text,length,is_long_context,metric_val,label_metric
"// license:GPL-2.0+
// copyright-holders:Angelo Salese, Jonathan Edwards, Christopher Edwards,Robbbert
/**************************************************************************************

    Basic Master Level 3 (MB-689x) (c) 1980 Hitachi

    Driver by Angelo Salese, Jonathan Edwards and Christopher Edwards

    TODO:
    - implement sound as a bml3bus slot device
    - account for hardware differences between MB-6890, MB-6891 and MB-6892
      (e.g. custom font support on the MB-6892)

**************************************************************************************/

#include ""emu.h""

#include ""cpu/m6809/m6809.h""
#include ""imagedev/cassette.h""
#include ""machine/6821pia.h""
#include ""machine/6850acia.h""
#include ""machine/clock.h""
#include ""machine/timer.h""
#include ""sound/2203intf.h""
#include ""sound/spkrdev.h""
#include ""sound/wave.h""
#include ""video/mc6845.h""

#include ""bus/bml3/bml3bus.h""
#include ""bus/bml3/bml3mp1802.h""
#include ""bus/bml3/bml3mp1805.h""
#include ""bus/bml3/bml3kanji.h""

#include ""screen.h""
#include ""speaker.h""

// System clock definitions, from the MB-6890 servce manual, p.48:

#define MASTER_CLOCK ( 32256000 )   // Master clock crystal (X1) frequency, 32.256 MHz.  ""fx"" in the manual.

#define D80_CLOCK ( MASTER_CLOCK / 2 )  // Graphics dot clock in 80-column mode. ~16 MHz.
#define D40_CLOCK ( D80_CLOCK / 2 )     // Graphics dot clock in 40-column mode.  ~8 MHz.

#define CPU_EXT_CLOCK ( D40_CLOCK / 2 ) // IC37, 4.032 MHz signal to EXTAL on the 6809 MPU.
#define CPU_CLOCK     ( CPU_EXT_CLOCK / 4 ) // Actual MPU clock frequency (""fE"" in the manual). The division yielding CPU_CLOCK is done in the 6809 itself.  Also used as the 40-column character clock.

#define C80_CLOCK ( CPU_EXT_CLOCK / 2 ) // 80-column character mode.  IC37, ""80CHRCK""; ~2 MHz.
#define C40_CLOCK ( CPU_CLOCK )         // 40-column character mode; same as MPU clock.  ""40CHRCK"";       ~1 MHz.

// Video signal clocks from the HD4650SSP CRTC (IC36)
// In the real hardware, the 80-/40-column Mode switch changes the CRTC character clock input source.  However, it just uses a different divider, so the end result is the same horizontal vsync frequency.
#define H_CLOCK ( C80_CLOCK / 128 ) // in 80-column mode
//#define H_CLOCK ( C40_CLOCK / 64 )    // in 40-column mode (either way the frequency is the same: 15.75 kHz)
#define V_CLOCK ( 2 * H_CLOCK / 525 )   // Vertical refresh rate comes out at exactly 60 Hz.

// TODO: ACIA RS-232C and cassette interface clocks (service manual p.67); perhaps reverse the order and simply divide by 2 from each previous frequency.
// IC111 (74LS157P) takes 16.128 MHz and 1.008 MHz TTL clock inputs.  The RS/C SW input line determines the mode (high -> RS-232C).

// Frequencies for RS-232C mode:
// D80_CLOCK / 840.0    // 19200 Hz
// D80_CLOCK / 420  // 38400 Hz
// D80_CLOCK / 210  // 76800 Hz
// D80_CLOCK / 105.0    // 153600 Hz

// Frequencies for cassette mode:
// / 13440  //1200
// / 6720   // 2400
// / 3360   // 4800
// / 1680   // 9600


class bml3_state : public driver_device
{
public:
	bml3_state(const machine_config &mconfig, device_type type, const char *tag)
		: driver_device(mconfig, type, tag)
		, m_maincpu(*this, ""maincpu"")
		, m_p_videoram(*this, ""vram"")
		, m_p_chargen(*this, ""chargen"")
		, m_bml3bus(*this, ""bml3bus"")
		, m_crtc(*this, ""crtc"")
		, m_cass(*this, ""cassette"")
		, m_speaker(*this, ""speaker"")
		, m_ym2203(*this, ""ym2203"")
		, m_acia(*this, ""acia"")
		, m_palette(*this, ""palette"")
	{
	}

	DECLARE_READ8_MEMBER(bml3_6845_r);
	DECLARE_WRITE8_MEMBER(bml3_6845_w);
	DECLARE_READ8_MEMBER(bml3_keyboard_r);
	DECLARE_WRITE8_MEMBER(bml3_keyboard_w);
	DECLARE_WRITE8_MEMBER(bml3_hres_reg_w);
	DECLARE_WRITE8_MEMBER(bml3_vres_reg_w);
	DECLARE_READ8_MEMBER(bml3_vram_r);
	DECLARE_WRITE8_MEMBER(bml3_vram_w);
	DECLARE_READ8_MEMBER(bml3_psg_latch_r);
	DECLARE_WRITE8_MEMBER(bml3_psg_latch_w);
	DECLARE_READ8_MEMBER(bml3_vram_attr_r);
	DECLARE_WRITE8_MEMBER(bml3_vram_attr_w);
	DECLARE_READ8_MEMBER(bml3_beep_r);
	DECLARE_WRITE8_MEMBER(bml3_beep_w);
	DECLARE_WRITE8_MEMBER(bml3_piaA_w);
	DECLARE_READ8_MEMBER(bml3_keyb_nmi_r);
	DECLARE_WRITE8_MEMBER(bml3_firq_mask_w);
	DECLARE_READ8_MEMBER(bml3_firq_status_r);
	DECLARE_WRITE8_MEMBER(relay_w);
	DECLARE_WRITE_LINE_MEMBER(bml3bus_nmi_w);
	DECLARE_WRITE_LINE_MEMBER(bml3bus_irq_w);
	DECLARE_WRITE_LINE_MEMBER(bml3bus_firq_w);
	DECLARE_WRITE_LINE_MEMBER(bml3_acia_tx_w);
	DECLARE_WRITE_LINE_MEMBER(bml3_acia_rts_w);
	DECLARE_WRITE_LINE_MEMBER(bml3_acia_irq_w);

	DECLARE_READ8_MEMBER(bml3_a000_r); DECLARE_WRITE8_MEMBER(bml3_a000_w);
	DECLARE_READ8_MEMBER(bml3_c000_r); DECLARE_WRITE8_MEMBER(bml3_c000_w);
	DECLARE_READ8_MEMBER(bml3_e000_r); DECLARE_WRITE8_MEMBER(bml3_e000_w);
	DECLARE_READ8_MEMBER(bml3_f000_r); DECLARE_WRITE8_MEMBER(bml3_f000_w);
	DECLARE_READ8_MEMBER(bml3_fff0_r); DECLARE_WRITE8_MEMBER(bml3_fff0_w);

	MC6845_UPDATE_ROW(crtc_update_row);

	// INTERRUPT_GEN_MEMBER(bml3_irq);
	INTERRUPT_GEN_MEMBER(bml3_timer_firq);
	TIMER_DEVICE_CALLBACK_MEMBER(bml3_c);
	TIMER_DEVICE_CALLBACK_MEMBER(bml3_p);
	TIMER_DEVICE_CALLBACK_MEMBER(keyboard_callback);
	DECLARE_READ8_MEMBER(bml3_ym2203_r);
	DECLARE_WRITE8_MEMBER(bml3_ym2203_w);

	void bml3mk2(machine_config &config);
	void bml3mk5(machine_config &config);
	void bml3(machine_config &config);
	void bml3_common(machine_config &config);
	void bml3_mem(address_map &map);
	void bml3mk2_mem(address_map &map);
	void bml3mk5_mem(address_map &map);
private:
	u8 m_hres_reg;
	u8 m_crtc_vreg[0x100];
	u8 m_psg_latch;
	u8 m_attr_latch;
	u8 m_vres_reg;
	bool m_keyb_interrupt_disabled;
	bool m_keyb_nmi_disabled; // not used yet
	bool m_keyb_counter_operation_disabled;
	u8 m_keyb_empty_scan;
	u8 m_keyb_scancode;
	bool m_keyb_capslock_led_on;
	bool m_keyb_hiragana_led_on;
	bool m_keyb_katakana_led_on;
	bool m_cassbit;
	bool m_cassold;
	u8 m_cass_data[4];
	virtual void machine_reset() override;
	virtual void machine_start() override;
	void m6845_change_clock(u8 setting);
	u8 m_crtc_index;
	std::unique_ptr<u8[]> m_extram;
	u8 m_firq_mask;
	u8 m_firq_status;
	required_device<cpu_device> m_maincpu;
	required_region_ptr<u8> m_p_videoram;
	required_region_ptr<u8> m_p_chargen;
	required_device<bml3bus_device> m_bml3bus;
	required_device<mc6845_device> m_crtc;
	required_device<cassette_image_device> m_cass;
	required_device<speaker_sound_device> m_speaker;
	optional_device<ym2203_device> m_ym2203;
	required_device<acia6850_device> m_acia;
	required_device<palette_device> m_palette;
};

#define mc6845_h_char_total     (m_crtc_vreg[0])
#define mc6845_h_display        (m_crtc_vreg[1])
#define mc6845_h_sync_pos       (m_crtc_vreg[2])
#define mc6845_sync_width       (m_crtc_vreg[3])
#define mc6845_v_char_total     (m_crtc_vreg[4])
#define mc6845_v_total_adj      (m_crtc_vreg[5])
#define mc6845_v_display        (m_crtc_vreg[6])
#define mc6845_v_sync_pos       (m_crtc_vreg[7])
#define mc6845_mode_ctrl        (m_crtc_vreg[8])
#define mc6845_tile_height      (m_crtc_vreg[9]+1)
#define mc6845_cursor_y_start   (m_crtc_vreg[0x0a])
#define mc6845_cursor_y_end     (m_crtc_vreg[0x0b])
#define mc6845_start_addr       (((m_crtc_vreg[0x0c]<<8) & 0x3f00) | (m_crtc_vreg[0x0d] & 0xff))
#define mc6845_cursor_addr      (((m_crtc_vreg[0x0e]<<8) & 0x3f00) | (m_crtc_vreg[0x0f] & 0xff))
#define mc6845_light_pen_addr   (((m_crtc_vreg[0x10]<<8) & 0x3f00) | (m_crtc_vreg[0x11] & 0xff))
#define mc6845_update_addr      (((m_crtc_vreg[0x12]<<8) & 0x3f00) | (m_crtc_vreg[0x13] & 0xff))



READ8_MEMBER( bml3_state::bml3_6845_r )
{
	if (offset)
		return m_crtc->register_r(space, 0);
	else
		return m_crtc->status_r(space, 0);
}

WRITE8_MEMBER( bml3_state::bml3_6845_w )
{
	if(offset == 0)
	{
		m_crtc_index = data;
		m_crtc->address_w(space, 0, data);
	}
	else
	{
		m_crtc_vreg[m_crtc_index] = data;
		m_crtc->register_w(space, 0, data);
	}
}

READ8_MEMBER( bml3_state::bml3_keyboard_r )
{
	u8 ret = m_keyb_scancode;
	m_keyb_scancode &= 0x7f;
	return ret;
}

WRITE8_MEMBER( bml3_state::bml3_keyboard_w )
{
	m_keyb_katakana_led_on = BIT(data, 0);
	m_keyb_hiragana_led_on = BIT(data, 1);
	m_keyb_capslock_led_on = BIT(data, 2);
	m_keyb_counter_operation_disabled = BIT(data, 3);
	m_keyb_interrupt_disabled = !BIT(data, 6);
	m_keyb_nmi_disabled = !BIT(data, 7);
}

void bml3_state::m6845_change_clock(u8 setting)
{
	int m6845_clock = CPU_CLOCK;    // CRTC and MPU are synchronous by default

	switch(setting & 0x88)
	{
		case 0x00: m6845_clock = C40_CLOCK; break; //320 x 200
		case 0x08: m6845_clock = C40_CLOCK; break; //320 x 200, interlace
		case 0x80: m6845_clock = C80_CLOCK; break; //640 x 200
		case 0x88: m6845_clock = C80_CLOCK; break; //640 x 200, interlace
	}

	m_crtc->set_clock(m6845_clock);
}

WRITE8_MEMBER( bml3_state::bml3_hres_reg_w )
{
	// MODE SEL register (see service manual p.43).
	/*
	x--- ---- ""W"" bit: 0 = 40 columns, 1 = 80 columns
	-x-- ---- ""HR"" bit: 0 = high resolution, 1 = normal
	--x- ---- ""C"" bit - ACIA mode: 0 = cassette, 1 = RS-232C
	---- -RGB Background colour
	*/

	m_hres_reg = data;

	m6845_change_clock((m_hres_reg & 0x80) | (m_vres_reg & 0x08));
}

WRITE8_MEMBER( bml3_state::bml3_vres_reg_w )
{
	// The MB-6890 had an interlaced video mode which was used for displaying Japanese (Hiragana and Katakana) text (8x16 character glyph bitmaps).
	/*
	---- x--- Interlace select: 0 = non-interlace, 1 = interlace
	*/
	m_vres_reg = data;

	m6845_change_clock((m_hres_reg & 0x80) | (m_vres_reg & 0x08));
}


READ8_MEMBER( bml3_state::bml3_vram_r )
{
	// Bit 7 masks reading back to the latch
	if (!BIT(m_attr_latch, 7))
	{
		m_attr_latch = m_p_videoram[offset+0x4000];
	}

	return m_p_videoram[offset];
}

WRITE8_MEMBER( bml3_state::bml3_vram_w )
{
	m_p_videoram[offset] = data;
	// color ram is 5-bit
	m_p_videoram[offset+0x4000] = m_attr_latch & 0x1F;
}

READ8_MEMBER( bml3_state::bml3_psg_latch_r)
{
	return 0x7f;
}

WRITE8_MEMBER( bml3_state::bml3_psg_latch_w)
{
	m_psg_latch = data;
}

READ8_MEMBER(bml3_state::bml3_ym2203_r)
{
	u8 dev_offs = ((m_psg_latch & 3) != 3);

	return m_ym2203->read(space, dev_offs);
}

WRITE8_MEMBER(bml3_state::bml3_ym2203_w)
{
	u8 dev_offs = ((m_psg_latch & 3) != 3);

	m_ym2203->write(space, dev_offs, data);
}

READ8_MEMBER( bml3_state::bml3_vram_attr_r)
{
	// C-REG-SELECT register
	// Reads from a VRAM address copy the corresponding 'colour RAM' address to the low-order 5 bits of this register as a side-effect
	// (unless MK bit indicates 'prohibit write')
	return m_attr_latch;
}

WRITE8_MEMBER( bml3_state::bml3_vram_attr_w)
{
	// C-REG-SELECT register
	// Writes to a VRAM address copy the low-order 5 bits of this register to the corresponding 'colour RAM' address as a side-effect
	/*
	x--- ---- ""MK"" bit: 0 = enable write, 1 = prohibit write
	---x ---- ""GC"" bit: 0 = character, 1 = graphic
	---- x--- ""RV"" bit: 0 = normal, 1 - reverse
	---- -RGB Foreground colour
	*/
	m_attr_latch = data;
}

READ8_MEMBER( bml3_state::bml3_beep_r)
{
	return -1; // BEEP status read?
}

WRITE8_MEMBER( bml3_state::bml3_beep_w)
{
	m_speaker->level_w(BIT(data, 7));
}

WRITE8_MEMBER( bml3_state::relay_w )
{
	m_cass->change_state(
		BIT(data,7) ? CASSETTE_MOTOR_ENABLED : CASSETTE_MOTOR_DISABLED, CASSETTE_MASK_MOTOR);
}

READ8_MEMBER( bml3_state::bml3_a000_r) { return m_extram[offset + 0xa000]; }
WRITE8_MEMBER( bml3_state::bml3_a000_w) { m_extram[offset + 0xa000] = data; }
READ8_MEMBER( bml3_state::bml3_c000_r) { return m_extram[offset + 0xc000]; }
WRITE8_MEMBER( bml3_state::bml3_c000_w) { m_extram[offset + 0xc000] = data; }
READ8_MEMBER( bml3_state::bml3_e000_r) { return m_extram[offset + 0xe000]; }
WRITE8_MEMBER( bml3_state::bml3_e000_w) { m_extram[offset + 0xe000] = data; }
READ8_MEMBER( bml3_state::bml3_f000_r) { return m_extram[offset + 0xf000]; }
WRITE8_MEMBER( bml3_state::bml3_f000_w) { m_extram[offset + 0xf000] = data; }
READ8_MEMBER( bml3_state::bml3_fff0_r) { return m_extram[offset + 0xfff0]; }
WRITE8_MEMBER( bml3_state::bml3_fff0_w) { m_extram[offset + 0xfff0] = data; }

READ8_MEMBER( bml3_state::bml3_keyb_nmi_r)
{
	return 0; // bit 7 used to signal a BREAK key pressure
}

WRITE8_MEMBER( bml3_state::bml3_firq_mask_w)
{
	m_firq_mask = data & 0x80;
	if(m_firq_mask)
	{
		m_firq_status = 0; // clear pending firq
		m_maincpu->set_input_line(M6809_FIRQ_LINE, CLEAR_LINE);
	}
}

READ8_MEMBER( bml3_state::bml3_firq_status_r )
{
	u8 res = m_firq_status << 7;
	m_firq_status = 0;
	m_maincpu->set_input_line(M6809_FIRQ_LINE, CLEAR_LINE);
	return res;
}

WRITE_LINE_MEMBER(bml3_state::bml3bus_nmi_w)
{
	m_maincpu->set_input_line(INPUT_LINE_NMI, state);
}

WRITE_LINE_MEMBER(bml3_state::bml3bus_irq_w)
{
	m_maincpu->set_input_line(M6809_IRQ_LINE, state);
}

WRITE_LINE_MEMBER(bml3_state::bml3bus_firq_w)
{
	m_maincpu->set_input_line(M6809_FIRQ_LINE, state);
}


void bml3_state::bml3_mem(address_map &map)
{
	map.unmap_value_high();
	map(0x0000, 0x03ff).ram();
	map(0x0400, 0x43ff).rw(this, FUNC(bml3_state::bml3_vram_r), FUNC(bml3_state::bml3_vram_w));
	map(0x4400, 0x9fff).ram();
	map(0xff40, 0xff46).noprw(); // lots of unknown reads and writes
	map(0xffc0, 0xffc3).rw(""pia"", FUNC(pia6821_device::read), FUNC(pia6821_device::write));
	map(0xffc4, 0xffc5).rw(m_acia, FUNC(acia6850_device::read), FUNC(acia6850_device::write));
	map(0xffc6, 0xffc7).rw(this, FUNC(bml3_state::bml3_6845_r), FUNC(bml3_state::bml3_6845_w));
	// KBNMI - Keyboard ""Break"" key non-maskable interrupt
	map(0xffc8, 0xffc8).r(this, FUNC(bml3_state::bml3_keyb_nmi_r)); // keyboard nmi
	// DIPSW - DIP switches on system mainboard
	map(0xffc9, 0xffc9).portr(""DSW"");
	// TIMER - System timer enable
	map(0xffca, 0xffca).r(this, FUNC(bml3_state::bml3_firq_status_r)); // timer irq
	// LPFLG - Light pen interrupt
//  AM_RANGE(0xffcb, 0xffcb)
	// MODE_SEL - Graphics mode select
	map(0xffd0, 0xffd0).w(this, FUNC(bml3_state::bml3_hres_reg_w));
	// TRACE - Trace counter
//  AM_RANGE(0xffd1, 0xffd1)
	// REMOTE - Remote relay control for cassette - bit 7
	map(0xffd2, 0xffd2).w(this, FUNC(bml3_state::relay_w));
	// MUSIC_SEL - Music select: toggle audio output level when rising
	map(0xffd3, 0xffd3).rw(this, FUNC(bml3_state::bml3_beep_r), FUNC(bml3_state::bml3_beep_w));
	// TIME_MASK - Prohibit timer IRQ
	map(0xffd4, 0xffd4).w(this, FUNC(bml3_state::bml3_firq_mask_w));
	// LPENBL - Light pen operation enable
	map(0xffd5, 0xffd5).noprw();
	// INTERLACE_SEL - Interlaced video mode (manual has ""INTERACE SEL""!)
	map(0xffd6, 0xffd6).w(this, FUNC(bml3_state::bml3_vres_reg_w));
//  AM_RANGE(0xffd7, 0xffd7) baud select
	// C_REG_SEL - Attribute register (character/video mode and colours)
	map(0xffd8, 0xffd8).rw(this, FUNC(bml3_state::bml3_vram_attr_r), FUNC(bml3_state::bml3_vram_attr_w));
	// KB - Keyboard mode register, interrupt control, keyboard LEDs
	map(0xffe0, 0xffe0).rw(this, FUNC(bml3_state::bml3_keyboard_r), FUNC(bml3_state::bml3_keyboard_w));
//  AM_RANGE(0xffe8, 0xffe8) bank register
//  AM_RANGE(0xffe9, 0xffe9) IG mode register
//  AM_RANGE(0xffea, 0xffea) IG enable register
	map(0xa000, 0xfeff).rom().region(""maincpu"", 0xa000);
	map(0xfff0, 0xffff).rom().region(""maincpu"", 0xfff0);
	map(0xa000, 0xbfff).w(this, FUNC(bml3_state::bml3_a000_w));
	map(0xc000, 0xdfff).w(this, FUNC(bml3_state::bml3_c000_w));
	map(0xe000, 0xefff).w(this, FUNC(bml3_state::bml3_e000_w));
	map(0xf000, 0xfeff).w(this, FUNC(bml3_state::bml3_f000_w));
	map(0xfff0, 0xffff).w(this, FUNC(bml3_state::bml3_fff0_w));

#if 0
	map(0xff00, 0xff00).rw(this, FUNC(bml3_state::bml3_ym2203_r), FUNC(bml3_state::bml3_ym2203_w));
	map(0xff02, 0xff02).rw(this, FUNC(bml3_state::bml3_psg_latch_r), FUNC(bml3_state::bml3_psg_latch_w)); // PSG address/data select
#endif
}

void bml3_state::bml3mk2_mem(address_map &map)
{
	bml3_mem(map);
	// TODO: anything to add here?

}

void bml3_state::bml3mk5_mem(address_map &map)
{
	bml3_mem(map);
	// TODO: anything to add here?

}

/* Input ports */

static INPUT_PORTS_START( bml3 )

	// DIP switches (service manual p.88)
	// Note the NEWON command reboots with a soft override for the DIP switch
	PORT_START(""DSW"")
	PORT_DIPNAME(     0x01, 0x01, ""BASIC/terminal mode"")
		PORT_DIPSETTING(0x00, ""Terminal mode"")
		PORT_DIPSETTING(0x01, ""BASIC mode"")
	PORT_DIPNAME(     0x02, 0x02, ""Interlaced video"")
		PORT_DIPSETTING(0x00, DEF_STR( Off ) )
		PORT_DIPSETTING(0x02, DEF_STR( On ))
	// This is overridden by the 'Mode' toggle button
	PORT_DIPNAME(     0x04, 0x04, ""40-/80-column"")
		PORT_DIPSETTING(0x00, ""40 chars/line"")
		PORT_DIPSETTING(0x04, ""80 chars/line"")
	PORT_DIPNAME(     0x08, 0x00, ""Video resolution"")
		PORT_DIPSETTING(0x00, ""High"")
		PORT_DIPSETTING(0x08, ""Low"")
	PORT_DIPNAME(     0x10, 0x00, ""Show PF key content"")
		PORT_DIPSETTING(0x00, DEF_STR ( Off ) )
		PORT_DIPSETTING(0x10, DEF_STR ( On ))
	PORT_DIPNAME(     0x20, 0x00, ""Terminal duplex"")
		PORT_DIPSETTING(0x00, ""Full duplex"")
		PORT_DIPSETTING(0x20, ""Half duplex"")
	PORT_DIPNAME(     0x40, 0x00, ""Terminal bits"")
		PORT_DIPSETTING(0x00, ""8 bits/char"")
		PORT_DIPSETTING(0x40, ""7 bits/char"")
	PORT_DIPNAME(     0x80, 0x00, ""Hiragana->Katakana"")
		PORT_DIPSETTING(    0x00, DEF_STR( Off ) )
		PORT_DIPSETTING(    0x80, DEF_STR( On ) )

// TODO: also model the CS jumper block?

	// RAM expansion configurations (see service manual p.76)
/*
    PORT_START(""RAM"")
    PORT_DIPNAME( 0x0003, 0x0002, ""RAM size"" )
    PORT_DIPSETTING(   0x0000, ""32 kiB (standard)"" )
    PORT_DIPSETTING(   0x0001, ""40 kiB (32 kiB + 8 kiB)"" )
    PORT_DIPSETTING(   0x0002, ""60 kiB (32 kiB + 28 kiB)"" )
*/

	PORT_START(""key1"") //0x00-0x1f
	PORT_BIT(0x00000001,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""Space"") PORT_CODE(KEYCODE_SPACE) PORT_CHAR(' ')
	PORT_BIT(0x00000002,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""Up"") PORT_CODE(KEYCODE_UP)
	PORT_BIT(0x00000004,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""? PAD"") PORT_CHAR('?')
	PORT_BIT(0x00000008,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""Left"") PORT_CODE(KEYCODE_LEFT)
	PORT_BIT(0x00000010,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""Down"") PORT_CODE(KEYCODE_DOWN)
	PORT_BIT(0x00000020,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""Right"") PORT_CODE(KEYCODE_RIGHT)
	PORT_BIT(0x00000040,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""Control"") PORT_CODE(KEYCODE_LCONTROL)
	PORT_BIT(0x00000080,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""Shift"")PORT_CODE(KEYCODE_LSHIFT)
	PORT_BIT(0x00000100,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""X2"")  // ???
	PORT_BIT(0x00000200,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""Caps Lock"") PORT_CODE(KEYCODE_CAPSLOCK)
	PORT_BIT(0x00000400,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""Kana Lock"") PORT_CODE(KEYCODE_NUMLOCK)
	PORT_BIT(0x00000800,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""Kana Shift"")  PORT_CODE(KEYCODE_LALT)
	PORT_BIT(0x00001000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""ESC"") PORT_CODE(KEYCODE_ESC)
	PORT_BIT(0x00002000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""8 PAD"") PORT_CODE(KEYCODE_8_PAD) PORT_CHAR('8')
	PORT_BIT(0x00004000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""9 PAD"") PORT_CODE(KEYCODE_9_PAD) PORT_CHAR('9')
	PORT_BIT(0x00008000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""*"") PORT_CODE(KEYCODE_ASTERISK) PORT_CHAR('*')
	PORT_BIT(0x00010000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""7"") PORT_CODE(KEYCODE_7) PORT_CHAR('7')
	PORT_BIT(0x00020000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""4"") PORT_CODE(KEYCODE_4) PORT_CHAR('4')
	PORT_BIT(0x00040000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""6"") PORT_CODE(KEYCODE_6) PORT_CHAR('6')
	PORT_BIT(0x00080000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""8"") PORT_CODE(KEYCODE_8) PORT_CHAR('8')
	PORT_BIT(0x00100000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""0"") PORT_CODE(KEYCODE_0) PORT_CHAR('0')
	PORT_BIT(0x00200000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""^"") PORT_CODE(KEYCODE_BACKSLASH)
	PORT_BIT(0x00400000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""-"") PORT_CODE(KEYCODE_MINUS) PORT_CHAR('-')
	PORT_BIT(0x00800000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""3"") PORT_CODE(KEYCODE_3) PORT_CHAR('3')
	PORT_BIT(0x01000000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""Delete"") PORT_CODE(KEYCODE_BACKSPACE)
	PORT_BIT(0x02000000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""5"") PORT_CODE(KEYCODE_5) PORT_CHAR('5')
	PORT_BIT(0x04000000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""1"") PORT_CODE(KEYCODE_1) PORT_CHAR('1')
	PORT_BIT(0x08000000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""2"") PORT_CODE(KEYCODE_2) PORT_CHAR('2')
	PORT_BIT(0x10000000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""9"") PORT_CODE(KEYCODE_9) PORT_CHAR('9')
	PORT_BIT(0x20000000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""7 PAD"") PORT_CODE(KEYCODE_7_PAD) PORT_CHAR('7')
	PORT_BIT(0x40000000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""Delete PAD"") //backspace
	PORT_BIT(0x80000000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""\\xC2\\xA5"") PORT_CODE(KEYCODE_TAB) // yen sign

	PORT_START(""key2"") //0x20-0x3f
	PORT_BIT(0x00000001,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""U"") PORT_CODE(KEYCODE_U)
	PORT_BIT(0x00000002,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""R"") PORT_CODE(KEYCODE_R)
	PORT_BIT(0x00000004,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""Y"") PORT_CODE(KEYCODE_Y)
	PORT_BIT(0x00000008,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""I"") PORT_CODE(KEYCODE_I)
	PORT_BIT(0x00000010,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""P"") PORT_CODE(KEYCODE_P)
	PORT_BIT(0x00000020,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""["") PORT_CODE(KEYCODE_OPENBRACE)
	PORT_BIT(0x00000040,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""@"") PORT_CODE(KEYCODE_EQUALS)
	PORT_BIT(0x00000080,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""0 PAD"") PORT_CODE(KEYCODE_0_PAD) PORT_CHAR('0')
	PORT_BIT(0x00000100,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""Q"") PORT_CODE(KEYCODE_Q)
	PORT_BIT(0x00000200,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""T"") PORT_CODE(KEYCODE_T)
	PORT_BIT(0x00000400,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""W"") PORT_CODE(KEYCODE_W)
	PORT_BIT(0x00000800,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""E"") PORT_CODE(KEYCODE_E)
	PORT_BIT(0x00001000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""O"") PORT_CODE(KEYCODE_O)
	PORT_BIT(0x00002000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME("". PAD"")  PORT_CODE(KEYCODE_DEL_PAD) PORT_CHAR('.')
	PORT_BIT(0x00004000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""HOME"") PORT_CODE(KEYCODE_HOME) //or cls?
	PORT_BIT(0x00008000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""ENTER"") PORT_CODE(KEYCODE_ENTER)
	PORT_BIT(0x00010000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""J"") PORT_CODE(KEYCODE_J)
	PORT_BIT(0x00020000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""F"") PORT_CODE(KEYCODE_F)
	PORT_BIT(0x00040000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""H"") PORT_CODE(KEYCODE_H)
	PORT_BIT(0x00080000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""K"") PORT_CODE(KEYCODE_K)
	PORT_BIT(0x00100000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME("";"") PORT_CODE(KEYCODE_COLON)
	PORT_BIT(0x00200000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""]"") PORT_CODE(KEYCODE_CLOSEBRACE)
	PORT_BIT(0x00400000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME("":"") PORT_CODE(KEYCODE_QUOTE)
	PORT_BIT(0x00800000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""4 PAD"") PORT_CODE(KEYCODE_4_PAD) PORT_CHAR('4')
	PORT_BIT(0x01000000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""A"") PORT_CODE(KEYCODE_A)
	PORT_BIT(0x02000000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""G"") PORT_CODE(KEYCODE_G)
	PORT_BIT(0x04000000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""S"") PORT_CODE(KEYCODE_S)
	PORT_BIT(0x08000000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""D"") PORT_CODE(KEYCODE_D)
	PORT_BIT(0x10000000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""L"") PORT_CODE(KEYCODE_L)
	PORT_BIT(0x20000000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""5 PAD"") PORT_CODE(KEYCODE_5_PAD) PORT_CHAR('5')
	PORT_BIT(0x40000000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""6 PAD"") PORT_CODE(KEYCODE_6_PAD) PORT_CHAR('6')
	PORT_BIT(0x80000000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""- PAD"") PORT_CODE(KEYCODE_MINUS_PAD) PORT_CHAR('-')

	PORT_START(""key3"") //0x40-0x5f
	PORT_BIT(0x00000001,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""M"") PORT_CODE(KEYCODE_M)
	PORT_BIT(0x00000002,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""V"") PORT_CODE(KEYCODE_V)
	PORT_BIT(0x00000004,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""N"") PORT_CODE(KEYCODE_N)
	PORT_BIT(0x00000008,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME("","") PORT_CODE(KEYCODE_COMMA)
	PORT_BIT(0x00000010,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""/"") PORT_CODE(KEYCODE_SLASH)
	PORT_BIT(0x00000020,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""/ PAD"") PORT_CODE(KEYCODE_SLASH_PAD) PORT_CHAR('/')
	PORT_BIT(0x00000040,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""_"") PORT_CODE(KEYCODE_TILDE)
	PORT_BIT(0x00000080,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""1 PAD"") PORT_CODE(KEYCODE_1_PAD) PORT_CHAR('1')
	PORT_BIT(0x00000100,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""Z"") PORT_CODE(KEYCODE_Z)
	PORT_BIT(0x00000200,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""B"") PORT_CODE(KEYCODE_B)
	PORT_BIT(0x00000400,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""X"") PORT_CODE(KEYCODE_X)
	PORT_BIT(0x00000800,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""C"") PORT_CODE(KEYCODE_C)
	PORT_BIT(0x00001000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""."") PORT_CODE(KEYCODE_STOP)
	PORT_BIT(0x00002000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""2 PAD"") PORT_CODE(KEYCODE_2_PAD) PORT_CHAR('2')
	PORT_BIT(0x00004000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""3 PAD"") PORT_CODE(KEYCODE_3_PAD) PORT_CHAR('3')
	PORT_BIT(0x00008000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""+"") PORT_CODE(KEYCODE_PLUS_PAD)
	PORT_BIT(0x00010000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""PF1"") PORT_CODE(KEYCODE_F1)
	PORT_BIT(0x00020000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""PF2"") PORT_CODE(KEYCODE_F2)
	PORT_BIT(0x00040000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""PF3"") PORT_CODE(KEYCODE_F3)
	PORT_BIT(0x00080000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""PF4"") PORT_CODE(KEYCODE_F4)
	PORT_BIT(0x00100000,IP_ACTIVE_HIGH,IPT_KEYBOARD) PORT_NAME(""PF5"") PORT_CODE(KEYCODE_F5)
	PORT_BIT(0xffe00000,IP_ACTIVE_HIGH,IPT_UNKNOWN)
INPUT_PORTS_END

MC6845_UPDATE_ROW( bml3_state::crtc_update_row )
{
	const rgb_t *palette = m_palette->palette()->entry_list_raw();
	// The MB-6890 has a 5-bit colour RAM region.  The meaning of the bits are:
	// 0: blue
	// 1: red
	// 2: green
	// 3: reverse/inverse video
	// 4: graphic (not character)

	u8 x=0,hf=0,xi=0,interlace=0,bgcolor=0,rawbits=0,dots[2],color=0,pen=0;
	bool reverse=0,graphic=0,lowres=0;
	u16 mem=0;

	interlace = (m_crtc_vreg[8] & 3) ? 1 : 0;
	lowres = BIT(m_hres_reg, 6);
	bgcolor = m_hres_reg & 7;

	if (interlace)
	{
		ra >>= 1;
		if (y > 0x176) return;
	}

	// redundant initializers to keep compiler happy
	dots[0] = dots[1] = 0;

	for(x=0; x<x_count; x++)
	{
		if (lowres)
			mem = (ma + x - 0x400) & 0x3fff;
		else
			mem = (ma + x + ra * x_count/40 * 0x400 -0x400) & 0x3fff;

		color = m_p_videoram[mem|0x4000] & 7;
		reverse = BIT(m_p_videoram[mem|0x4000], 3) ^ (x == cursor_x);
		graphic = BIT(m_p_videoram[mem|0x4000], 4);

		rawbits = m_p_videoram[mem];

		if (graphic)
		{
			if (lowres)
			{
				// low-res graphics, each tile has 8 bits arranged as follows:
				// 4 0
				// 5 1
				// 6 2
				// 7 3
				dots[0] = dots[1] = (rawbits >> ra/2 & 0x11) * 0xf;
			}
			else
			{
				dots[0] = dots[1] = rawbits;
			}
		}
		else
		{
			// character mode
			int tile = rawbits & 0x7f;
			int tile_bank = BIT(rawbits, 7);
			if (interlace)
			{
				dots[0] = m_p_chargen[(tile_bank<<11)|(tile<<4)|(ra<<1)];
				dots[1] = m_p_chargen[(tile_bank<<11)|(tile<<4)|(ra<<1)|tile_bank];
			}
			else
			{
				dots[0] = dots[1] = m_p_chargen[(tile<<4)|(ra<<1)|tile_bank];
			}
		}

		for(hf=0;hf<=interlace;hf++)
		{
			for(xi=0;xi<8;xi++)
			{
				if(reverse)
					pen = (dots[hf] >> (7-xi) & 1) ? bgcolor : color;
				else
					pen = (dots[hf] >> (7-xi) & 1) ? color : bgcolor;

				bitmap.pix32(y, x*8+xi) = palette[pen];
				// when the mc6845 device gains full interlace&video support, replace the line above with the line below
				// bitmap.pix32(y*(interlace+1)+hf, x*8+xi) = palette[pen];
			}
		}
	}
}


TIMER_DEVICE_CALLBACK_MEMBER(bml3_state::keyboard_callback)
{
	static const char *const portnames[3] = { ""key1"",""key2"",""key3"" };
	int i,port_i;
	bool trigger = false;

	if(!(m_keyb_scancode & 0x80))
	{
		m_keyb_scancode = (m_keyb_scancode + 1) & 0x7F;
		if (m_keyb_counter_operation_disabled)
		{
			m_keyb_scancode &= 0x7;
		}

		if (m_keyb_scancode == 0x7F)
		{
			if (m_keyb_empty_scan == 1)
			{
				// full scan completed with no keypress
				trigger = true;
			}
			if (m_keyb_empty_scan > 0)
				m_keyb_empty_scan--;
		}
		else if (m_keyb_scancode < 32*3)
		{
			port_i = m_keyb_scancode / 32;
			i = m_keyb_scancode % 32;
			if((ioport(portnames[port_i])->read()>>i) & 1)
			{
				m_keyb_empty_scan = 2;
				trigger = true;
			}
		}
		if (trigger)
		{
			m_keyb_scancode |= 0x80;
			if (!m_keyb_interrupt_disabled)
				m_maincpu->set_input_line(M6809_IRQ_LINE, HOLD_LINE);
		}
		/* Don't need this apparently...
		else
		{
		    m_maincpu->set_input_line(M6809_IRQ_LINE, CLEAR_LINE);
		}
		*/
	}
}

TIMER_DEVICE_CALLBACK_MEMBER( bml3_state::bml3_p )
{
	/* cassette - turn 1200/2400Hz to a bit */
	m_cass_data[1]++;
	u8 cass_ws = (m_cass->input() > +0.03) ? 1 : 0;

	if (cass_ws != m_cass_data[0])
	{
		m_cass_data[0] = cass_ws;
		m_acia->write_rxd((m_cass_data[1] < 12) ? 1 : 0);
		m_cass_data[1] = 0;
	}
}

#if 0
INTERRUPT_GEN_MEMBER(bml3_state::bml3_irq)
{
	m_maincpu->set_input_line(M6809_IRQ_LINE, HOLD_LINE);
}
#endif


INTERRUPT_GEN_MEMBER(bml3_state::bml3_timer_firq)
{
	if(!m_firq_mask)
	{
		m_maincpu->set_input_line(M6809_FIRQ_LINE, ASSERT_LINE);
		m_firq_status = 1;
	}
}

void bml3_state::machine_start()
{
	m_extram = std::make_unique<u8[]>(0x10000);
	m_psg_latch = 0;
	m_attr_latch = 0;
	m_vres_reg = 0;
	m_keyb_interrupt_disabled = 0;
	m_keyb_nmi_disabled = 0;
	m_keyb_counter_operation_disabled = 0;
	m_keyb_empty_scan = 0;
	m_keyb_scancode = 0;
	m_keyb_capslock_led_on = 0;
	m_keyb_hiragana_led_on = 0;
	m_keyb_katakana_led_on = 0;
	m_crtc_index = 0;
	m_firq_status = 0;
	m_cassbit = 0;
	m_cassold = 0;
}

void bml3_state::machine_reset()
{
	address_space &mem = m_maincpu->space(AS_PROGRAM);

	/* defaults */
	mem.install_rom(0xa000, 0xfeff,memregion(""maincpu"")->base() + 0xa000);
	mem.install_rom(0xfff0, 0xffff,memregion(""maincpu"")->base() + 0xfff0);
	mem.install_write_handler(0xa000, 0xbfff, write8_delegate(FUNC(bml3_state::bml3_a000_w), this),0);
	mem.install_write_handler(0xc000, 0xdfff, write8_delegate(FUNC(bml3_state::bml3_c000_w), this),0);
	mem.install_write_handler(0xe000, 0xefff, write8_delegate(FUNC(bml3_state::bml3_e000_w), this),0);
	mem.install_write_handler(0xf000, 0xfeff, write8_delegate(FUNC(bml3_state::bml3_f000_w), this),0);
	mem.install_write_handler(0xfff0, 0xffff, write8_delegate(FUNC(bml3_state::bml3_fff0_w), this),0);

	m_firq_mask = -1; // disable firq
}

WRITE8_MEMBER(bml3_state::bml3_piaA_w)
{
	address_space &mem = m_maincpu->space(AS_PROGRAM);
	/* ROM banking:
	-0-- --0- 0xa000 - 0xbfff ROM R RAM W
	-1-- --0- 0xa000 - 0xbfff RAM R/W
	-x-- --1- 0xa000 - 0xbfff no change
	0--- -0-- 0xc000 - 0xdfff ROM R RAM W
	1--- -0-- 0xc000 - 0xdfff RAM R/W
	x--- -1-- 0xc000 - 0xdfff no change
	0--- 0--- 0xe000 - 0xefff ROM R RAM W
	1--- 0--- 0xe000 - 0xefff RAM R/W
	x--- 1--- 0xe000 - 0xefff no change
	---- ---x 0xf000 - 0xfeff (0) ROM R RAM W (1) RAM R/W
	---- --x- 0xfff0 - 0xffff (0) ROM R RAM W (1) RAM R/W
	*/
	logerror(""Check banking PIA A -> %02x\\n"",data);

	if(!(data & 0x2))
	{
		if(data & 0x40)
		{
			mem.install_readwrite_handler(0xa000, 0xbfff,
				read8_delegate(FUNC(bml3_state::bml3_a000_r), this),
				write8_delegate(FUNC(bml3_state::bml3_a000_w), this), 0);
		}
		else
		{
			mem.install_rom(0xa000, 0xbfff,
				memregion(""maincpu"")->base() + 0xa000);
			mem.install_write_handler(0xa000, 0xbfff,
				write8_delegate(FUNC(bml3_state::bml3_a000_w), this),
				0);
		}
	}

	if(!(data & 0x4))
	{
		if(data & 0x40)
		{
			mem.install_readwrite_handler(0xc000, 0xdfff,
				read8_delegate(FUNC(bml3_state::bml3_c000_r), this),
				write8_delegate(FUNC(bml3_state::bml3_c000_w), this), 0);
		}
		else
		{
			mem.install_rom(0xc000, 0xdfff,
				memregion(""maincpu"")->base() + 0xc000);
			mem.install_write_handler(0xc000, 0xdfff,
				write8_delegate(FUNC(bml3_state::bml3_c000_w), this),
				0);
		}
	}

	if(!(data & 0x8))
	{
		if(data & 0x80)
		{
			mem.install_readwrite_handler(0xe000, 0xefff,
				read8_delegate(FUNC(bml3_state::bml3_e000_r), this),
				write8_delegate(FUNC(bml3_state::bml3_e000_w), this), 0);
		}
		else
		{
			mem.install_rom(0xe000, 0xefff,
				memregion(""maincpu"")->base() + 0xe000);
			mem.install_write_handler(0xe000, 0xefff,
				write8_delegate(FUNC(bml3_state::bml3_e000_w), this),
				0);
		}
	}

	if(data & 1)
	{
		mem.install_readwrite_handler(0xf000, 0xfeff,
			read8_delegate(FUNC(bml3_state::bml3_f000_r), this),
			write8_delegate(FUNC(bml3_state::bml3_f000_w), this), 0);
	}
	else
	{
		mem.install_rom(0xf000, 0xfeff,
			memregion(""maincpu"")->base() + 0xf000);
		mem.install_write_handler(0xf000, 0xfeff,
			write8_delegate(FUNC(bml3_state::bml3_f000_w), this),
			0);
	}

	if(data & 2)
	{
		mem.install_readwrite_handler(0xfff0, 0xffff,
			read8_delegate(FUNC(bml3_state::bml3_fff0_r), this),
			write8_delegate(FUNC(bml3_state::bml3_fff0_w), this), 0);
	}
	else
	{
		mem.install_rom(0xfff0, 0xffff,
			memregion(""maincpu"")->base() + 0xfff0);
		mem.install_write_handler(0xfff0, 0xffff,
			write8_delegate(FUNC(bml3_state::bml3_fff0_w), this),
			0);
	}
}

WRITE_LINE_MEMBER( bml3_state::bml3_acia_tx_w )
{
	//logerror(""%02x TAPE\\n"",state);
	m_cassbit = state;
}


WRITE_LINE_MEMBER( bml3_state::bml3_acia_rts_w )
{
	logerror(""%02x TAPE RTS\\n"",state);
}

WRITE_LINE_MEMBER( bml3_state::bml3_acia_irq_w )
{
	logerror(""%02x TAPE IRQ\\n"",state);
}

TIMER_DEVICE_CALLBACK_MEMBER( bml3_state::bml3_c )
{
	m_cass_data[3]++;

	if (m_cassbit != m_cassold)
	{
		m_cass_data[3] = 0;
		m_cassold = m_cassbit;
	}

	if (m_cassbit)
		m_cass->output(BIT(m_cass_data[3], 0) ? -1.0 : +1.0); // 2400Hz
	else
		m_cass->output(BIT(m_cass_data[3], 1) ? -1.0 : +1.0); // 1200Hz
}

#if 0
static const ay8910_interface ay8910_config =
{
	AY8910_LEGACY_OUTPUT,
	AY8910_DEFAULT_LOADS,
	DEVCB_NOOP, // read A
	DEVCB_NOOP, // read B
	DEVCB_NOOP, // write A
	DEVCB_NOOP  // write B
};
#endif

static SLOT_INTERFACE_START(bml3_cards)
	SLOT_INTERFACE(""bml3mp1802"", BML3BUS_MP1802)  /* MP-1802 Floppy Controller Card */
	SLOT_INTERFACE(""bml3mp1805"", BML3BUS_MP1805)  /* MP-1805 Floppy Controller Card */
	SLOT_INTERFACE(""bml3kanji"",  BML3BUS_KANJI)
SLOT_INTERFACE_END


MACHINE_CONFIG_START(bml3_state::bml3_common)
	/* basic machine hardware */
	MCFG_CPU_ADD(""maincpu"",M6809, CPU_CLOCK)
	MCFG_CPU_VBLANK_INT_DRIVER(""screen"", bml3_state,  bml3_timer_firq)
//  MCFG_CPU_PERIODIC_INT_DRIVER(bml3_state, bml3_firq, 45)

//  MCFG_MACHINE_RESET_OVERRIDE(bml3_state,bml3)

	/* video hardware */
	MCFG_SCREEN_ADD(""screen"", RASTER)
	MCFG_SCREEN_REFRESH_RATE(60)
	MCFG_SCREEN_VBLANK_TIME(ATTOSECONDS_IN_USEC(2400)) /* Service manual specifies ""Raster return period"" as 2.4 ms (p.64), although the total vertical non-displaying time seems to be 4 ms. */
	MCFG_SCREEN_SIZE(640, 400)
	MCFG_SCREEN_VISIBLE_AREA(0, 320-1, 0, 200-1)
	MCFG_SCREEN_UPDATE_DEVICE(""crtc"", mc6845_device, screen_update)
	MCFG_PALETTE_ADD_3BIT_BRG(""palette"")

	/* Devices */
	// CRTC clock should be synchronous with the CPU clock.
	MCFG_MC6845_ADD(""crtc"", H46505, ""screen"", CPU_CLOCK)
	MCFG_MC6845_SHOW_BORDER_AREA(false)
	MCFG_MC6845_CHAR_WIDTH(8)
	MCFG_MC6845_UPDATE_ROW_CB(bml3_state, crtc_update_row)

	// fire once per scan of an individual key
	// According to the service manual (p.65), the keyboard timer is driven by the horizontal video sync clock.
	MCFG_TIMER_DRIVER_ADD_PERIODIC(""keyboard_timer"", bml3_state, keyboard_callback, attotime::from_hz(H_CLOCK/2))
	MCFG_TIMER_DRIVER_ADD_PERIODIC(""bml3_c"", bml3_state, bml3_c, attotime::from_hz(4800))
	MCFG_TIMER_DRIVER_ADD_PERIODIC(""bml3_p"", bml3_state, bml3_p, attotime::from_hz(40000))

	MCFG_DEVICE_ADD(""pia"", PIA6821, 0)
	MCFG_PIA_WRITEPA_HANDLER(WRITE8(bml3_state, bml3_piaA_w))

	MCFG_DEVICE_ADD(""acia"", ACIA6850, 0)
	MCFG_ACIA6850_TXD_HANDLER(WRITELINE(bml3_state, bml3_acia_tx_w))
	MCFG_ACIA6850_RTS_HANDLER(WRITELINE(bml3_state, bml3_acia_rts_w))
	MCFG_ACIA6850_IRQ_HANDLER(WRITELINE(bml3_state, bml3_acia_irq_w))

	MCFG_DEVICE_ADD(""acia_clock"", CLOCK, 9600) // 600 baud x 16(divider) = 9600
	MCFG_CLOCK_SIGNAL_HANDLER(DEVWRITELINE(""acia"", acia6850_device, write_txc))
	MCFG_DEVCB_CHAIN_OUTPUT(DEVWRITELINE(""acia"", acia6850_device, write_rxc))

	MCFG_CASSETTE_ADD( ""cassette"" )

	/* Audio */
	MCFG_SPEAKER_STANDARD_MONO(""mono"")
	MCFG_SOUND_WAVE_ADD(WAVE_TAG, ""cassette"")
	MCFG_SOUND_ROUTE(ALL_OUTPUTS, ""mono"", 0.25)
	MCFG_SOUND_ADD(""speaker"", SPEAKER_SOUND, 0)
	MCFG_SOUND_ROUTE(ALL_OUTPUTS, ""mono"", 0.50)

	/* slot devices */
	MCFG_DEVICE_ADD(""bml3bus"", BML3BUS, 0)
	MCFG_BML3BUS_CPU(""maincpu"")
	MCFG_BML3BUS_OUT_NMI_CB(WRITELINE(bml3_state, bml3bus_nmi_w))
	MCFG_BML3BUS_OUT_IRQ_CB(WRITELINE(bml3_state, bml3bus_irq_w))
	MCFG_BML3BUS_OUT_FIRQ_CB(WRITELINE(bml3_state, bml3bus_firq_w))
	/* Default to MP-1805 disk (3"" or 5.25"" SS/SD), as our MB-6892 ROM dump includes
	   the MP-1805 ROM.
	   User may want to switch this to MP-1802 (5.25"" DS/DD).
	   Note it isn't feasible to use both, as they each place boot ROM at F800.
	 */
	MCFG_BML3BUS_SLOT_ADD(""bml3bus"", ""sl1"", bml3_cards, ""bml3mp1805"")
	MCFG_BML3BUS_SLOT_ADD(""bml3bus"", ""sl2"", bml3_cards, nullptr)
	MCFG_BML3BUS_SLOT_ADD(""bml3bus"", ""sl3"", bml3_cards, nullptr)
	MCFG_BML3BUS_SLOT_ADD(""bml3bus"", ""sl4"", bml3_cards, nullptr)
	MCFG_BML3BUS_SLOT_ADD(""bml3bus"", ""sl5"", bml3_cards, nullptr)
	MCFG_BML3BUS_SLOT_ADD(""bml3bus"", ""sl6"", bml3_cards, ""bml3kanji"")

MACHINE_CONFIG_END

MACHINE_CONFIG_START(bml3_state::bml3)
	bml3_common(config);
	MCFG_CPU_MODIFY( ""maincpu"" )
	MCFG_CPU_PROGRAM_MAP(bml3_mem)

#if 0
	// TODO: slot device for sound card
	// audio
	MCFG_SOUND_ADD(""ym2203"", YM2203, 2000000) //unknown clock / divider
	MCFG_YM2203_AY8910_INTF(&ay8910_config)
	MCFG_SOUND_ROUTE(0, ""mono"", 0.25)
	MCFG_SOUND_ROUTE(1, ""mono"", 0.25)
	MCFG_SOUND_ROUTE(2, ""mono"", 0.50)
	MCFG_SOUND_ROUTE(3, ""mono"", 0.50)
#endif
MACHINE_CONFIG_END

MACHINE_CONFIG_START(bml3_state::bml3mk2)
	bml3_common(config);
	MCFG_CPU_MODIFY( ""maincpu"" )
	MCFG_CPU_PROGRAM_MAP(bml3mk2_mem)

	// TODO: anything to add here?
MACHINE_CONFIG_END

MACHINE_CONFIG_START(bml3_state::bml3mk5)
	bml3_common(config);
	MCFG_CPU_MODIFY( ""maincpu"" )
	MCFG_CPU_PROGRAM_MAP(bml3mk5_mem)

	// TODO: anything to add here?
MACHINE_CONFIG_END



/* ROM definition */
ROM_START( bml3 )
	ROM_REGION( 0x10000, ""maincpu"", ROMREGION_ERASEFF )
//  ROM_LOAD( ""l3bas.rom"", 0xa000, 0x6000, BAD_DUMP CRC(d81baa07) SHA1(a8fd6b29d8c505b756dbf5354341c48f9ac1d24d)) //original, 24k isn't a proper rom size!
	// TODO: replace with MB-6890 ROMs (these are from an MB-6892)
	ROM_LOAD( ""598 p16611.ic3"", 0xa000, 0x2000, BAD_DUMP CRC(954b9bad) SHA1(047948fac6808717c60a1d0ac9205a5725362430))
	ROM_LOAD( ""599 p16561.ic4"", 0xc000, 0x2000, BAD_DUMP CRC(b27a48f5) SHA1(94cb616df4caa6415c5076f9acdf675acb7453e2))
	// TODO: Replace checksums with a ROM dump without a disk controller patch (checksums here are inclusive of the MP1805 patch)
	ROM_LOAD( ""600 p16681.ic5"", 0xe000, 0x2000, BAD_DUMP CRC(fe3988a5) SHA1(edc732f1cd421e0cf45ffcfc71c5589958ceaae7))

	ROM_REGION( 0x1000, ""chargen"", 0 )
	ROM_LOAD(""font.rom"", 0x00000, 0x1000, BAD_DUMP CRC(0b6f2f10) SHA1(dc411b447ca414e94843636d8b5f910c954581fb) ) // handcrafted

	ROM_REGION( 0x8000, ""vram"", ROMREGION_ERASEFF )
ROM_END

ROM_START( bml3mk2 )
	ROM_REGION( 0x10000, ""maincpu"", ROMREGION_ERASEFF )
//  ROM_LOAD( ""l3bas.rom"", 0xa000, 0x6000, BAD_DUMP CRC(d81baa07) SHA1(a8fd6b29d8c505b756dbf5354341c48f9ac1d24d)) //original, 24k isn't a proper rom size!
	// TODO: replace with MB-6891 ROMs (these are from an MB-6892)
	ROM_LOAD( ""598 p16611.ic3"", 0xa000, 0x2000, BAD_DUMP CRC(954b9bad) SHA1(047948fac6808717c60a1d0ac9205a5725362430))
	ROM_LOAD( ""599 p16561.ic4"", 0xc000, 0x2000, BAD_DUMP CRC(b27a48f5) SHA1(94cb616df4caa6415c5076f9acdf675acb7453e2))
	ROM_LOAD( ""600 p16681.ic5"", 0xe000, 0x2000, BAD_DUMP CRC(fe3988a5) SHA1(edc732f1cd421e0cf45ffcfc71c5589958ceaae7))

	ROM_REGION( 0x1000, ""chargen"", 0 )
	ROM_LOAD(""font.rom"", 0x00000, 0x1000, BAD_DUMP CRC(0b6f2f10) SHA1(dc411b447ca414e94843636d8b5f910c954581fb) ) // handcrafted

	ROM_REGION( 0x8000, ""vram"", ROMREGION_ERASEFF )
ROM_END

ROM_START( bml3mk5 )
	ROM_REGION( 0x10000, ""maincpu"", ROMREGION_ERASEFF )
//  ROM_LOAD( ""l3bas.rom"", 0xa000, 0x6000, BAD_DUMP CRC(d81baa07) SHA1(a8fd6b29d8c505b756dbf5354341c48f9ac1d24d)) //original, 24k isn't a proper rom size!
	/* Handcrafted ROMs, rom labels and contents might not match */
	ROM_LOAD( ""598 p16611.ic3"", 0xa000, 0x2000, BAD_DUMP CRC(954b9bad) SHA1(047948fac6808717c60a1d0ac9205a5725362430))
	ROM_LOAD( ""599 p16561.ic4"", 0xc000, 0x2000, BAD_DUMP CRC(b27a48f5) SHA1(94cb616df4caa6415c5076f9acdf675acb7453e2))
	// TODO: Replace checksums with a ROM dump without a disk controller patch (checksums here are inclusive of the MP1805 patch)
	ROM_LOAD( ""600 p16681.ic5"", 0xe000, 0x2000, BAD_DUMP CRC(fe3988a5) SHA1(edc732f1cd421e0cf45ffcfc71c5589958ceaae7))

	ROM_REGION( 0x1000, ""chargen"", 0 )
	ROM_LOAD(""font.rom"", 0x00000, 0x1000, BAD_DUMP CRC(0b6f2f10) SHA1(dc411b447ca414e94843636d8b5f910c954581fb) ) // handcrafted

	ROM_REGION( 0x8000, ""vram"", ROMREGION_ERASEFF )
ROM_END

/* Driver */

/*    YEAR  NAME    PARENT  COMPAT   MACHINE    INPUT  STATE       INIT  COMPANY    FULLNAME                               FLAGS */
COMP( 1980, bml3,   0,      0,       bml3,      bml3,  bml3_state, 0,    ""Hitachi"", ""MB-6890 Basic Master Level 3"",        MACHINE_NOT_WORKING)
COMP( 1982, bml3mk2,bml3,   0,       bml3mk2,   bml3,  bml3_state, 0,    ""Hitachi"", ""MB-6891 Basic Master Level 3 Mark 2"", MACHINE_NOT_WORKING)
COMP( 1983, bml3mk5,bml3,   0,       bml3mk5,   bml3,  bml3_state, 0,    ""Hitachi"", ""MB-6892 Basic Master Level 3 Mark 5"", MACHINE_NOT_WORKING)
",16241,True,2732.492557592215,median
"
#include ""tsMuxer.h""

#include ""pesPacket.h""
#include ""tsPacket.h""
//#include ""tsEncoder.h""
#include <fs/textfile.h>

#include ""ac3StreamReader.h""
#include ""avCodecs.h""
#include ""dtsStreamReader.h""
#include ""dvbSubStreamReader.h""
#include ""h264StreamReader.h""
#include ""iso_writer.h""
#include ""lpcmStreamReader.h""
#include ""mpegAudioStreamReader.h""
#include ""mpegStreamReader.h""
#include ""muxerManager.h""
#include ""vodCoreException.h""

#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#endif

using namespace std;

int V3_flags = 0;
int HDR10_metadata[6] = {0, 0, 0, 0, 0, 0};
bool isV3() { return V3_flags & HDMV_V3; }
bool is4K() { return V3_flags & FOUR_K; }

const static uint64_t M_PCR_DELTA = 7000;
const static uint64_t SIT_INTERVAL = 76900;
// const static uint64_t M_CBR_PCR_DELTA = 2250;
const static uint64_t M_CBR_PCR_DELTA = 7000;

static const uint8_t PES_INT_AC3_ID = 0x80;
static const uint8_t PES_INT_DTS_ID = 0x8a;
// static const uint8_t PES_INT_LPCM_ID  = 0xa0;
static const uint8_t PES_INT_SUB_ID = 0x20;

// static const int64_t FIXED_PTS_OFFSET = 27593l;

// static const int64_t FIXED_PCR_OFFSET = 45000;
static const int64_t DEFAULT_VBV_BUFFER_LEN = 500;  // default 500 ms vbv buffer
// static const int64_t FIXED_PCR_OFFSET = 8589934592ll - 90000ll*10ll;

// static const uint64_t FIXED_PCR_OFFSET = 0;

static const int PAT_PID = 0;
static const int SIT_PID = 0x1f;
static const int NULL_PID = 8191;

uint8_t DefaultSitTableOne[] = {
    0x47, 0x40, 0x1f, 0x10, 0x00, 0x7f, 0xf0, 0x19, 0xff, 0xff, 0xc1, 0x00, 0x00, 0xf0, 0x0a, 0x63, 0x08, 0xc1, 0x5a,
    0xae, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x01, 0x80, 0x00, 0x34, 0x1e, 0xe7, 0x4e, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};

TSMuxer::TSMuxer(MuxerManager* owner) : AbstractMuxer(owner)
{
    m_m2tsMode = false;
    m_vbvLen = DEFAULT_VBV_BUFFER_LEN * 90;
    m_lastPESDTS = -1;
    m_cbrBitrate = -1;  // mux CBR if bitrate specifed
    m_minBitrate = -1;
    m_pcrOnVideo = false;
    m_endStreamDTS = 0;
    m_prevM2TSPCROffset = 0;
    m_pesPID = 0;
    m_lastTSIndex = -1;
    m_lastPesLen = -1;
    m_lastMuxedDts = -1;
    m_lastPCR = -1;
    m_lastPMTPCR = -1;
    m_lastSITPCR = -1;
    m_nullCnt = 0;
    m_pmtCnt = 0;  // 2;
    m_patCnt = 0;  // 2;
    m_sitCnt = 1;
    m_needTruncate = false;
    m_videoTrackCnt = 0;
    m_DVvideoTrackCnt = 0;
    m_videoSecondTrackCnt = 0;
    m_audioTrackCnt = 0;
    m_secondaryAudioTrackCnt = 0;
    m_pgsTrackCnt = 0;
    m_beforePCRDataWrited = 0;
    m_useNewStyleAudioPES = false;
    m_minDts = -1;
    m_pcrBits = 0;
    m_pcr_delta = -1;
    m_patPmtDelta = -1;
    m_firstPts.push_back(-1);
    m_lastPts.push_back(-1);
    m_muxedPacketCnt.push_back(0);
    m_interliaveInfo.push_back(std::vector<int32_t>());
    m_pesIFrame = false;
    m_pesSpsPps = false;
    m_computeMuxStats = false;
    m_pmtFrames = 0;
    m_curFileStartPts = 0;  // FIXED_PTS_OFFSET;
    m_splitSize = m_splitDuration = 0;
    m_curFileNum = 0;
    m_bluRayMode = false;
    m_hdmvDescriptors = false;
    m_lastGopNullCnt = 0;
    m_outBufLen = 0;
    m_pesData.reserve(1024 * 128);
    // m_iFrameFound = false;
    m_mainStreamIndex = -1;
    m_muxFile = 0;
    m_isExternalFile = false;
    m_writeBlockSize = 0;
    m_frameSize = 188;

    m_processedBlockSize = 0;
    m_sublingMuxer = 0;
    m_outBuf = 0;
    m_masterMode = false;
    m_subMode = false;
    setPtsOffset(0);
    m_canSwithBlock = true;
    m_additionCLPISize = 0;
#ifdef _DEBUG
    m_lastProcessedDts = -1000000000;
    m_lastStreamIndex = -1;
#endif
}

void TSMuxer::setPtsOffset(int64_t value)
{
    m_timeOffset = value;
    m_fixed_pcr_offset = m_timeOffset - DEFAULT_VBV_BUFFER_LEN * 90;
    m_prevM2TSPCR = m_fixed_pcr_offset * 300;
}

void TSMuxer::internalReset() { m_outBufLen = 0; }

TSMuxer::~TSMuxer()
{
    delete[] m_outBuf;
    if (!m_isExternalFile)
        delete m_muxFile;
}

void TSMuxer::setVBVBufferLen(int value)
{
    m_vbvLen = (int64_t)value * 90;
    m_fixed_pcr_offset = m_timeOffset - m_vbvLen;
    if (m_fixed_pcr_offset < 0)
        m_fixed_pcr_offset = 0;
    m_prevM2TSPCR = m_fixed_pcr_offset * 300;
}

void TSMuxer::intAddStream(const std::string& streamName, const std::string& codecName, int streamIndex,
                           const map<string, string>& params, AbstractStreamReader* codecReader)
{
    int descriptorLen = 0;
    uint8_t descrBuffer[1024];
    if (codecReader != 0)
        descriptorLen = codecReader->getTSDescriptor(descrBuffer, m_bluRayMode, m_hdmvDescriptors);

    if (codecName[0] == 'V')
        m_mainStreamIndex = streamIndex;
    else if (codecName[0] == 'A' && m_mainStreamIndex == -1)
        m_mainStreamIndex = streamIndex;

    string lang;
    map<string, string>::const_iterator itr = params.find(""lang"");
    if (itr != params.end())
        lang = itr->second;

    int tsStreamIndex = streamIndex + 16;
    bool isSecondary = codecReader->isSecondary();

    if (codecName[0] == 'V')
    {
        if (!isSecondary)
        {
            int doubleMux = (m_subMode || m_masterMode) ? 2 : 1;
            if (codecReader->getStreamHDR() == 4)
            {
                tsStreamIndex = 0x1015 + m_DVvideoTrackCnt * doubleMux;
                m_DVvideoTrackCnt++;
            }
            else
            {
                tsStreamIndex = 0x1011 + m_videoTrackCnt * doubleMux;
                m_videoTrackCnt++;
                V3_flags |= NON_DV_TRACK;
            }
            if (m_subMode)
                tsStreamIndex++;
        }
        else
        {
            tsStreamIndex = 0x1B00 + m_videoSecondTrackCnt;
            m_videoSecondTrackCnt++;
        }
    }
    else if (codecName[0] == 'A')
    {
        if (isSecondary)
        {
            tsStreamIndex = 0x1A00 + m_secondaryAudioTrackCnt;
            m_secondaryAudioTrackCnt++;
        }
        else
        {
            tsStreamIndex = 0x1100 + m_audioTrackCnt;
            m_audioTrackCnt++;
        }
    }
    else if (codecName == ""S_HDMV/PGS"")
    {
        tsStreamIndex = (V3_flags & 0x1e ? 0x12A0 : 0x1200) + m_pgsTrackCnt;
        m_pgsTrackCnt++;
    }
    else if (codecName == ""S_TEXT/UTF8"")
    {
        tsStreamIndex = (V3_flags & 0x1e ? 0x12A0 : 0x1200) + m_pgsTrackCnt;
        m_pgsTrackCnt++;
    }
    m_extIndexToTSIndex[streamIndex] = tsStreamIndex;

    m_pmt.program_number = 1;
    if (m_pcrOnVideo)
    {
        if (codecName[0] == 'V')
            m_pmt.pcr_pid = tsStreamIndex;
    }
    else
        m_pmt.pcr_pid = DEFAULT_PCR_PID;

    if (codecName == ""A_AC3"")
        m_pesType[tsStreamIndex] = PES_INT_AC3_ID;  // m_ac3Cnt++;
    else if (codecName == ""S_SUP"")
        m_pesType[tsStreamIndex] = PES_PRIVATE_DATA1;
    else if (codecName == ""S_HDMV/PGS"")
        m_pesType[tsStreamIndex] = PES_PRIVATE_DATA1;
    else if (codecName == ""S_TEXT/UTF8"")
        m_pesType[tsStreamIndex] = PES_PRIVATE_DATA1;
    else if (codecName == ""A_MP3"")
        m_pesType[tsStreamIndex] = PES_AUDIO_ID;
    else if (codecName == ""A_DTS"")
        m_pesType[tsStreamIndex] = PES_INT_DTS_ID;  // m_dtsCnt++;
    else if (codecName == ""A_LPCM"")
        m_pesType[tsStreamIndex] = PES_PRIVATE_DATA1;  // PES_INT_LPCM_ID; //m_lpcmCnt++;
    else if (codecName[0] == 'V')
    {
        if (codecName == ""V_MS/VFW/WVC1"")
        {
            m_pesType[tsStreamIndex] = PES_VC1_ID;
        }
        else
        {
            m_pesType[tsStreamIndex] = (m_m2tsMode ? PES_VIDEO_ID : PES_VIDEO_ID - 1);  // m_videoCnt++;
        }
    }

    else if (codecName[0] == 'A')
    {
        m_pesType[tsStreamIndex] = PES_AUDIO_ID;  // m_audioCnt++;
    }
    else if (codecName[0] == 'S')
    {
        m_pesType[tsStreamIndex] = PES_INT_SUB_ID;  // m_subCnt++;
    }

    if (codecName[0] == 'V')
    {
        map<string, string>::const_iterator itr = params.find(""fps"");
        if (itr != params.end())
        {
            double fps = strToDouble(itr->second.c_str());
            LTRACE(LT_DEBUG, 0, ""Muxing fps: "" << fps);
        }
    }

    if (codecName == ""V_MPEG4/ISO/AVC"")
    {
        H264StreamReader* h264Reader = (H264StreamReader*)codecReader;
        // h264Reader->setH264SPSCont(m_h264SPSCont);
        m_pmt.pidList.insert(
            std::make_pair(tsStreamIndex, PMTStreamInfo(STREAM_TYPE_VIDEO_H264, tsStreamIndex, descrBuffer,
                                                        descriptorLen, codecReader, lang, isSecondary)));
    }
    else if (codecName == ""V_MPEG4/ISO/MVC"")
    {
        H264StreamReader* h264Reader = (H264StreamReader*)codecReader;
        m_pmt.pidList.insert(
            std::make_pair(tsStreamIndex, PMTStreamInfo(STREAM_TYPE_VIDEO_MVC, tsStreamIndex, descrBuffer,
                                                        descriptorLen, codecReader, lang, isSecondary)));
    }
    else if (codecName == ""V_MPEGH/ISO/HEVC"")
    {
        int stream_type = STREAM_TYPE_VIDEO_H265;
        // For non-bluray, second Dolby Vision track must be stream_type 06 = private data
        if (!m_bluRayMode && tsStreamIndex == 0x1015 && (V3_flags & NON_DV_TRACK))
            stream_type = STREAM_TYPE_PRIVATE_DATA;
        m_pmt.pidList.insert(std::make_pair(
            tsStreamIndex,
            PMTStreamInfo(stream_type, tsStreamIndex, descrBuffer, descriptorLen, codecReader, lang, isSecondary)));
    }
    else if (codecName == ""V_MS/VFW/WVC1"")
        m_pmt.pidList.insert(
            std::make_pair(tsStreamIndex, PMTStreamInfo(STREAM_TYPE_VIDEO_VC1, tsStreamIndex, descrBuffer,
                                                        descriptorLen, codecReader, lang, isSecondary)));
    else if (codecName == ""V_MPEG-2"")
        m_pmt.pidList.insert(
            std::make_pair(tsStreamIndex, PMTStreamInfo(STREAM_TYPE_VIDEO_MPEG2, tsStreamIndex, descrBuffer,
                                                        descriptorLen, codecReader, lang, isSecondary)));
    else if (codecName == ""A_AAC"")
        m_pmt.pidList.insert(
            std::make_pair(tsStreamIndex, PMTStreamInfo(STREAM_TYPE_AUDIO_AAC, tsStreamIndex, descrBuffer,
                                                        descriptorLen, codecReader, lang, isSecondary)));
    else if (codecName == ""S_SUP"")
        m_pmt.pidList.insert(
            std::make_pair(tsStreamIndex, PMTStreamInfo(STREAM_TYPE_SUB_PGS, tsStreamIndex, descrBuffer, descriptorLen,
                                                        codecReader, lang, isSecondary)));
    else if (codecName == ""S_HDMV/PGS"")
        m_pmt.pidList.insert(
            std::make_pair(tsStreamIndex, PMTStreamInfo(STREAM_TYPE_SUB_PGS, tsStreamIndex, descrBuffer, descriptorLen,
                                                        codecReader, lang, isSecondary)));
    else if (codecName == ""S_TEXT/UTF8"")
        m_pmt.pidList.insert(
            std::make_pair(tsStreamIndex, PMTStreamInfo(STREAM_TYPE_SUB_PGS, tsStreamIndex, descrBuffer, descriptorLen,
                                                        codecReader, lang, isSecondary)));
    else if (codecName == ""A_AC3"")
    {
        AC3StreamReader* ac3Reader = (AC3StreamReader*)codecReader;
        ac3Reader->setNewStyleAudioPES(m_useNewStyleAudioPES);

        int streamType = 0;

        if (ac3Reader->isTrueHD() && !ac3Reader->getDownconvertToAC3())
            streamType = STREAM_TYPE_AUDIO_EAC3_TRUE_HD;
        else if (ac3Reader->isEAC3() && !ac3Reader->getDownconvertToAC3())
        {
            if (ac3Reader->isSecondary())
                streamType = STREAM_TYPE_AUDIO_EAC3_SECONDARY;
            else if (ac3Reader->isAC3())
                streamType = STREAM_TYPE_AUDIO_EAC3;
            else
                streamType = STREAM_TYPE_AUDIO_EAC3_ATSC;
        }
        else
            streamType = STREAM_TYPE_AUDIO_AC3;

        m_pmt.pidList.insert(std::make_pair(
            tsStreamIndex,
            PMTStreamInfo(streamType, tsStreamIndex, descrBuffer, descriptorLen, codecReader, lang, isSecondary)));
    }
    else if (codecName == ""A_MP3"")
    {
        MpegAudioStreamReader* mp3Reader = (MpegAudioStreamReader*)codecReader;
        if (mp3Reader->getLayer() >= 2)
            m_pmt.pidList.insert(
                std::make_pair(tsStreamIndex, PMTStreamInfo(STREAM_TYPE_AUDIO_MPEG2, tsStreamIndex, descrBuffer,
                                                            descriptorLen, codecReader, lang, isSecondary)));
        else
            m_pmt.pidList.insert(
                std::make_pair(tsStreamIndex, PMTStreamInfo(STREAM_TYPE_AUDIO_MPEG1, tsStreamIndex, descrBuffer,
                                                            descriptorLen, codecReader, lang, isSecondary)));
    }
    else if (codecName == ""A_LPCM"")
    {
        m_pmt.pidList.insert(
            std::make_pair(tsStreamIndex, PMTStreamInfo(STREAM_TYPE_AUDIO_LPCM, tsStreamIndex, descrBuffer,
                                                        descriptorLen, codecReader, lang, isSecondary)));
    }
    else if (codecName == ""A_DTS"")
    {
        DTSStreamReader* dtsReader = (DTSStreamReader*)codecReader;
        dtsReader->setNewStyleAudioPES(m_useNewStyleAudioPES);
        int audioType = 0;
        if (dtsReader->getDTSHDMode() && !dtsReader->getDownconvertToDTS())
        {
            // if (dtsReader->getDTSHDMode() == DTSStreamReader::DTS_SUBTYPE_EXPRESS)
            if (dtsReader->isSecondary())
                audioType = STREAM_TYPE_AUDIO_DTS_HD_SECONDARY;
            else if (dtsReader->getDTSHDMode() == DTSStreamReader::DTS_SUBTYPE_MASTER_AUDIO)
                audioType = STREAM_TYPE_AUDIO_DTS_HD_MASTER_AUDIO;
            else
                audioType = STREAM_TYPE_AUDIO_DTS_HD;
        }
        else
        {
            audioType = STREAM_TYPE_AUDIO_DTS;
        }
        m_pmt.pidList.insert(std::make_pair(
            tsStreamIndex,
            PMTStreamInfo(audioType, tsStreamIndex, descrBuffer, descriptorLen, codecReader, lang, isSecondary)));
    }
    else
        THROW(ERR_UNKNOWN_CODEC, ""Unsupported codec "" << codecName << "" for TS/M2TS muxing."");

    m_streamInfo[DEFAULT_PCR_PID].m_tsCnt = 0;
    buildNULL();
    buildPAT();
    buildPMT();
}

bool TSMuxer::doFlush()
{
    if (!m_lastPts.empty())
        m_lastPts[m_lastPts.size() - 1] += m_additionCLPISize;

    uint64_t newPCR = 0;
    if (m_m2tsMode)
    {
        newPCR = (m_endStreamDTS - m_minDts) / INT_FREQ_TO_TS_FREQ + 0.5 + m_fixed_pcr_offset;
        if (m_cbrBitrate != -1 && m_lastPCR != -1)
        {
            uint64_t cbrPCR = m_lastPCR + m_pcrBits * 90000.0 / m_cbrBitrate + 0.5;
            newPCR = FFMAX(newPCR, cbrPCR);
        }
    }
    return doFlush(newPCR, 0);
}

bool TSMuxer::doFlush(uint64_t newPCR, int64_t pcrGAP)
{
    flushTSFrame();

    if (m_sectorSize > 0)
    {
        // round file to sector size. It's also can be applied to any file in a m2ts mode
        int nullCnt = 0;
        if (m_processedBlockSize % m_sectorSize)
            nullCnt = m_sectorSize - (m_processedBlockSize % m_sectorSize);
        writeNullPackets(nullCnt / m_frameSize);
    }

    if (m_m2tsMode)
        processM2TSPCR(newPCR, pcrGAP);

    unsigned lastBlockSize = m_outBufLen & (MuxerManager::PHYSICAL_SECTOR_SIZE - 1);  // last 64K of data
    unsigned roundBufLen = m_outBufLen & ~(MuxerManager::PHYSICAL_SECTOR_SIZE - 1);
    if (m_owner->isAsyncMode())
    {
        if (lastBlockSize > 0)
        {
            assert(m_sectorSize == 0);  // we should not be here in interleaved mode!
            uint8_t* newBuff = new uint8_t[lastBlockSize];
            memcpy(newBuff, m_outBuf + roundBufLen, lastBlockSize);
            m_owner->asyncWriteBuffer(this, m_outBuf, roundBufLen, m_muxFile);
            m_outBuf = newBuff;
        }
        else
        {
            m_owner->asyncWriteBuffer(this, m_outBuf, roundBufLen, m_muxFile);
            m_outBuf = 0;
        }
    }
    else
    {
        m_owner->syncWriteBuffer(this, m_outBuf, roundBufLen, m_muxFile);
        memmove(m_outBuf, m_outBuf + roundBufLen, lastBlockSize);
    }
    m_outBufLen = lastBlockSize;
    assert(!m_sectorSize || m_outBufLen == 0);
    return true;
}

int TSMuxer::writeOutFile(uint8_t* buffer, int len)
{
    int rez = m_muxFile->write(buffer, len);
    return rez;
}

bool TSMuxer::close()
{
    if (m_isExternalFile)
        return true;

    if (m_sectorSize)
    {
        assert(m_outBufLen == 0 && m_muxFile->size() % m_sectorSize == 0);
    }

    if (!m_muxFile->close())
        return false;

    if (m_sectorSize)
        return true;

    if (m_outBufLen > 0)
    {
        if (!m_muxFile->open(m_outFileName.c_str(), AbstractOutputStream::ofWrite + AbstractOutputStream::ofAppend))
            return false;
        if (!writeOutFile(m_outBuf, m_outBufLen))
            return false;
    }
    bool bRes = m_muxFile->close();
    return bRes;
}

int TSMuxer::calcM2tsFrameCnt()
{
    uint32_t byteCnt = 0;
    for (auto& i : m_m2tsDelayBlocks) byteCnt += i.second;
    byteCnt -= m_prevM2TSPCROffset;
    byteCnt += m_outBufLen;
    assert(byteCnt % 192 == 0);
    return byteCnt / 192;
}

void TSMuxer::processM2TSPCR(int64_t pcrVal, int64_t pcrGAP)
{
    int m2tsFrameCnt = calcM2tsFrameCnt();
    int64_t hiResPCR = pcrVal * 300 - pcrGAP;
    uint64_t pcrValDif = hiResPCR - m_prevM2TSPCR;  // m2ts pcr clock based on full 27Mhz counter
    double pcrIncPerFrame = double(pcrValDif + 0.1) / (double)m2tsFrameCnt;

    double curM2TSPCR = m_prevM2TSPCR;
    uint8_t* curPos;
    if (m_m2tsDelayBlocks.size() > 0)
    {
        int offset = m_prevM2TSPCROffset;
        for (auto& i : m_m2tsDelayBlocks)
        {
            curPos = i.first + offset;
            int j = offset;
            for (; j < i.second; j += 192)
            {
                curM2TSPCR += pcrIncPerFrame;
                writeM2TSHeader(curPos, (uint64_t)curM2TSPCR);
                curPos += 192;
            }
            if (m_owner->isAsyncMode())
                m_owner->asyncWriteBuffer(this, i.first, i.second, m_muxFile);
            else
            {
                m_owner->syncWriteBuffer(this, i.first, i.second, m_muxFile);
                delete[] i.first;
            }
            offset = j - i.second;
        }
        m_prevM2TSPCROffset = offset;
        m_m2tsDelayBlocks.clear();
    }
    curPos = m_outBuf + m_prevM2TSPCROffset;
    uint8_t* end = m_outBuf + m_outBufLen;
    for (; curPos < end; curPos += 192)
    {
        curM2TSPCR += pcrIncPerFrame;
        writeM2TSHeader(curPos, (uint64_t)curM2TSPCR);
    }
    assert(curPos == end);
    m_prevM2TSPCROffset = m_outBufLen;
    // assert((int64_t) curM2TSPCR == hiResPCR);
    m_prevM2TSPCR = hiResPCR;
}

void TSMuxer::writeEmptyPacketWithPCRTest(int64_t pcrVal)
{
    if (m_m2tsMode)
    {
        m_outBufLen += 4;
        m_processedBlockSize += 4;
        m_pcrBits += 4 * 8;
    }
    uint8_t* curBuf = m_outBuf + m_outBufLen;
    TSPacket* tsPacket = (TSPacket*)curBuf;
    uint32_t* initTS = (uint32_t*)curBuf;
    *initTS = TSPacket::TS_FRAME_SYNC_BYTE;
    initTS[1] = 0x07 + TSPacket::PCR_BIT_VAL;
    tsPacket->setPID(m_pmt.pcr_pid);
    tsPacket->afExists = 1;
    tsPacket->adaptiveField.setPCR33(pcrVal);
    // tsPacket->counter = m_streamInfo[m_pmt.pcr_pid].m_tsCnt++;
    tsPacket->counter = m_streamInfo[m_pmt.pcr_pid].m_tsCnt;  // do not increment counter because data_exists == 0

    memset(curBuf + tsPacket->getHeaderSize(), 0xff, TS_FRAME_SIZE - tsPacket->getHeaderSize());
    tsPacket->adaptiveField.length += TS_FRAME_SIZE - tsPacket->getHeaderSize();
    m_outBufLen += TS_FRAME_SIZE;
    m_processedBlockSize += TS_FRAME_SIZE;
    m_pcrBits += TS_FRAME_SIZE * 8;
    m_muxedPacketCnt[m_muxedPacketCnt.size() - 1]++;
}

void TSMuxer::writeEmptyPacketWithPCR(int64_t pcrVal)
{
    if (m_m2tsMode)
    {
        m_outBufLen += 4;
        m_processedBlockSize += 4;
        m_pcrBits += 4 * 8;
    }
    uint8_t* curBuf = m_outBuf + m_outBufLen;
    TSPacket* tsPacket = (TSPacket*)curBuf;
    uint32_t* initTS = (uint32_t*)curBuf;
    *initTS = TSPacket::TS_FRAME_SYNC_BYTE;
    initTS[1] = 0x07 + TSPacket::PCR_BIT_VAL;
    tsPacket->setPID(m_pmt.pcr_pid);
    tsPacket->afExists = 1;
    tsPacket->adaptiveField.setPCR33(pcrVal);
    // tsPacket->counter = m_streamInfo[m_pmt.pcr_pid].m_tsCnt++;
    tsPacket->counter = m_streamInfo[m_pmt.pcr_pid].m_tsCnt;  // do not increment counter becouse data_exists == 0

    memset(curBuf + tsPacket->getHeaderSize(), 0xff, TS_FRAME_SIZE - tsPacket->getHeaderSize());
    tsPacket->adaptiveField.length += TS_FRAME_SIZE - tsPacket->getHeaderSize();
    m_outBufLen += TS_FRAME_SIZE;
    m_processedBlockSize += TS_FRAME_SIZE;
    m_pcrBits += TS_FRAME_SIZE * 8;
    m_muxedPacketCnt[m_muxedPacketCnt.size() - 1]++;
    if (m_m2tsMode)
        processM2TSPCR(pcrVal, 0);
    writeOutBuffer();
}

void TSMuxer::buildPesHeader(int pesStreamID, AVPacket& avPacket, int pid)
{
    int64_t curDts = nanoClockToPts(avPacket.dts) + m_timeOffset;
    int64_t curPts = nanoClockToPts(avPacket.pts) + m_timeOffset;
    uint8_t tmpBuffer[2048];
    PESPacket* pesPacket = (PESPacket*)tmpBuffer;
    if (curDts != curPts)
        pesPacket->serialize(curPts, curDts, pesStreamID);
    else
        pesPacket->serialize(curPts, pesStreamID);
    m_lastPESDTS = curDts;
    m_fullPesDTS = avPacket.dts;
    m_fullPesPTS = avPacket.pts;
    pesPacket->flagsHi |= PES_DATA_ALIGNMENT;
    // int additionDataSize = avPacket.codec->writePESExtension(pesPacket);
    AbstractStreamReader* ast = dynamic_cast<AbstractStreamReader*>(avPacket.codec);
    if (ast)
        ast->writePESExtension(pesPacket, avPacket);
    if (avPacket.flags & AVPacket::IS_COMPLETE_FRAME)
        pesPacket->setPacketLength(avPacket.size + pesPacket->getHeaderLength());

    PriorityDataInfo tmpPriorityData;
    int additionDataSize = avPacket.codec->writeAdditionData(tmpBuffer + pesPacket->getHeaderLength(),
                                                             tmpBuffer + sizeof(tmpBuffer), avPacket, &tmpPriorityData);
    int bufLen = pesPacket->getHeaderLength() + additionDataSize;
    m_pesData.resize(bufLen);
    memcpy(m_pesData.data(), tmpBuffer, bufLen);
    for (auto& i : tmpPriorityData)
        m_priorityData.push_back(std::pair<int, int>(i.first + pesPacket->getHeaderLength(), i.second));
}

void TSMuxer::addData(int pesStreamID, int pid, AVPacket& avPacket)
{
    int beforePesLen = m_pesData.size();
    if (m_pesData.size() == 0)
    {
        buildPesHeader(pesStreamID, avPacket, pid);
        m_pesPID = pid;
        m_pesIFrame = avPacket.flags & AVPacket::IS_IFRAME;
        m_pesSpsPps = avPacket.flags & AVPacket::IS_SPS_PPS_IN_GOP;
    }
    int oldLen = m_pesData.size();
    int pesHeaderLen = oldLen - beforePesLen;
    if (oldLen > 100000000)
        THROW(ERR_COMMON, ""Pes packet len too large ( >100Mb). Bad stream or invalid codec speciffed."");
    m_pesData.grow(avPacket.size /*+ additionDataSize*/);
    uint8_t* dst = m_pesData.data() + oldLen;
    // memcpy(dst, tmpBuffer, additionDataSize);
    memcpy(dst /*+ additionDataSize*/, avPacket.data, avPacket.size);
    if (avPacket.flags & AVPacket::PRIORITY_DATA)
    {
        if (!m_priorityData.empty() && m_priorityData.rbegin()->first + m_priorityData.rbegin()->second == beforePesLen)
            m_priorityData.rbegin()->second += avPacket.size + pesHeaderLen;
        else
            m_priorityData.push_back(pair<int, int>(beforePesLen, avPacket.size + pesHeaderLen));
    }
}

void TSMuxer::flushTSFrame() { writePESPacket(); }

void TSMuxer::writePATPMT(int64_t pcr, bool force)
{
    if (pcr == -1 || pcr - m_lastPMTPCR >= m_patPmtDelta || force)
    {
        m_lastPMTPCR = pcr != -1 ? pcr : m_fixed_pcr_offset;
        writePAT();
        writePMT();
        if (force || pcr - m_lastSITPCR > SIT_INTERVAL)
        {
            m_lastSITPCR = pcr;
            writeSIT();
        }
    }
}

bool TSMuxer::isSplitPoint(const AVPacket& avPacket)
{
    if (avPacket.stream_index != m_mainStreamIndex || !(avPacket.flags & AVPacket::IS_IFRAME))
        return false;

    if (m_splitSize > 0)
    {
        return m_muxedPacketCnt[m_muxedPacketCnt.size() - 1] * m_frameSize > m_splitSize;
    }
    else if (m_splitDuration > 0)
    {
        return (avPacket.pts - m_curFileStartPts) > m_splitDuration;
    }
    else
        return false;
}

int TSMuxer::getFirstFileNum() const
{
    string fileName = extractFileName(m_origFileName);
    return strToInt32(fileName.c_str());
}

std::string TSMuxer::getNextName(const std::string curName)
{
    std::string result = curName;
    if (m_bluRayMode)
    {
        string fileExt = extractFileExt(m_origFileName);
        string fileName = extractFileName(m_origFileName);
        string filePath = extractFilePath(m_origFileName);
        int origNum = strToInt32(fileName.c_str());
        origNum += m_curFileNum;
        m_curFileNum++;
        result = closeDirPath(filePath) + strPadLeft(int32ToStr(origNum), 5, '0') + ""."" + fileExt;
    }
    else if (m_splitSize > 0 || m_splitDuration > 0)
    {
        m_curFileNum++;
        string fileExt = extractFileExt(m_origFileName);
        result = m_origFileName.substr(0, m_origFileName.size() - fileExt.size() - 1) + "".split."" +
                 int32ToStr(m_curFileNum) + ""."" + fileExt;
    }
    return toNativeSeparators(result);
}

void TSMuxer::gotoNextFile(uint64_t newPts)
{
    // 2. CloseCurrentFile
    if (m_owner->isAsyncMode())
        m_owner->waitForWriting();

    m_muxFile->close();
    assert(m_outBufLen == 0);

    // 3. open new file
    m_outFileName = getNextName(m_outFileName);
    if (m_sublingMuxer)
        m_outFileName = getNextName(m_outFileName);  // inc by 2
    m_fileNames.push_back(m_outFileName);
    openDstFile();

    for (PIDListMap::iterator itr = m_pmt.pidList.begin(); itr != m_pmt.pidList.end(); ++itr)
    {
        PMTStreamInfo& pmtInfo = itr->second;
        pmtInfo.m_codecReader->onSplitEvent();
        if (pmtInfo.m_index.size() == 0)
            continue;
        pmtInfo.m_index.push_back(PMTIndex());

        /*
                int spSize = pmtInfo.m_index.size();
                if (pmtInfo.m_index[spSize-2].size() > 0) {
                        uint64_t shortPts = (m_lastSplitPts / INT_FREQ_TO_TS_FREQ + 0.5) + m_timeOffset;
                        uint32_t lastPesSize = pmtInfo.m_index[spSize-2].rbegin()->second.m_frameLen;
                        pmtInfo.m_index[spSize-1].insert(make_pair(shortPts, PMTIndexData(firstDataFrame,
           lastPesSize))); pmtInfo.m_index[spSize-2].erase(pmtInfo.m_index[spSize-2].rbegin()->first);
                }
        */
    }

    m_muxedPacketCnt.push_back(0);
    m_interliaveInfo.push_back(std::vector<int32_t>());
    m_interliaveInfo.rbegin()->push_back(0);

    m_lastPts[m_lastPts.size() - 1] = newPts;  //(curPts-FIXED_PTS_OFFSET)*INT_FREQ_TO_TS_FREQ;
    m_firstPts.push_back(newPts);              //((curPts-FIXED_PTS_OFFSET)*INT_FREQ_TO_TS_FREQ);
    m_lastPts.push_back(newPts);               //((curPts-FIXED_PTS_OFFSET)*INT_FREQ_TO_TS_FREQ);
    m_curFileStartPts = newPts;
}

void TSMuxer::writePESPacket()
{
    if (m_pesData.size() > 0)
    {
        uint32_t tsPackets = 0;

        int size = m_pesData.size() - 6;
        if (size <= 0xffff)
        {
            m_pesData.data()[4] = size / 256;
            m_pesData.data()[5] = size % 256;
        }

        PMTStreamInfo& streamInfo = m_pmt.pidList[m_pesPID];
        PESPacket* pesPacket = (PESPacket*)m_pesData.data();
        bool updateIdx = false;
        if (m_computeMuxStats && (pesPacket->flagsLo & 0x80) == 0x80)
        {
            uint64_t curPts = pesPacket->getPts();
            uint64_t curDts = curPts;
            if ((pesPacket->flagsLo & 0xc0) == 0xc0)
                curDts = pesPacket->getDts();

            // LTRACE(LT_INFO, 2, ""pts="" << curPts << "" dts="" << curDts);

            int idxSize = streamInfo.m_index.size();
            if (idxSize == 0)
                streamInfo.m_index.push_back(PMTIndex());
            MPEGStreamReader* vCodec = dynamic_cast<MPEGStreamReader*>(streamInfo.m_codecReader);
            // bool isH264 = dynamic_cast <H264StreamReader*> (streamInfo.m_codecReader);
            bool SPSRequired = streamInfo.m_codecReader->needSPSForSplit();
            SimplePacketizerReader* aCodec = dynamic_cast<SimplePacketizerReader*>(streamInfo.m_codecReader);
            if (vCodec && m_pesIFrame)
            {
                // skip some I-frames for H.264 if no SPS/PPS in a gop
                if (m_pesSpsPps || !SPSRequired)
                {
                    PMTIndex& curIndex = *streamInfo.m_index.rbegin();
                    if (curIndex.empty() || curPts > curIndex.rbegin()->first)
                    {
                        curIndex.insert(
                            std::make_pair(curPts, PMTIndexData(m_muxedPacketCnt[m_muxedPacketCnt.size() - 1], 0)));
                        updateIdx = true;
                    }
                }

                m_lastGopNullCnt = m_nullCnt;
            }
            // else if (vCodec) {
            //	PMTIndex& curIndex = *streamInfo.m_index.rbegin();
            //	curIndex.insert(std::make_pair(curPts, PMTIndexData(m_muxedPacketCnt[m_muxedPacketCnt.size()-1],
            // m_pesDataSize)));
            //}
            else if (aCodec)
            {
                if (m_videoTrackCnt + m_videoSecondTrackCnt == 0)
                {
                    m_lastGopNullCnt = m_nullCnt;
                }
                PMTIndex& curIndex = *streamInfo.m_index.rbegin();
                idxSize = curIndex.size();
                if (idxSize == 0 || curPts - curIndex.rbegin()->first >= 90000)
                {
                    curIndex.insert(
                        std::make_pair(curPts, PMTIndexData(m_muxedPacketCnt[m_muxedPacketCnt.size() - 1], 0)));
                    updateIdx = true;
                }
            }
        }

        uint8_t* curPtr = m_pesData.data();
        uint8_t* dataEnd = curPtr + m_pesData.size();
        bool payloadStart = true;
        for (auto& i : m_priorityData)
        {
            uint8_t* blockPtr = m_pesData.data() + i.first;
            if (blockPtr > curPtr)
            {
                tsPackets += writeTSFrames(m_pesPID, curPtr, blockPtr - curPtr, false, payloadStart);
                payloadStart = false;
            }
            tsPackets += writeTSFrames(m_pesPID, blockPtr, i.second, true, payloadStart);
            curPtr = blockPtr + i.second;
        }
        tsPackets += writeTSFrames(m_pesPID, curPtr, dataEnd - curPtr, false, payloadStart);

        m_pesData.resize(0);
        m_priorityData.clear();
        if (updateIdx)
        {
            PMTIndex& curIndex = *streamInfo.m_index.rbegin();
            assert(curIndex.rbegin()->second.m_frameLen == 0);
            curIndex.rbegin()->second.m_frameLen = (tsPackets + 1) * m_frameSize;
        }
    }
}

void TSMuxer::writePCR(uint64_t newPCR)
{
    int bitsRest = 0;
    if (m_cbrBitrate != -1 && m_minBitrate != -1 && m_lastPCR != -1)
    {
        int expectedBits = (newPCR - m_lastPCR) / 90000.0 * m_minBitrate + 0.5;
        expectedBits -= m_pcrBits;
        if (expectedBits > 0)
        {
            int tsFrames = (expectedBits / 8 / m_frameSize);
            if (tsFrames * m_frameSize * 8 < expectedBits)
                tsFrames++;
            writeNullPackets(tsFrames);
            if (m_cbrBitrate == m_minBitrate)
                bitsRest = (tsFrames * m_frameSize * 8) - expectedBits;
        }
    }
    m_pcrBits = bitsRest;
    // assert(m_pcrBits % 8 == 0);
    writeEmptyPacketWithPCR(newPCR);
    m_lastPCR = newPCR;
}

void TSMuxer::flushTSBuffer()
{
    if (m_owner->isAsyncMode())
        m_owner->waitForWriting();

    uint64_t fileSize = m_muxFile->size();
    if (fileSize == -1)
        THROW(ERR_FILE_COMMON, ""Can't determine size for file "" << m_outFileName);
    m_muxFile->close();

    if (!m_muxFile->open(m_outFileName.c_str(), File::ofWrite + File::ofAppend))
        THROW(ERR_FILE_COMMON, ""Can't reopen file "" << m_outFileName);

    if (writeOutFile(m_outBuf, m_outBufLen) != m_outBufLen)
        THROW(ERR_FILE_COMMON, ""Can't write last data block to file "" << m_outFileName);
    delete[] m_outBuf;
    m_outBufLen = 0;
}

void TSMuxer::finishFileBlock(uint64_t newPts, uint64_t newPCR, bool doChangeFile, bool recursive)
{
    if (m_processedBlockSize > 0)
    {
        int64_t gapForPATPMT = (192 * 4.0) / 35000000.0 * 27000000.0;
        doFlush(newPCR, gapForPATPMT);
        if (!doChangeFile)
            m_interliaveInfo.rbegin()->push_back(m_processedBlockSize / 192);
        m_processedBlockSize = 0;
        m_owner->muxBlockFinished(this);
        if (m_m2tsMode)
            assert(m_outBuf == 0 && m_outBufLen == 0);
        else
            flushTSBuffer();
        m_outBuf = new uint8_t[m_writeBlockSize + 1024];
        m_prevM2TSPCROffset = 0;
    }

    if (doChangeFile)
        gotoNextFile(newPts);

    writePATPMT(newPCR, true);
    writePCR(newPCR);

    if (m_sublingMuxer && recursive)
        m_sublingMuxer->finishFileBlock(newPts, newPCR, doChangeFile, false);
}

bool TSMuxer::blockFull() const { return m_processedBlockSize >= m_interliaveBlockSize; }

bool TSMuxer::muxPacket(AVPacket& avPacket)
{
    /*
    if (!m_iFrameFound && m_mainStreamIndex != -1) {
        if (avPacket.stream_index == m_mainStreamIndex)
            m_iFrameFound = ( avPacket.flags & AVPacket::IS_IFRAME ) != 0;
        if (!m_iFrameFound)
            return false;
    }
    */

    if (avPacket.data == 0 || avPacket.size == 0)
    {
        return true;
    }

    // if (m_lastProcessedDts != avPacket.dts || m_lastStreamIndex != avPacket.stream_index)
    //    LTRACE(LT_INFO, 2, ""dts="" << avPacket.dts/1000000000.0 << "" index="" << avPacket.stream_index);
#ifdef _DEBUG
    // assert (avPacket.dts >= m_lastProcessedDts);
    m_lastProcessedDts = avPacket.dts;
    m_lastStreamIndex = avPacket.stream_index;
#endif

    if (avPacket.stream_index == m_mainStreamIndex)
    {
        MPEGStreamReader* mpegReader = dynamic_cast<MPEGStreamReader*>(avPacket.codec);
        if (mpegReader)
            m_additionCLPISize = INTERNAL_PTS_FREQ / mpegReader->getFPS();

        if (avPacket.duration > 0)
            *m_lastPts.rbegin() = FFMAX(*m_lastPts.rbegin(), avPacket.pts + avPacket.duration);
        else
            *m_lastPts.rbegin() = FFMAX(*m_lastPts.rbegin(), avPacket.pts);
    }
    if (m_firstPts[m_firstPts.size() - 1] == -1 /*|| avPacket.pts < m_firstPts[m_firstPts.size()-1]*/)
    {
        if (m_firstPts[m_firstPts.size() - 1] == -1)
        {
            m_curFileStartPts = avPacket.pts;
            uint64_t firstPtsShift = nanoClockToPts(avPacket.pts);
            m_fixed_pcr_offset = m_timeOffset - m_vbvLen + firstPtsShift;
            if (m_fixed_pcr_offset < 0)
                m_fixed_pcr_offset = 0;
            m_prevM2TSPCR = (m_fixed_pcr_offset - 100) *
                            300;  // add a little extra delta (100) to prevent 0 bitrate for first several packets
        }
        m_firstPts[m_firstPts.size() - 1] = avPacket.pts;
    }

    if (m_pcr_delta == -1)
    {
        if (m_cbrBitrate != -1)
            m_pcr_delta = M_CBR_PCR_DELTA;
        else
            m_pcr_delta = M_PCR_DELTA;
        m_patPmtDelta = m_m2tsMode ? M_PCR_DELTA : PCR_FREQUENCY / 4;
    }

    if (m_minDts == -1)
        m_minDts = avPacket.dts;

    int tsIndex = m_extIndexToTSIndex[avPacket.stream_index];
    if (tsIndex == 0)
        THROW(ERR_TS_COMMON, ""Unknown track number "" << avPacket.stream_index);

    bool newPES = false;
    if (avPacket.dts != m_streamInfo[tsIndex].m_dts || avPacket.pts != m_streamInfo[tsIndex].m_pts ||
        tsIndex != m_lastTSIndex || avPacket.flags & AVPacket::FORCE_NEW_FRAME)
    {
        writePESPacket();
        newPES = true;
    }

    m_lastTSIndex = tsIndex;

    int64_t newPCR = (avPacket.dts - m_minDts) / INT_FREQ_TO_TS_FREQ + 0.5 + m_fixed_pcr_offset;

    if (m_cbrBitrate != -1 && m_lastPCR != -1)
    {
        int64_t cbrPCR = m_lastPCR + m_pcrBits * 90000.0 / m_cbrBitrate + 0.5;
        newPCR = FFMAX(newPCR, cbrPCR);
    }

    if (newPES && m_canSwithBlock && (isSplitPoint(avPacket) || isSplitPoint(avPacket)))
    {
        finishFileBlock(avPacket.pts, newPCR, true);  // goto next file
    }
    else if (newPES && m_interliaveBlockSize > 0 && m_canSwithBlock &&
             (blockFull() || m_sublingMuxer && m_sublingMuxer->blockFull()))
    {
        finishFileBlock(avPacket.pts, newPCR, false);  // interleave SSIF here
    }
    else if (newPCR - m_lastPCR >= m_pcr_delta)
    {
        if (m_interliaveBlockSize == 0 || avPacket.stream_index == m_mainStreamIndex)
        {
            writePATPMT(newPCR);
            writePCR(newPCR);
        }
    }

    m_streamInfo[tsIndex].m_pts = avPacket.pts;
    m_streamInfo[tsIndex].m_dts = avPacket.dts;
    int pesStreamID = m_pesType[tsIndex];
    if (pesStreamID <= SYSTEM_START_CODE)
    {
        if (m_useNewStyleAudioPES)
            pesStreamID = PES_VC1_ID;
        else
            pesStreamID = PES_PRIVATE_DATA1;
    }

    addData(pesStreamID, tsIndex, avPacket);

    MPEGStreamReader* mpegReader = dynamic_cast<MPEGStreamReader*>(avPacket.codec);
    if (avPacket.duration > 0)
        m_endStreamDTS = avPacket.dts + avPacket.duration;
    else if (mpegReader)
        m_endStreamDTS = avPacket.dts + INTERNAL_PTS_FREQ / mpegReader->getFPS();
    else
        m_endStreamDTS = avPacket.dts;

    return true;
}

int TSMuxer::writeTSFrames(int pid, uint8_t* buffer, int len, bool priorityData, bool payloadStart)
{
    int result = 0;

    uint8_t* curPos = buffer;
    uint8_t* end = buffer + len;

    int streamType = m_pmt.pidList[pid].m_streamType;

    bool tsPriority = priorityData;
    StreamInfo& streamInfo = m_streamInfo[pid];

    while (curPos < end)
    {
        if (m_cbrBitrate != -1 && m_lastPCR != -1)
        {
            int64_t newPCR = m_lastPCR + m_pcrBits * 90000.0 / m_cbrBitrate + 0.5;
            if (newPCR - m_lastPCR >= m_pcr_delta && m_lastPCR != -1)
            {
                m_pcrBits = 0;
                writePATPMT(newPCR);
                writePCR(newPCR);
                if (m_lastPESDTS != -1 && m_lastPCR > m_lastPESDTS)
                {
                    LTRACE(LT_ERROR, 2,
                           ""VBV buffer overflow at position "" << (m_lastPCR - m_fixed_pcr_offset) / 90000.0 << "" sec"");
                }
            }
        }

        if (m_m2tsMode)
        {
            m_outBufLen += 4;
            m_processedBlockSize += 4;
            m_pcrBits += 4 * 8;
        }
        int tmpBufferLen = end - curPos;
        uint32_t* initTS = (uint32_t*)(m_outBuf + m_outBufLen);
        *initTS = TSPacket::TS_FRAME_SYNC_BYTE + TSPacket::DATA_EXIST_BIT_VAL;
        TSPacket* tsPacket = (TSPacket*)(m_outBuf + m_outBufLen);
        int payloadLen = TS_FRAME_SIZE - tsPacket->getHeaderSize();
        tsPacket->setPID(pid);
        tsPacket->counter = streamInfo.m_tsCnt++;
        tsPacket->payloadStart = payloadStart;  // curPos == buffer;
        payloadStart = false;
        tsPacket->priority = tsPriority;
        if (tmpBufferLen < payloadLen)
        {
            // insert padding bytes
            if (!tsPacket->afExists)
            {
                tsPacket->afExists = 1;
                if (payloadLen - tmpBufferLen == 1)
                {
                    tsPacket->adaptiveField.length = 0;
                    payloadLen--;
                }
                else
                {
                    initTS[1] = 0x01;  // zero all af flags, set af len to 1.
                    payloadLen -= 2;
                }
            }
            memset((uint8_t*)tsPacket + tsPacket->getHeaderSize(), 0xff, payloadLen - tmpBufferLen);
            tsPacket->adaptiveField.length += payloadLen - tmpBufferLen;
            payloadLen = tmpBufferLen;
        }
        int tsHeaderSize = tsPacket->getHeaderSize();
        memcpy(m_outBuf + m_outBufLen + tsHeaderSize, curPos, payloadLen);

        curPos += payloadLen;
        m_outBufLen += TS_FRAME_SIZE;
        m_processedBlockSize += TS_FRAME_SIZE;
        m_pcrBits += TS_FRAME_SIZE * 8;
        m_muxedPacketCnt[m_muxedPacketCnt.size() - 1]++;
        writeOutBuffer();
        result++;
    }
    return result;
}

void TSMuxer::buildNULL()
{
    *((uint32_t*)m_nullBuffer) = TSPacket::TS_FRAME_SYNC_BYTE;
    TSPacket* tsPacket = (TSPacket*)m_nullBuffer;
    tsPacket->setPID(NULL_PID);
    tsPacket->dataExists = 1;
    memset(m_nullBuffer + TSPacket::TS_HEADER_SIZE, 0xff, TS_FRAME_SIZE - TSPacket::TS_HEADER_SIZE);
}

void TSMuxer::buildPAT()
{
    *((uint32_t*)m_patBuffer) = TSPacket::TS_FRAME_SYNC_BYTE + TSPacket::DATA_EXIST_BIT_VAL;
    TSPacket* tsPacket = (TSPacket*)m_patBuffer;
    tsPacket->setPID(PAT_PID);
    tsPacket->dataExists = 1;
    tsPacket->payloadStart = 1;
    m_pat.pmtPids[SIT_PID] = 0;          // add NIT. program number = 0
    m_pat.pmtPids[DEFAULT_PMT_PID] = 1;  // add PMT. program number = 1
    m_pat.transport_stream_id = 1;       // version of transport stream
    uint32_t size = m_pat.serialize(m_patBuffer + TSPacket::TS_HEADER_SIZE, TS_FRAME_SIZE - TSPacket::TS_HEADER_SIZE);
    memset(m_patBuffer + TSPacket::TS_HEADER_SIZE + size, 0xff, TS_FRAME_SIZE - TSPacket::TS_HEADER_SIZE - size);
}

void TSMuxer::buildPMT()
{
    *((uint32_t*)m_pmtBuffer) = TSPacket::TS_FRAME_SYNC_BYTE + TSPacket::DATA_EXIST_BIT_VAL;
    TSPacket* tsPacket = (TSPacket*)m_pmtBuffer;
    tsPacket->setPID(DEFAULT_PMT_PID);
    tsPacket->dataExists = 1;
    tsPacket->payloadStart = 1;
    uint32_t size = m_pmt.serialize(m_pmtBuffer + TSPacket::TS_HEADER_SIZE, 3864, m_bluRayMode, m_hdmvDescriptors);
    uint8_t* pmtEnd = m_pmtBuffer + TSPacket::TS_HEADER_SIZE + size;
    uint8_t* curPos = m_pmtBuffer + TS_FRAME_SIZE;
    for (; curPos < pmtEnd; curPos += TS_FRAME_SIZE)
    {
        memmove(curPos + 4, curPos, pmtEnd - curPos);
        pmtEnd += 4;
        *((uint32_t*)curPos) = TSPacket::TS_FRAME_SYNC_BYTE + TSPacket::DATA_EXIST_BIT_VAL;
        TSPacket* tsPacket2 = (TSPacket*)curPos;
        tsPacket2->setPID(DEFAULT_PMT_PID);
        tsPacket2->dataExists = 1;
        tsPacket2->payloadStart = 0;
    }
    int oldPmtSize = pmtEnd - m_pmtBuffer;
    int roundSize = pmtEnd - m_pmtBuffer;
    if (roundSize % TS_FRAME_SIZE != 0)
        roundSize = (roundSize / TS_FRAME_SIZE + 1) * TS_FRAME_SIZE;
    memset(pmtEnd, 0xff, roundSize - oldPmtSize);
    m_pmtFrames = roundSize / TS_FRAME_SIZE;
}

void TSMuxer::buildSIT() {}

void TSMuxer::writeNullPackets(int cnt)
{
    for (int i = 0; i < cnt; i++)
    {
        if (m_m2tsMode)
        {
            m_outBufLen += 4;
            m_processedBlockSize += 4;
            m_pcrBits += 4 * 8;
        }
        memcpy(m_outBuf + m_outBufLen, m_nullBuffer, TS_FRAME_SIZE);
        TSPacket* tsPacket = (TSPacket*)(m_outBuf + m_outBufLen);
        tsPacket->counter = m_nullCnt++;
        m_outBufLen += TS_FRAME_SIZE;
        m_processedBlockSize += TS_FRAME_SIZE;
        m_pcrBits += TS_FRAME_SIZE * 8;
        m_muxedPacketCnt[m_muxedPacketCnt.size() - 1]++;
        writeOutBuffer();
    }
}

bool TSMuxer::appendM2TSNullPacketToFile(uint64_t curFileSize, int counter, int* packetsWrited)
{
    *packetsWrited = 0;
    while (counter < 0) counter += 16;
    uint8_t tmpBuff[192];

    File* file = dynamic_cast<File*>(m_muxFile);

    file->seek(curFileSize - 192, File::smBegin);
    int readCnt = file->read(tmpBuff, 192);
    if (readCnt != 192)
        return false;
    memcpy(tmpBuff + 4, m_nullBuffer, TS_FRAME_SIZE);
    TSPacket* tsPacket = (TSPacket*)(tmpBuff);
    for (uint64_t newFileSize = curFileSize; newFileSize % (2048 * 3) != 0; newFileSize += 192)
    {
        tsPacket->counter = counter++;
        if (file->write(tmpBuff, 192) != 192)
            return false;
        // m_muxedPacketCnt[m_muxedPacketCnt.size()-1]++;
        (*packetsWrited)++;
    }
    return true;
}

void TSMuxer::writePAT()
{
    if (m_m2tsMode)
    {
        m_outBufLen += 4;
        m_processedBlockSize += 4;
        m_pcrBits += 4 * 8;
    }
    memcpy(m_outBuf + m_outBufLen, m_patBuffer, TS_FRAME_SIZE);
    TSPacket* tsPacket = (TSPacket*)(m_outBuf + m_outBufLen);
    tsPacket->counter = m_patCnt++;
    m_outBufLen += TS_FRAME_SIZE;
    m_processedBlockSize += TS_FRAME_SIZE;
    m_pcrBits += TS_FRAME_SIZE * 8;
    m_muxedPacketCnt[m_muxedPacketCnt.size() - 1]++;
    writeOutBuffer();
}

void TSMuxer::writePMT()
{
    uint8_t* curPos = m_pmtBuffer;
    for (int i = 0; i < m_pmtFrames; i++)
    {
        if (m_m2tsMode)
        {
            m_outBufLen += 4;
            m_processedBlockSize += 4;
            m_pcrBits += 4 * 8;
        }
        memcpy(m_outBuf + m_outBufLen, curPos, TS_FRAME_SIZE);
        TSPacket* tsPacket = (TSPacket*)(m_outBuf + m_outBufLen);
        tsPacket->counter = m_pmtCnt++;
        m_outBufLen += TS_FRAME_SIZE;
        m_processedBlockSize += TS_FRAME_SIZE;
        m_pcrBits += TS_FRAME_SIZE * 8;
        m_muxedPacketCnt[m_muxedPacketCnt.size() - 1]++;
        writeOutBuffer();
        curPos += TS_FRAME_SIZE;
    }
}

void TSMuxer::writeSIT()
{
    if (m_m2tsMode)
    {
        m_outBufLen += 4;
        m_processedBlockSize += 4;
        m_pcrBits += 4 * 8;
    }
    memcpy(m_outBuf + m_outBufLen, DefaultSitTableOne, TS_FRAME_SIZE);
    TSPacket* tsPacket = (TSPacket*)(m_outBuf + m_outBufLen);
    tsPacket->counter = m_sitCnt++;
    m_outBufLen += TS_FRAME_SIZE;
    m_processedBlockSize += TS_FRAME_SIZE;
    m_pcrBits += TS_FRAME_SIZE * 8;
    m_muxedPacketCnt[m_muxedPacketCnt.size() - 1]++;
    writeOutBuffer();
}

void TSMuxer::writeOutBuffer()
{
    if (m_outBufLen >= m_writeBlockSize)
    {
        int toFileLen = m_writeBlockSize & ~(MuxerManager::PHYSICAL_SECTOR_SIZE - 1);
        if (m_owner->isAsyncMode())
        {
            uint8_t* newBuf = new uint8_t[m_writeBlockSize + 1024];
            memcpy(newBuf, m_outBuf + toFileLen, m_outBufLen - toFileLen);
            if (m_m2tsMode)
            {
                if (m_prevM2TSPCROffset >= toFileLen && m_m2tsDelayBlocks.empty())
                {
                    m_owner->asyncWriteBuffer(this, m_outBuf, toFileLen, m_muxFile);
                    m_prevM2TSPCROffset -= toFileLen;
                }
                else
                    m_m2tsDelayBlocks.push_back(std::make_pair(m_outBuf, toFileLen));
            }
            else
                m_owner->asyncWriteBuffer(this, m_outBuf, toFileLen, m_muxFile);
            m_outBuf = newBuf;
        }
        else
        {
            if (!m_m2tsMode)
                m_owner->syncWriteBuffer(this, m_outBuf, toFileLen, m_muxFile);
            else
            {
                if (m_prevM2TSPCROffset >= toFileLen && m_m2tsDelayBlocks.empty())
                {
                    m_owner->syncWriteBuffer(this, m_outBuf, toFileLen, m_muxFile);
                    m_prevM2TSPCROffset -= toFileLen;
                }
                else
                {
                    uint8_t* newBuf = new uint8_t[toFileLen];
                    memcpy(newBuf, m_outBuf, toFileLen);
                    m_m2tsDelayBlocks.push_back(std::make_pair(newBuf, toFileLen));
                }
            }
            memmove(m_outBuf, m_outBuf + toFileLen, m_outBufLen - toFileLen);
        }
        m_outBufLen -= toFileLen;
    }
}

void TSMuxer::parseMuxOpt(const std::string& opts)
{
    vector<string> params = splitStr(opts.c_str(), ' ');
    for (auto& i : params)
    {
        vector<string> paramPair = splitStr(trimStr(i).c_str(), '=');
        if (paramPair.size() == 0)
            continue;
        if (paramPair[0] == ""--pcr-on-video-pid"")
            setPCROnVideoPID(true);
        else if (paramPair[0] == ""--new-audio-pes"")
            setNewStyleAudioPES(true);
        else if (paramPair[0] == ""--hdmv-descriptors"")
            m_hdmvDescriptors = true;
        else if (paramPair[0] == ""--bitrate"" && paramPair.size() > 1)
        {
            setMaxBitrate(strToDouble(paramPair[1].c_str()) * 1000.0);
            setMinBitrate(strToDouble(paramPair[1].c_str()) * 1000.0);
        }
        else if (paramPair[0] == ""--maxbitrate"" && paramPair.size() > 1)
            setMaxBitrate(strToDouble(paramPair[1].c_str()) * 1000.0);
        else if (paramPair[0] == ""--minbitrate"" && paramPair.size() > 1)
            setMinBitrate(strToDouble(paramPair[1].c_str()) * 1000.0);
        else if (paramPair[0] == ""--vbv-len"" && paramPair.size() > 1)
            setVBVBufferLen(strToInt32(paramPair[1].c_str()));
        else if (paramPair[0] == ""--split-duration"")
        {
            setSplitDuration(strToInt64(paramPair[1].c_str()) * 1000000000ull);
            m_computeMuxStats = true;
        }
        else if (paramPair[0] == ""--split-size"")
        {
            uint64_t coeff = 1;
            string postfix;
            for (auto& j : paramPair[1])
                if (!(j >= '0' && j <= '9' || j == '.'))
                    postfix += j;
            postfix = strToUpperCase(postfix);
            if (postfix == ""GB"")
                coeff = 1000000000ull;
            else if (postfix == ""GIB"")
                coeff = 1024ull * 1024ull * 1024ull;
            else if (postfix == ""MB"")
                coeff = 1000000;
            else if (postfix == ""MIB"")
                coeff = 1024 * 1024;
            else if (postfix == ""KB"")
                coeff = 1000;
            else if (postfix == ""KIB"")
                coeff = 1024;
            string prefix = paramPair[1].substr(0, paramPair[1].size() - postfix.size());
            setSplitSize(strToDouble(prefix.c_str()) * coeff);
            m_computeMuxStats = true;
        }
        else if (paramPair[0] == ""--blu-ray"" || paramPair[0] == ""--blu-ray-v3"" || paramPair[0] == ""--avchd"")
        {
            m_bluRayMode = true;
            m_computeMuxStats = true;
        }
        else if (paramPair[0] == ""--cut-start"" || paramPair[0] == ""--cut-end"")
        {
            m_computeMuxStats = true;
        }
    }
}

void TSMuxer::setSubMode(AbstractMuxer* mainMuxer, bool flushInterleavedBlock)
{
    m_sublingMuxer = dynamic_cast<TSMuxer*>(mainMuxer);
    m_subMode = true;
    m_canSwithBlock = flushInterleavedBlock;
    m_interliaveInfo.rbegin()->push_back(0);
}

void TSMuxer::joinToMasterFile()
{
    m_isExternalFile = true;
    m_muxFile = dynamic_cast<TSMuxer*>(m_sublingMuxer)->getDstFile();
}

void TSMuxer::setMasterMode(AbstractMuxer* subMuxer, bool flushInterleavedBlock)
{
    m_sublingMuxer = dynamic_cast<TSMuxer*>(subMuxer);
    m_masterMode = true;
    m_canSwithBlock = flushInterleavedBlock;
    m_interliaveInfo.rbegin()->push_back(0);
}

void TSMuxer::openDstFile()
{
    m_muxFile = m_fileFactory ? m_fileFactory->createFile() : new File();

    int systemFlags = 0;
#ifdef _WIN32
    if (m_owner->isAsyncMode())
        systemFlags += FILE_FLAG_NO_BUFFERING;
#endif
    if (!m_muxFile->open(m_outFileName.c_str(), File::ofWrite, systemFlags))
        THROW(ERR_CANT_CREATE_FILE, ""Can't create file "" << m_outFileName);
}

vector<int64_t> TSMuxer::getFirstPts()
{
    std::vector<int64_t> rez;
    for (auto& i : m_firstPts) rez.push_back(nanoClockToPts(i) + m_timeOffset);
    return rez;
}

void TSMuxer::alignPTS(TSMuxer* otherMuxer)
{
    if (!m_lastPts.empty() && !otherMuxer->m_lastPts.empty())
    {
        int64_t minPTS = FFMIN(*m_lastPts.rbegin(), *otherMuxer->m_lastPts.rbegin());
        *m_lastPts.rbegin() = minPTS;
        *otherMuxer->m_lastPts.rbegin() = minPTS;
    }
}

vector<int64_t> TSMuxer::getLastPts()
{
    std::vector<int64_t> rez;
    for (auto& i : m_lastPts) rez.push_back(nanoClockToPts(i) + m_timeOffset);
    // if (!rez.empty())
    //    *rez.rbegin() += m_mainStreamFrameDuration;
    return rez;
}

void TSMuxer::setFileName(const std::string& fileName, FileFactory* fileFactory)
{
    m_curFileNum = 0;
    AbstractMuxer::setFileName(fileName, fileFactory);
    m_outFileName = getNextName(fileName);
    string ext = strToUpperCase(extractFileExt(m_outFileName));
    setMuxFormat(ext);

    m_fileNames.clear();
    m_fileNames.push_back(m_outFileName);
}

std::string TSMuxer::getFileNameByIdx(size_t idx)
{
    if (idx < m_fileNames.size())
        return m_fileNames[idx];
    assert(1);
    return std::string();
}

void TSMuxer::setMuxFormat(const std::string& format)
{
    m_m2tsMode = format == ""M2TS"" || format == ""M2T"" || format == ""MTS"" || format == ""SSIF"";
    m_writeBlockSize = (m_m2tsMode ? DEFAULT_FILE_BLOCK_SIZE : TS188_ROUND_BLOCK_SIZE);
    m_outBuf = new uint8_t[m_writeBlockSize + 1024];
    m_frameSize = m_m2tsMode ? 192 : 188;
    if (m_m2tsMode)
        m_sectorSize = 1024 * 6;
}

bool TSMuxer::isInterleaveMode() const { return m_masterMode || m_subMode; }

std::vector<int32_t> TSMuxer::getInterleaveInfo(int idx) const { return m_interliaveInfo[idx]; }
",16325,True,2819.3936241779625,median
"**********************************************************************
* UTILS
**********************************************************************

CLASS lcl_utils DEFINITION FINAL.
  PUBLIC SECTION.

    CLASS-METHODS normalize_path
      IMPORTING
        iv_path TYPE string
      RETURNING
        VALUE(rv_path) TYPE string.
    CLASS-METHODS split_path
      IMPORTING
        iv_path TYPE string
      RETURNING
        VALUE(rv_path_name) TYPE zif_abapgit_ajson=>ty_path_name.
    CLASS-METHODS validate_array_index
      IMPORTING
        iv_path TYPE string
        iv_index TYPE string
      RETURNING
        VALUE(rv_index) TYPE i
      RAISING
        zcx_abapgit_ajson_error.

ENDCLASS.

CLASS lcl_utils IMPLEMENTATION.

  METHOD validate_array_index.

    IF NOT iv_index CO '0123456789'.
      zcx_abapgit_ajson_error=>raise( |Cannot add non-numeric key [{ iv_index }] to array [{ iv_path }]| ).
    ENDIF.
    rv_index = iv_index.
    IF rv_index = 0.
      zcx_abapgit_ajson_error=>raise( |Cannot add zero key to array [{ iv_path }]| ).
    ENDIF.

  ENDMETHOD.

  METHOD normalize_path.

    rv_path = iv_path.
    IF strlen( rv_path ) = 0.
      rv_path = '/'.
    ENDIF.
    IF rv_path+0(1) <> '/'.
      rv_path = '/' && rv_path.
    ENDIF.
    IF substring( val = rv_path
                  off = strlen( rv_path ) - 1 ) <> '/'.
      rv_path = rv_path && '/'.
    ENDIF.

  ENDMETHOD.

  METHOD split_path.

    DATA lv_offs TYPE i.
    DATA lv_len TYPE i.
    DATA lv_trim_slash TYPE i.

    lv_len = strlen( iv_path ).
    IF lv_len = 0 OR iv_path = '/'.
      RETURN. "" empty path is the alias for root item = '' + ''
    ENDIF.

    IF substring( val = iv_path
                  off = lv_len - 1 ) = '/'.
      lv_trim_slash = 1. "" ignore last '/'
    ENDIF.

    lv_offs = find( val = reverse( iv_path )
                    sub = '/'
                    off = lv_trim_slash ).
    IF lv_offs = -1.
      lv_offs  = lv_len. "" treat whole string as the 'name' part
    ENDIF.
    lv_offs = lv_len - lv_offs.

    rv_path_name-path = normalize_path( substring( val = iv_path
                                                   len = lv_offs ) ).
    rv_path_name-name = substring( val = iv_path
                                   off = lv_offs
                                   len = lv_len - lv_offs - lv_trim_slash ).

  ENDMETHOD.

ENDCLASS.


**********************************************************************
* PARSER
**********************************************************************

CLASS lcl_json_parser DEFINITION FINAL.
  PUBLIC SECTION.

    METHODS parse
      IMPORTING
        iv_json TYPE string
      RETURNING
        VALUE(rt_json_tree) TYPE zif_abapgit_ajson=>ty_nodes_tt
      RAISING
        zcx_abapgit_ajson_error.

  PRIVATE SECTION.

    TYPES:
      ty_stack_tt TYPE STANDARD TABLE OF REF TO zif_abapgit_ajson=>ty_node.

    DATA mt_stack TYPE ty_stack_tt.

    CLASS-METHODS join_path
      IMPORTING
        it_stack TYPE ty_stack_tt
      RETURNING
        VALUE(rv_path) TYPE string.

    METHODS raise
      IMPORTING
        iv_error TYPE string
      RAISING
        zcx_abapgit_ajson_error.

    METHODS _parse
      IMPORTING
        iv_json TYPE string
      RETURNING
        VALUE(rt_json_tree) TYPE zif_abapgit_ajson=>ty_nodes_tt
      RAISING
        zcx_abapgit_ajson_error cx_sxml_error.

    METHODS _get_location
      IMPORTING
        iv_json            TYPE string
        iv_offset          TYPE i
      RETURNING
        VALUE(rv_location) TYPE string.

ENDCLASS.

CLASS lcl_json_parser IMPLEMENTATION.

  METHOD parse.
    DATA lx_sxml_parse TYPE REF TO cx_sxml_parse_error.
    DATA lx_sxml TYPE REF TO cx_sxml_error.
    DATA lv_location TYPE string.
    TRY.
      "" TODO sane JSON check:
      "" JSON can be true,false,null,(-)digits
      "" or start from "" or from {
        rt_json_tree = _parse( iv_json ).
      CATCH cx_sxml_parse_error INTO lx_sxml_parse.
        lv_location = _get_location(
        iv_json   = iv_json
        iv_offset = lx_sxml_parse->xml_offset ).
        zcx_abapgit_ajson_error=>raise(
        iv_msg      = |Json parsing error (SXML): { lx_sxml_parse->get_text( ) }|
        iv_location = lv_location ).
      CATCH cx_sxml_error INTO lx_sxml.
        zcx_abapgit_ajson_error=>raise(
        iv_msg      = |Json parsing error (SXML): { lx_sxml->get_text( ) }|
        iv_location = '@PARSER' ).
    ENDTRY.
  ENDMETHOD.

  METHOD _get_location.

    DATA lv_json TYPE string.
    DATA lv_offset TYPE i.
    DATA lt_text TYPE TABLE OF string.
    DATA lv_text TYPE string.
    DATA lv_line TYPE i.
    DATA lv_pos TYPE i.

    lv_offset = iv_offset.
    IF lv_offset < 0.
      lv_offset = 0.
    ENDIF.
    IF lv_offset > strlen( iv_json ).
      lv_offset = strlen( iv_json ).
    ENDIF.

    lv_json = iv_json(lv_offset).

    REPLACE ALL OCCURRENCES OF cl_abap_char_utilities=>cr_lf
      IN lv_json WITH cl_abap_char_utilities=>newline.

    SPLIT lv_json AT cl_abap_char_utilities=>newline INTO TABLE lt_text.

    lv_line = lines( lt_text ).
    IF lv_line = 0.
      lv_line = 1.
      lv_pos = 1.
    ELSE.
      READ TABLE lt_text INDEX lv_line INTO lv_text.
      lv_pos = strlen( lv_text ) + 1.
    ENDIF.

    rv_location = |Line { lv_line }, Offset { lv_pos }|.

  ENDMETHOD.

  METHOD _parse.

    DATA lo_reader TYPE REF TO if_sxml_reader.
    DATA lr_stack_top LIKE LINE OF mt_stack.
    DATA lo_node TYPE REF TO if_sxml_node.
    FIELD-SYMBOLS <item> LIKE LINE OF rt_json_tree.

    CLEAR mt_stack.
    IF iv_json IS INITIAL.
      RETURN.
    ENDIF.
    lo_reader = cl_sxml_string_reader=>create( cl_abap_codepage=>convert_to( iv_json ) ).

    "" TODO: self protection, check non-empty, check starting from object ...

    DO.
      lo_node = lo_reader->read_next_node( ).
      IF lo_node IS NOT BOUND.
        EXIT.
      ENDIF.


      CASE lo_node->type.
        WHEN if_sxml_node=>co_nt_element_open.
          DATA lt_attributes TYPE if_sxml_attribute=>attributes.
          DATA lo_attr LIKE LINE OF lt_attributes.
          DATA lo_open TYPE REF TO if_sxml_open_element.
          lo_open ?= lo_node.

          APPEND INITIAL LINE TO rt_json_tree ASSIGNING <item>.

          <item>-type = to_lower( lo_open->qname-name ).

          READ TABLE mt_stack INDEX 1 INTO lr_stack_top.
          IF sy-subrc = 0.
            <item>-path = join_path( mt_stack ).
            lr_stack_top->children = lr_stack_top->children + 1.

            IF lr_stack_top->type = 'array'.
              <item>-name = |{ lr_stack_top->children }|.
              <item>-index = lr_stack_top->children.
            ELSE.
              lt_attributes = lo_open->get_attributes( ).
              LOOP AT lt_attributes INTO lo_attr.
                IF lo_attr->qname-name = 'name' AND lo_attr->value_type = if_sxml_value=>co_vt_text.
                  <item>-name = lo_attr->get_value( ).
                ENDIF.
              ENDLOOP.
            ENDIF.
            IF <item>-name IS INITIAL.
              raise( 'Node without name (maybe not JSON)' ).
            ENDIF.
          ENDIF.

          GET REFERENCE OF <item> INTO lr_stack_top.
          INSERT lr_stack_top INTO mt_stack INDEX 1.

        WHEN if_sxml_node=>co_nt_element_close.
          DATA lo_close TYPE REF TO if_sxml_close_element.
          lo_close ?= lo_node.

          READ TABLE mt_stack INDEX 1 INTO lr_stack_top.
          DELETE mt_stack INDEX 1.
          IF lo_close->qname-name <> lr_stack_top->type.
            raise( 'Unexpected closing node type' ).
          ENDIF.

        WHEN if_sxml_node=>co_nt_value.
          DATA lo_value TYPE REF TO if_sxml_value_node.
          lo_value ?= lo_node.

          <item>-value = lo_value->get_value( ).

        WHEN OTHERS.
          raise( 'Unexpected node type' ).
      ENDCASE.
    ENDDO.

    IF lines( mt_stack ) > 0.
      raise( 'Unexpected end of data' ).
    ENDIF.

  ENDMETHOD.

  METHOD join_path.

    FIELD-SYMBOLS <ref> LIKE LINE OF it_stack.

    LOOP AT it_stack ASSIGNING <ref>.
      rv_path = <ref>->name && '/' && rv_path.
    ENDLOOP.

  ENDMETHOD.

  METHOD raise.

    zcx_abapgit_ajson_error=>raise(
      iv_location = join_path( mt_stack )
      iv_msg      = |JSON PARSER: { iv_error } @ { join_path( mt_stack ) }| ).

  ENDMETHOD.

ENDCLASS.

**********************************************************************
* SERIALIZER
**********************************************************************

CLASS lcl_json_serializer DEFINITION FINAL CREATE PRIVATE.
  PUBLIC SECTION.

    CLASS-METHODS stringify
      IMPORTING
        it_json_tree TYPE zif_abapgit_ajson=>ty_nodes_ts
        iv_indent TYPE i DEFAULT 0
        iv_keep_item_order TYPE abap_bool DEFAULT abap_false
      RETURNING
        VALUE(rv_json_string) TYPE string
      RAISING
        zcx_abapgit_ajson_error.

    CLASS-METHODS class_constructor.

  PRIVATE SECTION.

    CLASS-DATA gv_comma_with_lf TYPE string.

    DATA mt_json_tree TYPE zif_abapgit_ajson=>ty_nodes_ts.
    DATA mv_keep_item_order TYPE abap_bool.
    DATA mt_buffer TYPE string_table.
    DATA mv_indent_step TYPE i.
    DATA mv_level TYPE i.

    CLASS-METHODS escape
      IMPORTING
        iv_unescaped TYPE string
      RETURNING
        VALUE(rv_escaped) TYPE string.

    METHODS _stringify
      RETURNING
        VALUE(rv_json_string) TYPE string
      RAISING
        zcx_abapgit_ajson_error.

    METHODS stringify_node
      IMPORTING
        is_node TYPE zif_abapgit_ajson=>ty_node
      RAISING
        zcx_abapgit_ajson_error.

    METHODS stringify_set
      IMPORTING
        iv_parent_path TYPE string
        iv_array TYPE abap_bool
      RAISING
        zcx_abapgit_ajson_error.

ENDCLASS.

CLASS lcl_json_serializer IMPLEMENTATION.

  METHOD class_constructor.
    gv_comma_with_lf = ',' && cl_abap_char_utilities=>newline.
  ENDMETHOD.

  METHOD stringify.

    DATA lo TYPE REF TO lcl_json_serializer.
    CREATE OBJECT lo.
    lo->mt_json_tree = it_json_tree.
    lo->mv_indent_step = iv_indent.
    lo->mv_keep_item_order = iv_keep_item_order.
    rv_json_string = lo->_stringify( ).

  ENDMETHOD.

  METHOD _stringify.

    FIELD-SYMBOLS <n> LIKE LINE OF mt_json_tree.
    READ TABLE mt_json_tree ASSIGNING <n>
      WITH KEY
        path = ''
        name = ''. "" Root
    IF sy-subrc <> 0.
      RETURN.
    ENDIF.

    stringify_node( <n> ).

    rv_json_string = concat_lines_of( table = mt_buffer ).

  ENDMETHOD.

  METHOD stringify_node.

    DATA lv_item TYPE string.
    DATA lv_indent_prefix TYPE string.

    IF mv_indent_step > 0.
      lv_indent_prefix = repeat( val = ` `
                                 occ = mv_indent_step * mv_level ).
      lv_item = lv_indent_prefix.
    ENDIF.

    IF is_node-name IS NOT INITIAL AND is_node-index IS INITIAL. "" Not root, not array item
      IF mv_indent_step > 0.
        lv_item = lv_item && |""{ is_node-name }"": |.
      ELSE.
        lv_item = |""{ is_node-name }"":|.
      ENDIF.
    ENDIF.

    CASE is_node-type.
      WHEN zif_abapgit_ajson=>node_type-array.
        lv_item = lv_item && '['.
      WHEN zif_abapgit_ajson=>node_type-object.
        lv_item = lv_item && '{'.
      WHEN zif_abapgit_ajson=>node_type-string.
        lv_item = lv_item && |""{ escape( is_node-value ) }""|.
      WHEN zif_abapgit_ajson=>node_type-boolean OR zif_abapgit_ajson=>node_type-number.
        lv_item = lv_item && is_node-value.
      WHEN zif_abapgit_ajson=>node_type-null.
        lv_item = lv_item && 'null'.
      WHEN OTHERS.
        zcx_abapgit_ajson_error=>raise(
          iv_msg = |Unexpected type [{ is_node-type }]|
          iv_location = is_node-path && is_node-name ).
    ENDCASE.

    IF mv_indent_step > 0
      AND ( is_node-type = zif_abapgit_ajson=>node_type-array OR is_node-type = zif_abapgit_ajson=>node_type-object )
      AND is_node-children > 0.
      mv_level = mv_level + 1.
      lv_item = lv_item && cl_abap_char_utilities=>newline.
    ENDIF.

    APPEND lv_item TO mt_buffer.

    "" finish complex item

    IF is_node-type = zif_abapgit_ajson=>node_type-array OR is_node-type = zif_abapgit_ajson=>node_type-object.
      DATA lv_children_path TYPE string.
      DATA lv_tail TYPE string.

      lv_children_path = is_node-path && is_node-name && '/'. "" for root: path = '' and name = '', so result is '/'

      CASE is_node-type.
        WHEN zif_abapgit_ajson=>node_type-array.
          IF is_node-children > 0.
            stringify_set(
              iv_parent_path = lv_children_path
              iv_array       = abap_true ).
          ENDIF.
          lv_tail = ']'.
        WHEN zif_abapgit_ajson=>node_type-object.
          IF is_node-children > 0.
            stringify_set(
              iv_parent_path = lv_children_path
              iv_array       = abap_false ).
          ENDIF.
          lv_tail = '}'.
      ENDCASE.

      IF mv_indent_step > 0 AND is_node-children > 0.
        lv_tail = lv_indent_prefix && lv_tail.
        mv_level = mv_level - 1.
      ENDIF.
      APPEND lv_tail TO mt_buffer.
    ENDIF.

  ENDMETHOD.

  METHOD stringify_set.

    DATA lv_tab_key TYPE string.
    DATA lv_first_done TYPE abap_bool.
    FIELD-SYMBOLS <n> LIKE LINE OF mt_json_tree.

    IF iv_array = abap_true.
      lv_tab_key = 'array_index'. "" path + index
    ELSEIF mv_keep_item_order = abap_true.
      lv_tab_key = 'item_order'. "" path + order
    ELSE.
      lv_tab_key = 'primary_key'. "" path + name
    ENDIF.

    LOOP AT mt_json_tree ASSIGNING <n> USING KEY (lv_tab_key) WHERE path = iv_parent_path.
      IF lv_first_done = abap_false.
        lv_first_done = abap_true.
      ELSEIF mv_indent_step > 0.
        APPEND gv_comma_with_lf TO mt_buffer.
      ELSE.
        APPEND ',' TO mt_buffer.
      ENDIF.
      stringify_node( <n> ).
    ENDLOOP.

    IF mv_indent_step > 0 AND lv_first_done = abap_true. "" only of items were in the list
      APPEND cl_abap_char_utilities=>newline TO mt_buffer.
    ENDIF.

  ENDMETHOD.

  METHOD escape.

    rv_escaped = iv_unescaped.
    IF rv_escaped CA |""\\\\\\t\\n\\r|.
      "" TODO consider performance ...
      "" see also https://www.json.org/json-en.html
      rv_escaped = replace(
        val = rv_escaped
        sub = '\\'
        with = '\\\\'
        occ = 0 ).
      rv_escaped = replace(
        val = rv_escaped
        sub = |\\n|
        with = '\\n'
        occ = 0 ).
      rv_escaped = replace(
        val = rv_escaped
        sub = |\\r|
        with = '\\r'
        occ = 0 ).
      rv_escaped = replace(
        val = rv_escaped
        sub = |\\t|
        with = '\\t'
        occ = 0 ).
      rv_escaped = replace(
        val = rv_escaped
        sub = '""'
        with = '\\""'
        occ = 0 ).

    ENDIF.

  ENDMETHOD.

ENDCLASS.


**********************************************************************
* JSON_TO_ABAP
**********************************************************************

CLASS lcl_json_to_abap DEFINITION FINAL.
  PUBLIC SECTION.

    METHODS constructor
      IMPORTING
        !ii_custom_mapping TYPE REF TO zif_abapgit_ajson_mapping OPTIONAL.

    METHODS to_abap
      IMPORTING
        it_nodes     TYPE zif_abapgit_ajson=>ty_nodes_ts
      CHANGING
        c_container TYPE any
      RAISING
        zcx_abapgit_ajson_error.

    METHODS to_timestamp
      IMPORTING
        iv_value         TYPE zif_abapgit_ajson=>ty_node-value
      RETURNING
        VALUE(rv_result) TYPE timestamp
      RAISING
        zcx_abapgit_ajson_error.

    METHODS to_date
      IMPORTING
        iv_value         TYPE zif_abapgit_ajson=>ty_node-value
      RETURNING
        VALUE(rv_result) TYPE d
      RAISING
        zcx_abapgit_ajson_error.

  PRIVATE SECTION.

    TYPES:
      BEGIN OF ty_type_cache,
        type_path         TYPE string,
        target_field_name TYPE string,
        dd                TYPE REF TO cl_abap_datadescr,
        type_kind         LIKE cl_abap_typedescr=>typekind_any,
        tab_item_buf      TYPE REF TO data,
      END OF ty_type_cache.
    DATA mt_node_type_cache TYPE HASHED TABLE OF ty_type_cache WITH UNIQUE KEY type_path.

    DATA mr_nodes TYPE REF TO zif_abapgit_ajson=>ty_nodes_ts.
    DATA mi_custom_mapping TYPE REF TO zif_abapgit_ajson_mapping.

    METHODS any_to_abap
      IMPORTING
        iv_path        TYPE string
        is_parent_type TYPE ty_type_cache OPTIONAL
        i_container_ref TYPE REF TO data
      RAISING
        zcx_abapgit_ajson_error.

    METHODS value_to_abap
      IMPORTING
        is_node      TYPE zif_abapgit_ajson=>ty_node
        is_node_type TYPE ty_type_cache
        i_container_ref TYPE REF TO data
      RAISING
        zcx_abapgit_ajson_error
        cx_sy_conversion_no_number.

    METHODS get_node_type
      IMPORTING
        is_node            TYPE zif_abapgit_ajson=>ty_node OPTIONAL "" Empty for root
        is_parent_type     TYPE ty_type_cache OPTIONAL
        i_container_ref    TYPE REF TO data OPTIONAL
      RETURNING
        VALUE(rs_node_type) TYPE ty_type_cache
      RAISING
        zcx_abapgit_ajson_error.

ENDCLASS.

CLASS lcl_json_to_abap IMPLEMENTATION.

  METHOD constructor.
    mi_custom_mapping = ii_custom_mapping.
  ENDMETHOD.

  METHOD to_abap.

    DATA lr_ref TYPE REF TO data.

    CLEAR c_container. "" what about data/obj refs ?
    CLEAR mt_node_type_cache.

    GET REFERENCE OF c_container INTO lr_ref.
    GET REFERENCE OF it_nodes INTO mr_nodes.

    get_node_type( i_container_ref = lr_ref ). "" Pre-cache root node type

    any_to_abap(
      iv_path         = ''
      i_container_ref = lr_ref ).

  ENDMETHOD.

  METHOD get_node_type.

    DATA lv_node_type_path TYPE string.
    DATA lo_sdescr TYPE REF TO cl_abap_structdescr.
    DATA lo_tdescr TYPE REF TO cl_abap_tabledescr.
    DATA lo_ddescr TYPE REF TO cl_abap_datadescr.

    "" Calculate type path
    IF is_parent_type-type_kind = cl_abap_typedescr=>typekind_table.
      lv_node_type_path = is_parent_type-type_path && '/-'. "" table item type
    ELSEIF is_parent_type-type_kind IS NOT INITIAL.
      lv_node_type_path = is_parent_type-type_path && '/' && is_node-name.
    ENDIF. "" For root node lv_node_type_path remains ''

    "" Get or create cached
    READ TABLE mt_node_type_cache INTO rs_node_type WITH KEY type_path = lv_node_type_path.
    IF sy-subrc <> 0.

      rs_node_type-type_path         = lv_node_type_path.

      IF mi_custom_mapping IS BOUND.
        rs_node_type-target_field_name = to_upper( mi_custom_mapping->to_abap(
          iv_path = is_node-path
          iv_name = is_node-name ) ).
        IF rs_node_type-target_field_name IS INITIAL.
          rs_node_type-target_field_name = to_upper( is_node-name ).
        ENDIF.
      ELSE.
        rs_node_type-target_field_name = to_upper( is_node-name ).
      ENDIF.

      CASE is_parent_type-type_kind.
        WHEN 'h'. "" Table
          lo_tdescr ?= is_parent_type-dd.
          rs_node_type-dd = lo_tdescr->get_table_line_type( ).

        WHEN 'u' OR 'v'. "" Structure
          lo_sdescr ?= is_parent_type-dd.
          lo_sdescr->get_component_type(
            EXPORTING
              p_name      = rs_node_type-target_field_name
            RECEIVING
              p_descr_ref = rs_node_type-dd
            EXCEPTIONS
              component_not_found = 4 ).
          IF sy-subrc <> 0.
            zcx_abapgit_ajson_error=>raise( |Path not found| ).
          ENDIF.

        WHEN ''. "" Root node
          rs_node_type-dd ?= cl_abap_typedescr=>describe_by_data_ref( i_container_ref ).

        WHEN OTHERS.
          zcx_abapgit_ajson_error=>raise( |Unexpected parent type| ).
      ENDCASE.

      rs_node_type-type_kind         = rs_node_type-dd->type_kind. "" for caching and cleaner unintialized access
      IF rs_node_type-type_kind = 'h'. "" Table
        lo_tdescr ?= rs_node_type-dd.
        IF lo_tdescr->table_kind <> 'S'. "" standard
          lo_ddescr = lo_tdescr->get_table_line_type( ).
          CREATE DATA rs_node_type-tab_item_buf TYPE HANDLE lo_ddescr.
        ENDIF.
      ENDIF.

      INSERT rs_node_type INTO TABLE mt_node_type_cache.
    ENDIF.

  ENDMETHOD.

  METHOD any_to_abap.

    DATA ls_node_type LIKE LINE OF mt_node_type_cache.
    DATA lx_ajson TYPE REF TO zcx_abapgit_ajson_error.
    DATA lx_root TYPE REF TO cx_root.
    DATA lr_target_field TYPE REF TO data.

    FIELD-SYMBOLS <n> TYPE zif_abapgit_ajson=>ty_node.
    FIELD-SYMBOLS <parent_stdtab> TYPE STANDARD TABLE.
    FIELD-SYMBOLS <parent_anytab> TYPE ANY TABLE.
    FIELD-SYMBOLS <parent_struc> TYPE any.
    FIELD-SYMBOLS <tab_item> TYPE any.

    "" Assign container
    CASE is_parent_type-type_kind.
      WHEN 'h'. "" Table
        IF is_parent_type-tab_item_buf IS BOUND. "" Indirect hint that table was sorted/hashed, see get_node_type.
          ASSIGN i_container_ref->* TO <parent_anytab>.
          ASSERT sy-subrc = 0.

          lr_target_field = is_parent_type-tab_item_buf. "" For hashed/sorted table - same buffer for all children
          ASSIGN is_parent_type-tab_item_buf->* TO <tab_item>.
          ASSERT sy-subrc = 0.

        ELSE.
          ASSIGN i_container_ref->* TO <parent_stdtab>.
          ASSERT sy-subrc = 0.
        ENDIF.

      WHEN 'u' OR 'v'. "" Structure
        ASSIGN i_container_ref->* TO <parent_struc>.
        ASSERT sy-subrc = 0.
    ENDCASE.

    TRY.

      "" array_index because stringified index goes in wrong order [1, 10, 2 ...]
        LOOP AT mr_nodes->* ASSIGNING <n> USING KEY array_index WHERE path = iv_path.

        "" Get or create type cache record
          IF is_parent_type-type_kind <> 'h' OR ls_node_type-type_kind IS INITIAL.
          "" table records are the same, no need to refetch twice
            ls_node_type = get_node_type(
            is_node        = <n>
            is_parent_type = is_parent_type ).
          ENDIF.

        "" Validate node type
          IF ls_node_type-type_kind CA 'lr'. "" data/obj ref
          "" TODO maybe in future
            zcx_abapgit_ajson_error=>raise( 'Cannot assign to ref' ).
          ENDIF.

        "" Find target field reference
          CASE is_parent_type-type_kind.
            WHEN 'h'. "" Table
              IF NOT ls_node_type-target_field_name CO '0123456789'.
              "" Does not affect anything actually but for integrity
                zcx_abapgit_ajson_error=>raise( 'Need index to access tables' ).
              ENDIF.

              IF is_parent_type-tab_item_buf IS NOT BOUND. "" Indirect hint that table was srt/hsh, see get_node_type
                APPEND INITIAL LINE TO <parent_stdtab> REFERENCE INTO lr_target_field.
                ASSERT sy-subrc = 0.
              ENDIF.

            WHEN 'u' OR 'v'.
              FIELD-SYMBOLS <field> TYPE any.
              ASSIGN COMPONENT ls_node_type-target_field_name OF STRUCTURE <parent_struc> TO <field>.
              ASSERT sy-subrc = 0.
              GET REFERENCE OF <field> INTO lr_target_field.

            WHEN ''. "" Root node
              lr_target_field = i_container_ref.

            WHEN OTHERS.
              zcx_abapgit_ajson_error=>raise( 'Unexpected parent type' ).
          ENDCASE.

        "" Process value assignment
          CASE <n>-type.
            WHEN zif_abapgit_ajson=>node_type-object.
              IF NOT ls_node_type-type_kind CO 'uv'.
                zcx_abapgit_ajson_error=>raise( 'Expected structure' ).
              ENDIF.
              any_to_abap(
              iv_path         = <n>-path && <n>-name && '/'
              is_parent_type  = ls_node_type
              i_container_ref = lr_target_field ).

            WHEN zif_abapgit_ajson=>node_type-array.
              IF NOT ls_node_type-type_kind = 'h'.
                zcx_abapgit_ajson_error=>raise( 'Expected table' ).
              ENDIF.
              any_to_abap(
              iv_path         = <n>-path && <n>-name && '/'
              is_parent_type  = ls_node_type
              i_container_ref = lr_target_field ).

            WHEN OTHERS.
              value_to_abap(
              is_node         = <n>
              is_node_type    = ls_node_type
              i_container_ref = lr_target_field ).
          ENDCASE.

          IF is_parent_type-tab_item_buf IS BOUND. "" Indirect hint that table was sorted/hashed, see get_node_type.
            TRY.
                INSERT <tab_item> INTO TABLE <parent_anytab>.
              CATCH cx_sy_itab_duplicate_key.
                sy-subrc = 4.
            ENDTRY.
            IF sy-subrc <> 0.
              zcx_abapgit_ajson_error=>raise( 'Duplicate insertion' ).
            ENDIF.
          ENDIF.

        ENDLOOP.

      CATCH zcx_abapgit_ajson_error INTO lx_ajson.
        IF lx_ajson->location IS INITIAL.
          lx_ajson->set_location( <n>-path && <n>-name ).
        ENDIF.
        RAISE EXCEPTION lx_ajson.
      CATCH cx_sy_conversion_no_number.
        zcx_abapgit_ajson_error=>raise(
        iv_msg = 'Source is not a number'
        iv_location = <n>-path && <n>-name ).
      CATCH cx_root INTO lx_root.
        zcx_abapgit_ajson_error=>raise(
        iv_msg = lx_root->get_text( )
        iv_location = <n>-path && <n>-name ).
    ENDTRY.

  ENDMETHOD.

  METHOD value_to_abap.

    FIELD-SYMBOLS <container> TYPE any.

    IF is_node_type-type_kind CA 'lruvh'. "" refs, table, strucs
      zcx_abapgit_ajson_error=>raise( |Unsupported target for value [{ is_node_type-type_kind }]| ).
    ENDIF.

    ASSIGN i_container_ref->* TO <container>.
    ASSERT sy-subrc = 0.

    CASE is_node-type.
      WHEN zif_abapgit_ajson=>node_type-null.
        "" Do nothing
      WHEN zif_abapgit_ajson=>node_type-boolean.
        "" TODO: check type ?
        <container> = boolc( is_node-value = 'true' ).
      WHEN zif_abapgit_ajson=>node_type-number.
        "" TODO: check type ?
        <container> = is_node-value.

      WHEN zif_abapgit_ajson=>node_type-string.
        "" TODO: check type ?
        IF is_node_type-type_kind = 'D' AND is_node-value IS NOT INITIAL.
          <container> = to_date( is_node-value ).
        ELSEIF is_node_type-type_kind = 'P' AND is_node-value IS NOT INITIAL.
          <container> = to_timestamp( is_node-value ).
        ELSE.
          <container> = is_node-value.
        ENDIF.
      WHEN OTHERS.
        zcx_abapgit_ajson_error=>raise( |Unexpected JSON type [{ is_node-type }]| ).
    ENDCASE.

  ENDMETHOD.

  METHOD to_date.

    DATA lv_y TYPE c LENGTH 4.
    DATA lv_m TYPE c LENGTH 2.
    DATA lv_d TYPE c LENGTH 2.

    FIND FIRST OCCURRENCE OF REGEX '^(\\d{4})-(\\d{2})-(\\d{2})(T|$)'
      IN iv_value
      SUBMATCHES lv_y lv_m lv_d.
    IF sy-subrc <> 0.
      zcx_abapgit_ajson_error=>raise( 'Unexpected date format' ).
    ENDIF.
    CONCATENATE lv_y lv_m lv_d INTO rv_result.

  ENDMETHOD.

  METHOD to_timestamp.

    CONSTANTS lc_utc TYPE c LENGTH 6 VALUE 'UTC'.
    CONSTANTS lc_regex_ts_with_hour TYPE string
      VALUE `^(\\d{4})-(\\d{2})-(\\d{2})(T)(\\d{2}):(\\d{2}):(\\d{2})(\\+)(\\d{2}):(\\d{2})`.
    CONSTANTS lc_regex_ts_utc TYPE string
      VALUE `^(\\d{4})-(\\d{2})-(\\d{2})(T)(\\d{2}):(\\d{2}):(\\d{2})(Z|$)`.

    DATA:
      BEGIN OF ls_timestamp,
        year         TYPE c LENGTH 4,
        month        TYPE c LENGTH 2,
        day          TYPE c LENGTH 2,
        t            TYPE c LENGTH 1,
        hour         TYPE c LENGTH 2,
        minute       TYPE c LENGTH 2,
        second       TYPE c LENGTH 2,
        local_sign   TYPE c LENGTH 1,
        local_hour   TYPE c LENGTH 2,
        local_minute TYPE c LENGTH 2,
      END OF ls_timestamp.

    DATA lv_date TYPE d.
    DATA lv_time TYPE t.
    DATA lv_seconds_conv TYPE i.
    DATA lv_timestamp TYPE timestampl.

    FIND FIRST OCCURRENCE OF REGEX lc_regex_ts_with_hour
      IN iv_value SUBMATCHES
        ls_timestamp-year ls_timestamp-month ls_timestamp-day ls_timestamp-t
        ls_timestamp-hour ls_timestamp-minute ls_timestamp-second
        ls_timestamp-local_sign ls_timestamp-local_hour ls_timestamp-local_minute.

    IF sy-subrc = 0.

      lv_seconds_conv = ( ls_timestamp-local_hour * 3600 ) + ( ls_timestamp-local_minute * 60 ).

    ELSE.

      FIND FIRST OCCURRENCE OF REGEX lc_regex_ts_utc
        IN iv_value SUBMATCHES
          ls_timestamp-year ls_timestamp-month ls_timestamp-day ls_timestamp-t
          ls_timestamp-hour ls_timestamp-minute ls_timestamp-second.

      IF sy-subrc <> 0.
        zcx_abapgit_ajson_error=>raise( 'Unexpected timestamp format' ).
      ENDIF.

    ENDIF.

    CONCATENATE ls_timestamp-year ls_timestamp-month ls_timestamp-day INTO lv_date.
    CONCATENATE ls_timestamp-hour ls_timestamp-minute ls_timestamp-second INTO lv_time.

    CONVERT DATE lv_date TIME lv_time INTO TIME STAMP lv_timestamp TIME ZONE lc_utc.

    TRY.

        CASE ls_timestamp-local_sign.
          WHEN '-'.
            lv_timestamp = cl_abap_tstmp=>add(
            tstmp = lv_timestamp
            secs  = lv_seconds_conv ).
          WHEN '+'.
            lv_timestamp = cl_abap_tstmp=>subtractsecs(
            tstmp = lv_timestamp
            secs  = lv_seconds_conv ).
        ENDCASE.

      CATCH cx_parameter_invalid_range cx_parameter_invalid_type.
        zcx_abapgit_ajson_error=>raise( 'Unexpected error calculating timestamp' ).
    ENDTRY.

    cl_abap_tstmp=>move(
      EXPORTING
        tstmp_src = lv_timestamp
      IMPORTING
        tstmp_tgt = rv_result ).

  ENDMETHOD.

ENDCLASS.

**********************************************************************
* ABAP_TO_JSON
**********************************************************************

CLASS lcl_abap_to_json DEFINITION FINAL.
  PUBLIC SECTION.

    CLASS-METHODS convert
      IMPORTING
        iv_data            TYPE any
        is_prefix          TYPE zif_abapgit_ajson=>ty_path_name OPTIONAL
        iv_array_index     TYPE i DEFAULT 0
        ii_custom_mapping  TYPE REF TO zif_abapgit_ajson_mapping OPTIONAL
        iv_keep_item_order TYPE abap_bool DEFAULT abap_false
        iv_format_datetime TYPE abap_bool DEFAULT abap_false
      RETURNING
        VALUE(rt_nodes)   TYPE zif_abapgit_ajson=>ty_nodes_tt
      RAISING
        zcx_abapgit_ajson_error.

    CLASS-METHODS insert_with_type
      IMPORTING
        iv_data            TYPE any
        iv_type            TYPE string
        is_prefix          TYPE zif_abapgit_ajson=>ty_path_name OPTIONAL
        iv_array_index     TYPE i DEFAULT 0
        ii_custom_mapping  TYPE REF TO zif_abapgit_ajson_mapping OPTIONAL
        iv_keep_item_order TYPE abap_bool DEFAULT abap_false
        iv_format_datetime TYPE abap_bool DEFAULT abap_false
      RETURNING
        VALUE(rt_nodes)   TYPE zif_abapgit_ajson=>ty_nodes_tt
      RAISING
        zcx_abapgit_ajson_error.

    CLASS-METHODS format_date
      IMPORTING
        iv_date TYPE d
      RETURNING
        VALUE(rv_str) TYPE string.
    CLASS-METHODS format_time
      IMPORTING
        iv_time TYPE t
      RETURNING
        VALUE(rv_str) TYPE string.
    CLASS-METHODS format_timestamp
      IMPORTING
        iv_ts TYPE timestamp
      RETURNING
        VALUE(rv_str) TYPE string.

    CLASS-METHODS class_constructor.

  PRIVATE SECTION.

    CLASS-DATA gv_ajson_absolute_type_name TYPE string.
    DATA mi_custom_mapping TYPE REF TO zif_abapgit_ajson_mapping.
    DATA mv_keep_item_order TYPE abap_bool.
    DATA mv_format_datetime TYPE abap_bool.

    METHODS convert_any
      IMPORTING
        iv_data TYPE any
        io_type TYPE REF TO cl_abap_typedescr
        is_prefix TYPE zif_abapgit_ajson=>ty_path_name
        iv_index TYPE i DEFAULT 0
        iv_item_order TYPE i DEFAULT 0
      CHANGING
        ct_nodes TYPE zif_abapgit_ajson=>ty_nodes_tt
      RAISING
        zcx_abapgit_ajson_error.

    METHODS convert_ajson
      IMPORTING
        io_json TYPE REF TO zif_abapgit_ajson
        is_prefix TYPE zif_abapgit_ajson=>ty_path_name
        iv_index TYPE i DEFAULT 0
      CHANGING
        ct_nodes TYPE zif_abapgit_ajson=>ty_nodes_tt
      RAISING
        zcx_abapgit_ajson_error.

    METHODS convert_value
      IMPORTING
        iv_data TYPE any
        io_type TYPE REF TO cl_abap_typedescr
        is_prefix TYPE zif_abapgit_ajson=>ty_path_name
        iv_index TYPE i DEFAULT 0
        iv_item_order TYPE i DEFAULT 0
      CHANGING
        ct_nodes TYPE zif_abapgit_ajson=>ty_nodes_tt
      RAISING
        zcx_abapgit_ajson_error.

    METHODS convert_ref
      IMPORTING
        iv_data TYPE any
        is_prefix TYPE zif_abapgit_ajson=>ty_path_name
        iv_index TYPE i DEFAULT 0
        iv_item_order TYPE i DEFAULT 0
      CHANGING
        ct_nodes TYPE zif_abapgit_ajson=>ty_nodes_tt
      RAISING
        zcx_abapgit_ajson_error.

    METHODS convert_struc
      IMPORTING
        iv_data TYPE any
        io_type TYPE REF TO cl_abap_typedescr
        is_prefix TYPE zif_abapgit_ajson=>ty_path_name
        iv_index TYPE i DEFAULT 0
        iv_item_order TYPE i DEFAULT 0
      CHANGING
        ct_nodes TYPE zif_abapgit_ajson=>ty_nodes_tt
        cs_root  TYPE zif_abapgit_ajson=>ty_node OPTIONAL
      RAISING
        zcx_abapgit_ajson_error.

    METHODS convert_table
      IMPORTING
        iv_data TYPE any
        io_type TYPE REF TO cl_abap_typedescr
        is_prefix TYPE zif_abapgit_ajson=>ty_path_name
        iv_index TYPE i DEFAULT 0
        iv_item_order TYPE i DEFAULT 0
      CHANGING
        ct_nodes TYPE zif_abapgit_ajson=>ty_nodes_tt
      RAISING
        zcx_abapgit_ajson_error.

    METHODS insert_value_with_type
      IMPORTING
        iv_data TYPE any
        iv_type TYPE string
        io_type TYPE REF TO cl_abap_typedescr
        is_prefix TYPE zif_abapgit_ajson=>ty_path_name
        iv_index TYPE i DEFAULT 0
        iv_item_order TYPE i DEFAULT 0
      CHANGING
        ct_nodes TYPE zif_abapgit_ajson=>ty_nodes_tt
      RAISING
        zcx_abapgit_ajson_error.

ENDCLASS.

CLASS lcl_abap_to_json IMPLEMENTATION.

  METHOD class_constructor.

    DATA lo_dummy TYPE REF TO zcl_abapgit_ajson.
    DATA lo_type TYPE REF TO cl_abap_refdescr.
    lo_type ?= cl_abap_typedescr=>describe_by_data( lo_dummy ).
    gv_ajson_absolute_type_name = lo_type->get_referenced_type( )->absolute_name.

  ENDMETHOD.

  METHOD convert.

    DATA lo_type TYPE REF TO cl_abap_typedescr.
    DATA lo_converter TYPE REF TO lcl_abap_to_json.

    lo_type = cl_abap_typedescr=>describe_by_data( iv_data ).

    CREATE OBJECT lo_converter.
    lo_converter->mi_custom_mapping  = ii_custom_mapping.
    lo_converter->mv_keep_item_order = iv_keep_item_order.
    lo_converter->mv_format_datetime = iv_format_datetime.

    lo_converter->convert_any(
      EXPORTING
        iv_data   = iv_data
        io_type   = lo_type
        is_prefix = is_prefix
        iv_index  = iv_array_index
      CHANGING
        ct_nodes = rt_nodes ).

  ENDMETHOD.

  METHOD convert_any.

    CASE io_type->kind.
      WHEN cl_abap_typedescr=>kind_elem.
        convert_value(
          EXPORTING
            iv_data   = iv_data
            io_type   = io_type
            is_prefix = is_prefix
            iv_index  = iv_index
            iv_item_order = iv_item_order
          CHANGING
            ct_nodes = ct_nodes ).

      WHEN cl_abap_typedescr=>kind_struct.
        convert_struc(
          EXPORTING
            iv_data   = iv_data
            io_type   = io_type
            is_prefix = is_prefix
            iv_index  = iv_index
            iv_item_order = iv_item_order
          CHANGING
            ct_nodes = ct_nodes ).

      WHEN cl_abap_typedescr=>kind_table.
        convert_table(
          EXPORTING
            iv_data   = iv_data
            io_type   = io_type
            is_prefix = is_prefix
            iv_index  = iv_index
            iv_item_order = iv_item_order
          CHANGING
            ct_nodes = ct_nodes ).

      WHEN OTHERS.

        IF io_type->type_kind = cl_abap_typedescr=>typekind_dref OR iv_data IS INITIAL.
          "" Convert data references and initial references to other types (like ref to class or interface)
          "" Initial references will result in ""null""
          convert_ref(
            EXPORTING
              iv_data   = iv_data
              is_prefix = is_prefix
              iv_index  = iv_index
              iv_item_order = iv_item_order
            CHANGING
              ct_nodes = ct_nodes ).

        ELSEIF io_type->type_kind = cl_abap_typedescr=>typekind_oref
          AND cl_abap_typedescr=>describe_by_object_ref( iv_data )->absolute_name = gv_ajson_absolute_type_name.
          convert_ajson(
            EXPORTING
              io_json   = iv_data
              is_prefix = is_prefix
              iv_index  = iv_index
            CHANGING
              ct_nodes = ct_nodes ).
        ELSE.
          zcx_abapgit_ajson_error=>raise( |Unsupported type [{ io_type->type_kind
            }] @{ is_prefix-path && is_prefix-name }| ).
        ENDIF.

    ENDCASE.

  ENDMETHOD.

  METHOD convert_ajson.

    FIELD-SYMBOLS <src> LIKE LINE OF ct_nodes.
    FIELD-SYMBOLS <dst> LIKE LINE OF ct_nodes.

    IF io_json IS NOT BOUND.
      RETURN.
    ENDIF.

    LOOP AT io_json->mt_json_tree ASSIGNING <src>.
      APPEND <src> TO ct_nodes ASSIGNING <dst>.

      IF <dst>-path IS INITIAL AND <dst>-name IS INITIAL. "" root node
        <dst>-path  = is_prefix-path.
        <dst>-name  = is_prefix-name.
        <dst>-index = iv_index.
      ELSE.
        <dst>-path = is_prefix-path && is_prefix-name && <dst>-path.
      ENDIF.
    ENDLOOP.

  ENDMETHOD.

  METHOD format_date.
    IF iv_date IS NOT INITIAL.
      rv_str = iv_date+0(4) && '-' && iv_date+4(2) && '-' && iv_date+6(2).
    ENDIF.
  ENDMETHOD.

  METHOD format_time.
    IF iv_time IS NOT INITIAL.
      rv_str = iv_time+0(2) && ':' && iv_time+2(2) && ':' && iv_time+4(2).
    ENDIF.
  ENDMETHOD.

  METHOD format_timestamp.

    CONSTANTS lc_utc TYPE c LENGTH 6 VALUE 'UTC'.

    DATA lv_date TYPE d.
    DATA lv_time TYPE t.

    IF iv_ts IS INITIAL.
      "" The zero value is January 1, year 1, 00:00:00.000000000 UTC.
      lv_date = '00010101'.
    ELSE.

      CONVERT TIME STAMP iv_ts TIME ZONE lc_utc
        INTO DATE lv_date TIME lv_time.

    ENDIF.

    rv_str =
      lv_date+0(4) && '-' && lv_date+4(2) && '-' && lv_date+6(2) &&
      'T' &&
      lv_time+0(2) && '-' && lv_time+2(2) && '-' && lv_time+4(2) &&
      'Z'.

  ENDMETHOD.

  METHOD convert_value.

    DATA ls_node LIKE LINE OF ct_nodes.

    ls_node-path  = is_prefix-path.
    ls_node-name  = is_prefix-name.
    ls_node-index = iv_index.
    ls_node-order = iv_item_order.

    IF mi_custom_mapping IS BOUND.
      ls_node-name = mi_custom_mapping->to_json(
        iv_path = is_prefix-path
        iv_name = is_prefix-name ).
    ENDIF.

    IF ls_node-name IS INITIAL.
      ls_node-name  = is_prefix-name.
    ENDIF.

    IF io_type->absolute_name = '\\TYPE-POOL=ABAP\\TYPE=ABAP_BOOL'
        OR io_type->absolute_name = '\\TYPE=ABAP_BOOLEAN'
        OR io_type->absolute_name = '\\TYPE=XSDBOOLEAN'
        OR io_type->absolute_name = '\\TYPE=FLAG'
        OR io_type->absolute_name = '\\TYPE=XFELD'.
      ls_node-type = zif_abapgit_ajson=>node_type-boolean.
      IF iv_data IS NOT INITIAL.
        ls_node-value = 'true'.
      ELSE.
        ls_node-value = 'false'.
      ENDIF.
    ELSEIF io_type->absolute_name = '\\TYPE=TIMESTAMP'.
      IF mv_format_datetime = abap_true.
        ls_node-type  = zif_abapgit_ajson=>node_type-string.
        ls_node-value = format_timestamp( iv_data ).
      ELSE.
        ls_node-type  = zif_abapgit_ajson=>node_type-number.
        ls_node-value = |{ iv_data }|.
      ENDIF.
    ELSEIF io_type->type_kind CO 'CNgXy'. "" Char like, xstring
      ls_node-type = zif_abapgit_ajson=>node_type-string.
      ls_node-value = |{ iv_data }|.
    ELSEIF io_type->type_kind = 'D'. "" Date
      ls_node-type = zif_abapgit_ajson=>node_type-string.
      IF mv_format_datetime = abap_true.
        ls_node-value = format_date( iv_data ).
      ELSE.
        ls_node-value = |{ iv_data }|.
      ENDIF.
    ELSEIF io_type->type_kind = 'T'. "" Time
      ls_node-type = zif_abapgit_ajson=>node_type-string.
      IF mv_format_datetime = abap_true.
        ls_node-value = format_time( iv_data ).
      ELSE.
        ls_node-value = |{ iv_data }|.
      ENDIF.
    ELSEIF io_type->type_kind CO 'bsI8aeFP'. "" Numeric
      ls_node-type = zif_abapgit_ajson=>node_type-number.
      ls_node-value = |{ iv_data }|.
    ELSE.
      zcx_abapgit_ajson_error=>raise( |Unexpected elementary type [{
        io_type->type_kind }] @{ is_prefix-path && is_prefix-name }| ).
    ENDIF.

    APPEND ls_node TO ct_nodes.

  ENDMETHOD.

  METHOD convert_ref.

    DATA ls_node LIKE LINE OF ct_nodes.

    ls_node-path  = is_prefix-path.
    ls_node-name  = is_prefix-name.
    ls_node-index = iv_index.
    ls_node-order = iv_item_order.

    IF mi_custom_mapping IS BOUND.
      ls_node-name = mi_custom_mapping->to_json(
        iv_path = is_prefix-path
        iv_name = is_prefix-name ).
    ENDIF.

    IF ls_node-name IS INITIAL.
      ls_node-name  = is_prefix-name.
    ENDIF.

    IF iv_data IS INITIAL.
      ls_node-type  = zif_abapgit_ajson=>node_type-null.
      ls_node-value = 'null'.
    ELSE.
      "" TODO support data references
      zcx_abapgit_ajson_error=>raise( |Unexpected reference @{ is_prefix-path && is_prefix-name }| ).
    ENDIF.

    APPEND ls_node TO ct_nodes.

  ENDMETHOD.

  METHOD convert_struc.

    DATA lo_struc TYPE REF TO cl_abap_structdescr.
    DATA lt_comps TYPE cl_abap_structdescr=>component_table.
    DATA ls_next_prefix LIKE is_prefix.
    DATA lv_item_order TYPE i.
    DATA ls_root LIKE LINE OF ct_nodes.

    FIELD-SYMBOLS <root> LIKE ls_root.
    FIELD-SYMBOLS <c> LIKE LINE OF lt_comps.
    FIELD-SYMBOLS <val> TYPE any.

    "" Object root

    IF cs_root IS SUPPLIED. "" call for include structure
      ASSIGN cs_root TO <root>.
    ELSE. "" First call
      ls_root-path  = is_prefix-path.
      ls_root-name  = is_prefix-name.
      ls_root-type  = zif_abapgit_ajson=>node_type-object.
      ls_root-index = iv_index.

      IF mi_custom_mapping IS BOUND.
        ls_root-name = mi_custom_mapping->to_json(
          iv_path = is_prefix-path
          iv_name = is_prefix-name ).
      ENDIF.

      IF ls_root-name IS INITIAL.
        ls_root-name  = is_prefix-name.
      ENDIF.

      ls_root-order = iv_item_order.

      APPEND ls_root TO ct_nodes ASSIGNING <root>.

    ENDIF.

    "" Object attributes

    lo_struc ?= io_type.
    lt_comps = lo_struc->get_components( ).
    "" get_components is potentially much slower than lo_struc->components
    "" but ! we still need it to identify booleans
    "" and rtti seems to cache type descriptions really well (https://github.com/sbcgua/benchmarks.git)
    "" the structures will be repeated in real life

    ls_next_prefix-path = is_prefix-path && <root>-name && '/'.

    LOOP AT lt_comps ASSIGNING <c>.

      IF <c>-as_include = abap_true.

        convert_struc(
          EXPORTING
            iv_data   = iv_data
            io_type   = <c>-type
            is_prefix = is_prefix
          CHANGING
            cs_root  = <root>
            ct_nodes = ct_nodes ).

      ELSE.

        <root>-children = <root>-children + 1.
        ls_next_prefix-name = to_lower( <c>-name ).
        ASSIGN COMPONENT <c>-name OF STRUCTURE iv_data TO <val>.
        ASSERT sy-subrc = 0.

        IF mv_keep_item_order = abap_true.
          lv_item_order = <root>-children.
        ENDIF.

        convert_any(
          EXPORTING
            iv_data   = <val>
            io_type   = <c>-type
            is_prefix = ls_next_prefix
            iv_item_order = lv_item_order
          CHANGING
            ct_nodes = ct_nodes ).

      ENDIF.

    ENDLOOP.

  ENDMETHOD.

  METHOD convert_table.

    DATA lo_table TYPE REF TO cl_abap_tabledescr.
    DATA lo_ltype TYPE REF TO cl_abap_typedescr.
    DATA ls_next_prefix LIKE is_prefix.
    DATA lv_tabix TYPE sy-tabix.
    DATA ls_root LIKE LINE OF ct_nodes.

    FIELD-SYMBOLS <root> LIKE ls_root.
    FIELD-SYMBOLS <tab> TYPE ANY TABLE.
    FIELD-SYMBOLS <val> TYPE any.

    "" Array root

    ls_root-path  = is_prefix-path.
    ls_root-name  = is_prefix-name.
    ls_root-type  = zif_abapgit_ajson=>node_type-array.
    ls_root-index = iv_index.
    ls_root-order = iv_item_order.

    IF mi_custom_mapping IS BOUND.
      ls_root-name = mi_custom_mapping->to_json(
        iv_path = is_prefix-path
        iv_name = is_prefix-name ).
    ENDIF.

    IF ls_root-name IS INITIAL.
      ls_root-name  = is_prefix-name.
    ENDIF.

    APPEND ls_root TO ct_nodes ASSIGNING <root>.

    "" Array items

    lo_table ?= io_type.
    lo_ltype  = lo_table->get_table_line_type( ).

    ls_next_prefix-path = is_prefix-path && <root>-name && '/'.
    ASSIGN iv_data TO <tab>.

    lv_tabix = 1.
    LOOP AT <tab> ASSIGNING <val>.
      ls_next_prefix-name = to_lower( |{ lv_tabix }| ).

      convert_any(
        EXPORTING
          iv_data   = <val>
          io_type   = lo_ltype
          is_prefix = ls_next_prefix
          iv_index  = <root>-children + 1
        CHANGING
          ct_nodes = ct_nodes ).

      <root>-children = <root>-children + 1.
      lv_tabix = lv_tabix + 1.
    ENDLOOP.

  ENDMETHOD.

  METHOD insert_with_type.

    DATA lo_type TYPE REF TO cl_abap_typedescr.
    DATA lo_converter TYPE REF TO lcl_abap_to_json.

    lo_type = cl_abap_typedescr=>describe_by_data( iv_data ).

    CREATE OBJECT lo_converter.
    lo_converter->mi_custom_mapping  = ii_custom_mapping.
    lo_converter->mv_keep_item_order = iv_keep_item_order.
    lo_converter->mv_format_datetime = iv_format_datetime.

    lo_converter->insert_value_with_type(
      EXPORTING
        iv_data   = iv_data
        iv_type   = iv_type
        io_type   = lo_type
        is_prefix = is_prefix
        iv_index  = iv_array_index
      CHANGING
        ct_nodes = rt_nodes ).

  ENDMETHOD.

  METHOD insert_value_with_type.

    DATA lv_prefix TYPE string.
    DATA ls_node LIKE LINE OF ct_nodes.

    lv_prefix = is_prefix-path && is_prefix-name.
    IF io_type->type_kind CO 'CNgXyDT'. "" Char like, date/time, xstring
      IF iv_type = zif_abapgit_ajson=>node_type-boolean AND iv_data <> 'true' AND iv_data <> 'false'.
        zcx_abapgit_ajson_error=>raise( |Unexpected boolean value [{ iv_data }] @{ lv_prefix }| ).
      ELSEIF iv_type = zif_abapgit_ajson=>node_type-null AND iv_data IS NOT INITIAL.
        zcx_abapgit_ajson_error=>raise( |Unexpected null value [{ iv_data }] @{ lv_prefix }| ).
      ELSEIF iv_type = zif_abapgit_ajson=>node_type-number AND iv_data CN '0123456789. E+-'.
        zcx_abapgit_ajson_error=>raise( |Unexpected numeric value [{ iv_data }] @{ lv_prefix }| ).
      ELSEIF iv_type <> zif_abapgit_ajson=>node_type-string AND iv_type <> zif_abapgit_ajson=>node_type-boolean
        AND iv_type <> zif_abapgit_ajson=>node_type-null AND iv_type <> zif_abapgit_ajson=>node_type-number.
        zcx_abapgit_ajson_error=>raise( |Unexpected type for value [{ iv_type },{ iv_data }] @{ lv_prefix }| ).
      ENDIF.
    ELSEIF io_type->type_kind CO 'bsI8PaeF'. "" Numeric
      IF iv_type <> zif_abapgit_ajson=>node_type-number.
        zcx_abapgit_ajson_error=>raise( |Unexpected value for numeric [{ iv_data }] @{ lv_prefix }| ).
      ENDIF.
    ELSE.
      zcx_abapgit_ajson_error=>raise( |Unexpected type [{ io_type->type_kind }] @{ lv_prefix }| ).
    ENDIF.

    ls_node-path  = is_prefix-path.
    ls_node-name  = is_prefix-name.
    ls_node-index = iv_index.
    ls_node-value = iv_data.
    ls_node-type  = iv_type.
    ls_node-order = iv_item_order.

    IF mi_custom_mapping IS BOUND.
      ls_node-name = mi_custom_mapping->to_json(
        iv_path = is_prefix-path
        iv_name = is_prefix-name ).
    ENDIF.

    IF ls_node-name IS INITIAL.
      ls_node-name  = is_prefix-name.
    ENDIF.

    APPEND ls_node TO ct_nodes.

  ENDMETHOD.

ENDCLASS.

**********************************************************************
* FILTER RUNNER
**********************************************************************

CLASS lcl_filter_runner DEFINITION FINAL.
  PUBLIC SECTION.
    METHODS run
      IMPORTING
        ii_filter TYPE REF TO zif_abapgit_ajson_filter
        it_source_tree TYPE zif_abapgit_ajson=>ty_nodes_ts
      CHANGING
        ct_dest_tree TYPE zif_abapgit_ajson=>ty_nodes_ts
      RAISING
        zcx_abapgit_ajson_error.

  PRIVATE SECTION.
    DATA mi_filter TYPE REF TO zif_abapgit_ajson_filter.
    DATA mr_source_tree TYPE REF TO zif_abapgit_ajson=>ty_nodes_ts.
    DATA mr_dest_tree TYPE REF TO zif_abapgit_ajson=>ty_nodes_ts.

    METHODS walk
      IMPORTING
        iv_path TYPE string
      CHANGING
        cs_parent TYPE zif_abapgit_ajson=>ty_node OPTIONAL
      RAISING
        zcx_abapgit_ajson_error.

ENDCLASS.

CLASS lcl_filter_runner IMPLEMENTATION.

  METHOD run.

    ASSERT ii_filter IS BOUND.
    mi_filter = ii_filter.
    CLEAR ct_dest_tree.

    GET REFERENCE OF it_source_tree INTO mr_source_tree.
    GET REFERENCE OF ct_dest_tree INTO mr_dest_tree.

    walk( iv_path = '' ).

  ENDMETHOD.

  METHOD walk.

    DATA ls_node TYPE zif_abapgit_ajson=>ty_node.

    LOOP AT mr_source_tree->* INTO ls_node WHERE path = iv_path.
      CASE ls_node-type.
        WHEN zif_abapgit_ajson=>node_type-boolean OR zif_abapgit_ajson=>node_type-null
          OR zif_abapgit_ajson=>node_type-number OR zif_abapgit_ajson=>node_type-string.

          IF mi_filter->keep_node( ls_node ) = abap_false.
            CONTINUE.
          ENDIF.

        WHEN zif_abapgit_ajson=>node_type-array OR zif_abapgit_ajson=>node_type-object.

          IF mi_filter->keep_node(
              is_node  = ls_node
              iv_visit = zif_abapgit_ajson_filter=>visit_type-open ) = abap_false.
            CONTINUE.
          ENDIF.

          "" Intentionally clear AFTER ""open""
          CLEAR ls_node-children.

          walk(
            EXPORTING
              iv_path = iv_path && ls_node-name && `/`
            CHANGING
              cs_parent    = ls_node ).

          IF mi_filter->keep_node(
              is_node  = ls_node
              iv_visit = zif_abapgit_ajson_filter=>visit_type-close ) = abap_false.
            CONTINUE.
          ENDIF.

        WHEN OTHERS.
          zcx_abapgit_ajson_error=>raise( |Unexpected node type { ls_node-type }| ).
      ENDCASE.

      IF cs_parent IS SUPPLIED.
        cs_parent-children = cs_parent-children + 1.
        IF cs_parent-type = zif_abapgit_ajson=>node_type-array.
          ls_node-name  = |{ cs_parent-children }|.
          ls_node-index = cs_parent-children.
        ENDIF.
      ENDIF.
      INSERT ls_node INTO TABLE mr_dest_tree->*.

    ENDLOOP.

  ENDMETHOD.

ENDCLASS.
",13202,True,2825.2547611896953,median
"// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License.
#include <thread>

#include ""gtest/gtest.h""
#include ""orttraining/core/optimizer/gist_encode_decode.h""
#include ""test/providers/provider_test_utils.h""
#include ""core/providers/cpu/cpu_execution_provider.h""
#include ""core/session/environment.h""
#include ""orttraining/models/runner/training_runner.h""

#include ""orttraining/training_ops/cpu/controlflow/event_pool.h""  // TODO: move with PipelineBatchPlanner

#ifdef USE_CUDA
#include ""bert_toy_fetches.h""
#include ""core/providers/cuda/cuda_execution_provider.h""
#endif

using namespace onnxruntime::logging;
using namespace onnxruntime::training;
using namespace google::protobuf::util;

namespace onnxruntime {
namespace test {

namespace {
constexpr auto ORIGINAL_MODEL_PATH = ORT_TSTR(""testdata/test_training_model.onnx"");
constexpr auto BACKWARD_MODEL_PATH = ORT_TSTR(""testdata/temp_backward_model.onnx"");

std::unordered_set<std::string> GetModelOutputNames(const InferenceSession& session) {
  const auto outputs_result = session.GetModelOutputs();
  ORT_ENFORCE(outputs_result.first.IsOK(), ""Failed to get model outputs: "", outputs_result.first.ErrorMessage());
  std::unordered_set<std::string> output_names{};
  for (const auto* output : *outputs_result.second) {
    output_names.insert(output->Name());
  }
  return output_names;
}
}  // namespace

static TrainingSession::TrainingConfiguration MakeBasicTrainingConfig() {
  TrainingSession::TrainingConfiguration config{};
  config.model_with_training_graph_path = BACKWARD_MODEL_PATH;
  config.loss_function_config = TrainingSession::TrainingConfiguration::LossFunctionConfiguration{};
  config.loss_function_config.value().loss_function_info =
      LossFunctionInfo(OpDef(""MeanSquaredError""), ""loss"", {""predictions"", ""labels""});

  return config;
}

static Status BuildBackPropGraph(
    const PathString& forward_model_file,
    const TrainingSession::TrainingConfiguration& config,
    PathString& backward_model_file) {
  std::unique_ptr<Environment> env;
  ORT_RETURN_IF_ERROR(Environment::Create(nullptr, env));

  SessionOptions so{};
  TrainingSession training_session{so, *env};

  std::cout << ""Loading source model file = "" << ToMBString(forward_model_file) << ""\\n"";

  ORT_RETURN_IF_ERROR(training_session.Load(forward_model_file));

  TrainingSession::TrainingConfigurationResult config_result{};
  ORT_RETURN_IF_ERROR(training_session.ConfigureForTraining(config, config_result));

  backward_model_file = config.model_with_training_graph_path.value();

  return Status::OK();
}

/**
 * Run a training session for this model for 1 epoch, using batch size of 1 and synthetic input data.
 * @param so - SessionOptions for this run.
 * @param backprop_model_file - Mocel file to be run. This should already contain loss function and backward prop nodes.
 * @return TrainingSession for this run.
 */
static std::unique_ptr<TrainingSession> RunTrainingSessionWithChecks(
    const SessionOptions& so, const PathString& backprop_model_file) {
  std::unique_ptr<Environment> env;
  EXPECT_TRUE(Environment::Create(nullptr, env).IsOK());

  std::unique_ptr<TrainingSession> training_session = onnxruntime::make_unique<TrainingSession>(so, *env);

  EXPECT_TRUE(training_session->Load(backprop_model_file).IsOK());

  std::pair<common::Status, const ModelMetadata*> res = training_session->GetModelMetadata();
  EXPECT_TRUE(res.first.IsOK());
  EXPECT_TRUE(res.second != nullptr);
  auto model_metadata = res.second;
  std::cout << ""Loaded "" << model_metadata->graph_name << '\\n';

  EXPECT_TRUE(training_session->Initialize().IsOK());

  std::vector<MLValue> gradient_fetches;
  RunOptions run_options;
  run_options.run_log_verbosity_level = so.session_log_verbosity_level;
  run_options.run_tag = so.session_logid;

  // Create dummy feeds
  std::vector<int64_t> image_dims = {1, 784};
  std::vector<int64_t> label_dims = {1, 10};
  std::vector<float> image_value(784, 1);
  std::vector<float> label_value(10, 1);

  MLValue imageMLValue;
  TrainingUtil::CreateCpuMLValue(image_dims, image_value, &imageMLValue);
  MLValue labelMLValue;
  TrainingUtil::CreateCpuMLValue(label_dims, label_value, &labelMLValue);

  auto fw_feeds = std::make_pair<std::vector<std::string>, std::vector<MLValue>>({""X"", ""labels""}, {imageMLValue, labelMLValue});

  auto output_names_include_gradients = GetModelOutputNames(*training_session);
  std::vector<std::string> training_output_names(output_names_include_gradients.begin(), output_names_include_gradients.end());

  auto start_time = std::chrono::high_resolution_clock::now();

  EXPECT_TRUE(training_session->Run(run_options, fw_feeds.first, fw_feeds.second, training_output_names, &gradient_fetches).IsOK());

  auto end_time = std::chrono::high_resolution_clock::now();
  auto elapsed = TimeDiffMicroSeconds(start_time, end_time);
  std::cout << ""Training session run completed in "" << elapsed << "" microseconds.\\n"";

  return training_session;
}

TEST(GradientGraphBuilderTest, BuildGradientGraphTest) {
  const auto config = MakeBasicTrainingConfig();
  PathString backprop_model_file;
  ASSERT_STATUS_OK(BuildBackPropGraph(ORIGINAL_MODEL_PATH, config, backprop_model_file));

  std::shared_ptr<Model> pModel;
  ASSERT_STATUS_OK(Model::Load(backprop_model_file, pModel, nullptr, DefaultLoggingManager().DefaultLogger()));

  Graph& graph = pModel->MainGraph();
  EXPECT_FALSE(graph.GraphResolveNeeded());
  EXPECT_TRUE(graph.NumberOfNodes() > 0);
  EXPECT_TRUE(graph.MaxNodeIndex() > 0);

  std::cout << ""Graph input names = [\\n"";
  for (const NodeArg* p_node_arg : graph.GetInputs()) {
    std::cout << '\\t' << p_node_arg->Name() << '\\n';
  }
  std::cout << ""]\\n"";

  std::cout << ""Graph output names = [\\n"";
  for (const NodeArg* p_node_arg : graph.GetOutputs()) {
    std::cout << '\\t' << p_node_arg->Name() << '\\n';
  }
  std::cout << ""]\\n"";

  for (Node& node : graph.Nodes()) {
    const NodeIndex node_index = node.Index();
    const std::string& node_name = node.Name();
    const std::string& op_type = node.OpType();

    std::cout << ""Operation node:""
              << "" Index="" << node_index
              << (node.NodeType() == Node::Type::Fused ? ""-(FUSED)"" : """")
              << "" OpType="" << op_type
              << "" Name="" << node_name
              << '\\n';
  }
}

TEST(GradientGraphBuilderTest, TrainingSession_Basic) {
  const auto config = MakeBasicTrainingConfig();
  PathString backprop_model_file;
  ASSERT_STATUS_OK(BuildBackPropGraph(ORIGINAL_MODEL_PATH, config, backprop_model_file));

  SessionOptions so{};
  RunTrainingSessionWithChecks(so, backprop_model_file);
}

TEST(GradientGraphBuilderTest, TrainingSession_WithGist) {
  auto config = MakeBasicTrainingConfig();
  config.gist_config = TrainingSession::TrainingConfiguration::GistConfiguration{};
  PathString backprop_model_file;
  ASSERT_STATUS_OK(BuildBackPropGraph(ORIGINAL_MODEL_PATH, config, backprop_model_file));

  std::cout << ""Loading model file = "" << ToMBString(backprop_model_file) << ""\\n"";
  std::shared_ptr<Model> p_model;
  ASSERT_STATUS_OK(onnxruntime::Model::Load(backprop_model_file, p_model, nullptr, DefaultLoggingManager().DefaultLogger()));

  const Graph& graph = p_model->MainGraph();
  bool found_encoder = false;
  bool found_decoder = false;
  for (auto& node : graph.Nodes()) {
    const std::string& node_name = node.Name();
    std::cout << ""Node name='"" << node_name << ""' op_type="" << node.OpType() << ""\\n"";
    if (node_name.find(onnxruntime::GistEncodeDecode::GIST_ENCODER_NODE_NAME_BASE) != std::string::npos) {
      found_encoder = true;
      std::cout << ""Found encoder node "" << node_name << ""\\n"";
    } else if (node_name.find(onnxruntime::GistEncodeDecode::GIST_DECODER_NODE_NAME_BASE) != std::string::npos) {
      found_decoder = true;
      std::cout << ""Found decoder node "" << node_name << ""\\n"";
    }
  }
  ASSERT_TRUE(found_encoder);
  ASSERT_TRUE(found_decoder);

  SessionOptions so{};
  RunTrainingSessionWithChecks(so, backprop_model_file);
}

TEST(GradientGraphBuilderTest, TrainingSession_WithLogging) {
  const auto& log_manager = DefaultLoggingManager();
  const auto& default_logger = log_manager.DefaultLogger();
  log_manager.SetDefaultLoggerSeverity(Severity::kINFO);

  EXPECT_TRUE(default_logger.OutputIsEnabled(Severity::kERROR, ::onnxruntime::logging::DataType::USER)) << ""ERROR level logging enabled."";
  EXPECT_TRUE(default_logger.OutputIsEnabled(Severity::kWARNING, ::onnxruntime::logging::DataType::USER)) << ""WARNING level logging enabled."";
  EXPECT_TRUE(default_logger.OutputIsEnabled(Severity::kINFO, ::onnxruntime::logging::DataType::USER)) << ""INFO level logging enabled."";

  const auto config = MakeBasicTrainingConfig();
  PathString backprop_model_file;
  ASSERT_STATUS_OK(BuildBackPropGraph(ORIGINAL_MODEL_PATH, config, backprop_model_file));

  SessionOptions so;
  so.session_logid = ""training_session_with_logging"";
  so.session_log_verbosity_level = 1;  // 1 == detailed logging

  std::unique_ptr<TrainingSession> training_session = RunTrainingSessionWithChecks(so, backprop_model_file);

  EXPECT_TRUE(default_logger.OutputIsEnabled(Severity::kERROR, ::onnxruntime::logging::DataType::USER)) << ""ERROR level logging still enabled."";
  EXPECT_TRUE(default_logger.OutputIsEnabled(Severity::kWARNING, ::onnxruntime::logging::DataType::USER)) << ""WARNING level logging still enabled."";
  EXPECT_TRUE(default_logger.OutputIsEnabled(Severity::kINFO, ::onnxruntime::logging::DataType::USER)) << ""INFO level logging still enabled."";

  std::string profile_file = training_session->EndProfiling();

  log_manager.SetDefaultLoggerSeverity(Severity::kWARNING);

  EXPECT_EQ(profile_file, std::string()) << ""There should be no profile output file."";
}

TEST(GradientGraphBuilderTest, TrainingSession_WithProfiler) {
  const auto config = MakeBasicTrainingConfig();
  PathString backprop_model_file;
  ASSERT_STATUS_OK(BuildBackPropGraph(ORIGINAL_MODEL_PATH, config, backprop_model_file));

  SessionOptions so;
  so.enable_profiling = true;
  so.profile_file_prefix = ORT_TSTR(""onnx_training_profiler_test"");

  std::unique_ptr<TrainingSession> training_session = RunTrainingSessionWithChecks(so, backprop_model_file);

  std::string profile_file = training_session->EndProfiling();

  std::cout << ""Profile output file = "" << profile_file << '\\n';

  std::ifstream profile(profile_file);
  ASSERT_TRUE(profile);

  std::vector<std::string> core_trace_fields = {""pid"", ""dur"", ""ts"", ""ph"", ""X"", ""name"", ""args""};
  std::vector<std::string> fiddle_profile_data_fields = {""dur"", ""activation_size"", ""parameter_size"", ""output_size""};

  int count = 0;
  std::string line;
  while (std::getline(profile, line)) {
    if (count == 0) {
      ASSERT_TRUE(line.find('[') != std::string::npos)
          << ""Missing opening array marker in first trace record: "" << line;
      // Opening array marker found.
    } else if (line.find(']') != std::string::npos) {
      // Closing array marker found.
      break;
    } else if (count >= 1) {
      if (count == 1) {
        auto s = ""model_loading_uri"";
        ASSERT_TRUE(line.find(s) != std::string::npos)
            << ""Missing field '"" << s << ""' in trace record: "" << line;
      }

      // Check we have the core fields in each trace record.
      for (auto& s : core_trace_fields) {
        ASSERT_TRUE(line.find(s) != std::string::npos)
            << ""Missing core trace field '"" << s << ""' in trace record: "" << line;
      }

      // Check we have the data profile fields output for each kernel operation.
      if (line.find(""_kernel_time"") != std::string::npos) {
        for (auto& s : fiddle_profile_data_fields) {
          ASSERT_TRUE(line.find(s) != std::string::npos)
              << ""Missing data profile field '"" << s << ""' in trace record: "" << line;
        }
      }
    }

    count++;
  }
  ASSERT_TRUE(count > 1);
}

#ifdef USE_CUDA
static void RunBertTrainingWithChecks(
    const SessionOptions& so,
    const PathString& backprop_model_file) {
  std::unique_ptr<Environment> env;
  EXPECT_TRUE(Environment::Create(nullptr, env).IsOK());

  std::unique_ptr<TrainingSession> training_session = onnxruntime::make_unique<TrainingSession>(so, *env);

  EXPECT_TRUE(training_session->Load(backprop_model_file).IsOK());

  std::pair<common::Status, const ModelMetadata*> res = training_session->GetModelMetadata();
  EXPECT_TRUE(res.first.IsOK());
  ASSERT_TRUE(res.second != nullptr);
  auto model_metadata = res.second;
  std::cout << ""Loaded "" << model_metadata->graph_name << '\\n';

  CUDAExecutionProviderInfo xp_info;
  ASSERT_STATUS_OK(training_session->RegisterExecutionProvider(onnxruntime::make_unique<CUDAExecutionProvider>(xp_info)));

  ASSERT_STATUS_OK(training_session->Initialize());

  RunOptions run_options;
  run_options.run_log_verbosity_level = so.session_log_verbosity_level;
  run_options.run_tag = so.session_logid;

  // Creating feeds
  int batch_size = 13;
  int max_seq_len_in_batch = 7;
  std::vector<std::string> feed_names = {
      ""input_ids"",
      ""token_type_ids"",
      ""input_mask"",
      ""masked_lm_ids"",
      ""next_sentence_labels"",
      ""masked_lm_positions"",
      ""masked_lm_weights"",
  };
  std::vector<TensorShape> tensor_shapes = {
      {batch_size, max_seq_len_in_batch},
      {batch_size, max_seq_len_in_batch},
      {batch_size, max_seq_len_in_batch},
      {batch_size, max_seq_len_in_batch},
      {batch_size},
      {batch_size, max_seq_len_in_batch},
      {batch_size, max_seq_len_in_batch}};

  std::vector<std::vector<int64_t>> tensor_values = {
      /*input_ids*/
      {49, 97, 53, 5, 33, 65, 62,
       51, 38, 61, 45, 74, 27, 64,
       17, 36, 17, 96, 12, 79, 32,
       68, 90, 77, 18, 39, 12, 93,
       9, 87, 42, 60, 71, 12, 45,
       55, 40, 78, 81, 26, 70, 61,
       56, 66, 33, 7, 70, 1, 11,
       92, 51, 90, 85, 80, 0, 78,
       63, 42, 31, 93, 41, 90, 8,
       24, 72, 28, 30, 18, 69, 57,
       11, 10, 40, 65, 62, 13, 38,
       70, 37, 90, 15, 70, 42, 69,
       26, 77, 70, 75, 36, 56, 11},
      /*token_type_ids*/
      {12, 13, 1, 8, 15, 12, 9,
       15, 11, 6, 4, 9, 4, 3,
       8, 4, 9, 3, 2, 10, 15,
       3, 11, 13, 10, 6, 15, 14,
       8, 1, 0, 2, 12, 0, 15,
       10, 7, 10, 2, 6, 7, 7,
       4, 14, 2, 2, 10, 15, 3,
       9, 9, 3, 10, 6, 9, 14,
       2, 12, 10, 7, 9, 5, 6,
       5, 1, 8, 15, 2, 2, 4,
       4, 1, 2, 12, 8, 7, 6,
       13, 8, 14, 15, 11, 2, 10,
       3, 15, 10, 6, 7, 0, 8},
      /*input_mask*/
      {1, 1, 0, 1, 1, 1, 1,
       1, 1, 0, 0, 1, 0, 0,
       1, 0, 1, 0, 0, 1, 1,
       0, 1, 1, 1, 0, 1, 1,
       1, 0, 0, 0, 1, 0, 1,
       1, 0, 1, 0, 0, 0, 0,
       0, 1, 0, 0, 1, 1, 0,
       1, 1, 0, 1, 0, 1, 1,
       0, 1, 1, 0, 1, 0, 0,
       0, 0, 1, 1, 0, 0, 0,
       0, 0, 0, 1, 1, 0, 0,
       1, 1, 1, 1, 1, 0, 1,
       0, 1, 1, 0, 0, 0, 1},
      /*masked_lm_ids*/
      {1, 1, 0, 1, 2, 1, 1,
       1, 1, 1, 2, 0, 2, 0,
       1, 0, 0, 2, 1, 2, 2,
       2, 0, 1, 0, 2, 0, 2,
       1, 1, 2, 0, 1, 1, 1,
       2, 2, 0, 2, 1, 1, 2,
       1, 0, 2, 0, 0, 2, 1,
       2, 2, 2, 0, 2, 1, 1,
       0, 2, 1, 2, 0, 0, 2,
       0, 0, 0, 2, 1, 0, 0,
       1, 2, 1, 0, 1, 2, 1,
       2, 0, 2, 1, 2, 0, 2,
       2, 2, 1, 1, 0, 2, 1},
      /*next_sentence_labels*/
      {1, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0},
      /*masked_lm_positions*/
      {0, 1, 2, 3, 4, 5, 6,
       0, 1, 2, 3, 4, 5, 6,
       0, 1, 2, 3, 4, 5, 6,
       0, 1, 2, 3, 4, 5, 6,
       0, 1, 2, 3, 4, 5, 6,
       0, 1, 2, 3, 4, 5, 6,
       0, 1, 2, 3, 4, 5, 6,
       0, 1, 2, 3, 4, 5, 6,
       0, 1, 2, 3, 4, 5, 6,
       0, 1, 2, 3, 4, 5, 6,
       0, 1, 2, 3, 4, 5, 6,
       0, 1, 2, 3, 4, 5, 6,
       0, 1, 2, 3, 4, 5, 6}};
  std::vector<float> masked_lm_weights(13 * 7, 1.0f);

  std::vector<OrtValue> feeds(feed_names.size());
  for (size_t i = 0; i < 6; ++i) {
    TrainingUtil::CreateCpuMLValue(tensor_shapes[i].GetDims(), tensor_values[i], &feeds[i]);
  }
  TrainingUtil::CreateCpuMLValue(tensor_shapes[6].GetDims(), masked_lm_weights, &feeds[6]);

  auto output_names_include_gradients = GetModelOutputNames(*training_session);
  std::vector<std::string> fetch_names(output_names_include_gradients.begin(), output_names_include_gradients.end());

  std::vector<OrtValue> fetches;

  EXPECT_TRUE(training_session->Run(run_options, feed_names, feeds, fetch_names, &fetches).IsOK());

  for (size_t i = 0; i < fetch_names.size(); ++i) {
    if (!fetches[i].IsAllocated() || !!fetches[i].IsTensor())
      continue;

    const Tensor& tensor = fetches[i].Get<Tensor>();
    if (DataTypeImpl::GetType<float>() != tensor.DataType()) {
      continue;
    }

    const std::string& name = fetch_names[i];
    if (BERT_TOY_FETCHES.find(name) == BERT_TOY_FETCHES.end()) {
      continue;
    }

    auto gradient_ref = BERT_TOY_FETCHES.at(name);
    EXPECT_TRUE(static_cast<size_t>(tensor.Shape().Size()) == gradient_ref.size());

    float max_diff = 0;
    float max_percent_diff = 0;
    const float* data = tensor.template Data<float>();
    for (size_t idx = 0; idx < gradient_ref.size(); ++idx) {
      float diff = std::fabs(static_cast<float>(gradient_ref[idx]) - data[idx]);
      max_diff = std::fmax(max_diff, diff);
      max_percent_diff = std::fmax(max_percent_diff, diff / data[idx]);
    }
    EXPECT_TRUE(max_diff < 1e-5) << name << "" is incorrect: max_diff is "" << max_diff;
    if (max_diff > 1e-10) {
      EXPECT_TRUE(max_percent_diff < 0.01f) << name << "" is incorrect: max_percent_diff is ""
                                            << max_percent_diff;
    }
  }
}
#endif
TEST(GradientGraphBuilderTest, TrainingSession_BertToy) {
  const auto model_path = ORT_TSTR(""testdata/bert_toy_optimized.onnx"");

  TrainingSession::TrainingConfiguration config{};
  config.model_with_training_graph_path = ORT_TSTR(""testdata/bert_toy_optimized_bw.onnx"");
  config.loss_function_config = TrainingSession::TrainingConfiguration::LossFunctionConfiguration{};
  config.loss_function_config.value().loss_function_info =
      LossFunctionInfo(OpDef(""BertLoss"", kOnnxDomain),
                       ""total_loss"",
                       {/*prediction_masked_lm*/ ""prediction_scores"",
                        /*prediction_next_sentence*/ ""seq_relationship_score"",
                        /*masked_lm_positions*/ ""masked_lm_positions"",
                        /*masked_lm_ids*/ ""masked_lm_ids"",
                        /*masked_lm_weights*/ ""masked_lm_weights"",
                        /*next_sentence_labels*/ ""next_sentence_labels"",
                        /*mlm_loss*/ ""mlm_loss"",
                        /*nsp_loss*/ ""nsp_loss""});
  config.weight_names_to_not_train = {
      ""position_01"",            // Slice's dat input
      ""op_min_ends_expand_10"",  //op_min_ends_expand_10
  };
  config.immutable_weights = {
      {""Div"", {{1, 8.0f}, {1, 1.4142135381698608f}}},
      {""Add"", {{1, 1.0f}, {1, 9.999999960041972e-13f}}},
      {""Mul"", {{1, 0.5f}, {1, -10000.0f}}},
      {""Sub"", {{0, 1.0f}}}};

  PathString backprop_model_file;
  ASSERT_STATUS_OK(BuildBackPropGraph(model_path, config, backprop_model_file));

#ifdef USE_CUDA
  SessionOptions so;
  RunBertTrainingWithChecks(so, backprop_model_file);
#endif
}

class PipelineSplitter {
 public:
  struct UnidirectionCutInfo {
    // nodes are identified by its output[0]
    std::vector<std::string> nodes;
    // inputs for sync between sub models
    std::vector<std::string> sync_inputs;
    // outputs for sync between sub models
    // note there might be some graph ouputs do not need to sync
    std::vector<std::string> sync_outputs;
    // dependencies for maintaining topological order
    std::vector<std::string> wait_depends;
    std::vector<std::string> record_depends;
  };

  struct CutInfo {
    UnidirectionCutInfo fw;
    UnidirectionCutInfo bw;
  };

  PipelineSplitter() = default;

  void Split(
      PathString backprop_model_file,
      const std::vector<PathString>& sub_model_files,
      const std::vector<CutInfo>& cuts) {
    const auto num_subs = cuts.size();

    std::shared_ptr<Model> model;
    ASSERT_STATUS_OK(Model::Load(
        backprop_model_file, model, nullptr, DefaultLoggingManager().DefaultLogger()));

    const auto& main_graph = model->MainGraph();
    const auto mp = model->ToProto();
    const auto& main_gp = mp.graph();

    auto lookup_main_graph_node_arg_proto =
        [&main_graph](const std::string& node_arg_name) -> const ONNX_NAMESPACE::ValueInfoProto* {
      const auto* node_arg = main_graph.GetNodeArg(node_arg_name);
      if (!node_arg) return nullptr;
      return &node_arg->ToProto();
    };

    std::vector<ONNX_NAMESPACE::ModelProto> sub_mps(num_subs, mp);
    for (size_t i = 0; i < num_subs; ++i) {
      auto& sub = sub_mps[i];
      sub.clear_graph();
      FillInputWait(sub.mutable_graph(),
                    main_gp,
                    lookup_main_graph_node_arg_proto,
                    cuts[i].fw.sync_inputs,
                    cuts[i].fw.wait_depends,
                    i,
                    /*bw*/ false);
    }

    for (const auto& n : main_gp.node()) {
      // check which sub_model the node should be in
      const size_t sub_id = [&]() {
        for (size_t i = 0; i < num_subs; ++i) {
          const auto& cut = cuts[i];
          if (std::count(cut.fw.nodes.cbegin(), cut.fw.nodes.cend(), n.output()[0])) {
            return i;
          }
          if (std::count(cut.bw.nodes.cbegin(), cut.bw.nodes.cend(), n.output()[0])) {
            return i;
          }
        }
        ORT_THROW(""Failed to find sub-model containing node: "", n.name());
      }();

      auto* sub_gp = sub_mps[sub_id].mutable_graph();
      const auto& cut = cuts[sub_id];

      // add WaitEvent node at the beginning of bw
      if (!cut.bw.nodes.empty() && n.output()[0] == cut.bw.nodes.front()) {
        FillInputWait(sub_gp,
                      main_gp,
                      lookup_main_graph_node_arg_proto,
                      cut.bw.sync_inputs,
                      cut.bw.wait_depends,
                      sub_id,
                      /*bw*/ true);
      }

      // copy node to sub model
      sub_gp->mutable_node()->Add()->CopyFrom(n);
      for (auto i = n.input().cbegin(); i != n.input().cend(); ++i) {
        AddItemByName(sub_gp->mutable_initializer(), main_gp.initializer(), *i, *i);
        if (0 == std::count(cut.fw.sync_inputs.cbegin(), cut.fw.sync_inputs.cend(), *i) &&
            0 == std::count(cut.bw.sync_inputs.cbegin(), cut.bw.sync_inputs.cend(), *i)) {
          // carry over original graph's input, if not in sync_inputs
          AddItemByName(sub_gp->mutable_input(), main_gp.input(), *i, *i);
        }
      }
      for (auto i = n.output().cbegin(); i != n.output().cend(); ++i) {
        if (std::count(cut.fw.sync_outputs.cbegin(), cut.fw.sync_outputs.cend(), *i) ||
            std::count(cut.bw.sync_outputs.cbegin(), cut.bw.sync_outputs.cend(), *i))
          continue;  // sync_ouputs already handled, skip

        // add graph output
        if (!AddItemByName(sub_gp->mutable_output(), main_gp.output(), *i, *i)) {
          // for non-output, add shape info
          AddValueInfoByNameFromLookup(*sub_gp->mutable_value_info(),
                                       lookup_main_graph_node_arg_proto,
                                       *i,
                                       *i);
        }
      }

      // add RecordEvent node at the end of fw and bw
      if ((!cut.fw.nodes.empty() && n.output()[0] == cut.fw.nodes.back()) ||
          (!cut.bw.nodes.empty() && n.output()[0] == cut.bw.nodes.back())) {
        bool bw = (n.output()[0] == cut.bw.nodes.back());
        const auto& sync_outputs = (bw ? cut.bw.sync_outputs : cut.fw.sync_outputs);
        const auto& dependencies = (bw ? cut.bw.record_depends : cut.fw.record_depends);

        FillOutputRecord(sub_gp,
                         main_gp,
                         lookup_main_graph_node_arg_proto,
                         sync_outputs,
                         dependencies,
                         sub_id,
                         bw);
      }
    }

    // save sub models
    for (size_t sub_id = 0; sub_id < num_subs; ++sub_id) {
      std::ofstream ofs(sub_model_files[sub_id], std::ofstream::binary);
      sub_mps[sub_id].SerializeToOstream(&ofs);
      ofs.close();
    }
  }

 private:
  // add RepeatedField item by name from another RepeatedFields
  // return true if the name exists in dst
  template <typename TD, typename TS>
  bool AddItemByName(TD* dst, const TS& src, const std::string& name, const std::string& new_name) {
    for (auto iter = dst->cbegin(); iter != dst->cend(); ++iter) {
      if (iter->name() == new_name) {
        return true;
      }
    }
    for (auto iter = src.cbegin(); iter != src.cend(); ++iter) {
      if (iter->name() == name) {
        auto* p = dst->Add();
        p->CopyFrom(*iter);
        *p->mutable_name() = new_name;
        return true;
      }
    }
    return false;
  }

  // expected signature of TValueInfoLookupFn:
  //   const ValueInfoProto* TValueInfoLookupFn(const std::string& name)
  template <typename TValueInfoLookupFn>
  bool AddValueInfoByNameFromLookup(
      google::protobuf::RepeatedPtrField<ONNX_NAMESPACE::ValueInfoProto>& dst, TValueInfoLookupFn lookup,
      const std::string& name, const std::string& new_name) {
    for (auto iter = dst.cbegin(); iter != dst.cend(); ++iter) {
      if (iter->name() == new_name) {
        return true;
      }
    }

    const ONNX_NAMESPACE::ValueInfoProto* value_info = lookup(name);
    if (value_info) {
      auto* p = dst.Add();
      p->CopyFrom(*value_info);
      *p->mutable_name() = new_name;
      return true;
    }

    return false;
  }

  template <typename TValueInfoLookupFn>
  void FillInputWait(
      ONNX_NAMESPACE::GraphProto* sub_gp,
      const ONNX_NAMESPACE::GraphProto& main_gp,
      TValueInfoLookupFn main_graph_lookup,
      const std::vector<std::string>& sync_inputs,
      const std::vector<std::string>& dependencies,
      size_t sub_id,
      bool bw) {
    // input/output with Wait/RecordEvent
    // Note data is gated by Wait/RecordEvent, so name with postfix ""_sync""
    // In distributed training, the pattern is:
    //   wait_data -> recv -> wait_pipeline -> fw/bw -> record_pipeline -> send -> record_data
    // Here wait_data/record_data is to ensure execution order due to data dependency (same batch across pipelines),
    // while wait_pipeline/recorde_pipeline is to ensure pipeline execution order.
    // This test simplifies the graph to omit send/recv,
    // but we still need to have double wait and record to sync data and pipeline separately
    ONNX_NAMESPACE::NodeProto* wait_data_np = nullptr;
    ONNX_NAMESPACE::NodeProto* wait_pipeline_np = nullptr;
    std::string wait_data_id = ""wait_data_"" + std::to_string(sub_id) + (bw ? ""_bw"" : ""_fw"");
    std::string wait_pipeline_id = ""wait_pipeline_"" + std::to_string(sub_id) + (bw ? ""_bw"" : ""_fw"");
    bool is_first = (sub_id == 0 && !bw);
    if (sync_inputs.size() + dependencies.size() > 0) {
      if (!is_first) {
        wait_data_np = sub_gp->add_node();
        *wait_data_np->mutable_op_type() = ""WaitEvent"";
        *wait_data_np->mutable_domain() = kMSDomain;
        *wait_data_np->mutable_input()->Add() = wait_data_id;
      }
      wait_pipeline_np = sub_gp->add_node();
      *wait_pipeline_np->mutable_op_type() = ""WaitEvent"";
      *wait_pipeline_np->mutable_domain() = kMSDomain;
      *wait_pipeline_np->mutable_input()->Add() = wait_pipeline_id;
    }
    for (const auto& name : sync_inputs) {
      std::string input_name = name + ""_sync"";
      std::string recv_name = name + ""_recv"";
      if (wait_data_np) {
        *wait_data_np->mutable_input()->Add() = input_name;
        *wait_data_np->mutable_output()->Add() = recv_name;
        *wait_pipeline_np->mutable_input()->Add() = recv_name;
      } else {
        *wait_pipeline_np->mutable_input()->Add() = input_name;
      }
      *wait_pipeline_np->mutable_output()->Add() = name;
      // some input comes graph input
      if (AddItemByName(sub_gp->mutable_input(),
                        main_gp.input(),
                        name,
                        input_name)) {
        ASSERT_TRUE(is_first);
        // add shape info
        EXPECT_TRUE(AddValueInfoByNameFromLookup(*sub_gp->mutable_value_info(),
                                                 main_graph_lookup,
                                                 name,
                                                 name));
      } else {
        // some input comes from the middle of the graph
        AddValueInfoByNameFromLookup(*sub_gp->mutable_input(),
                                     main_graph_lookup,
                                     name,
                                     input_name);
        // add shape info
        AddValueInfoByNameFromLookup(*sub_gp->mutable_value_info(),
                                     main_graph_lookup,
                                     name,
                                     recv_name);
        AddValueInfoByNameFromLookup(*sub_gp->mutable_value_info(),
                                     main_graph_lookup,
                                     name,
                                     name);
      }
    }

    if (wait_pipeline_np) {
      //add dependencies on the first wait
      auto* wait_np = wait_data_np ? wait_data_np : wait_pipeline_np;
      for (const auto& dep : dependencies) {
        *wait_np->mutable_input()->Add() = dep;
      }

      // add input for event ids
      if (wait_data_np) {
        auto* p = sub_gp->mutable_input()->Add();
        *p->mutable_name() = wait_data_id;
        p->mutable_type()->mutable_tensor_type()->set_elem_type(ONNX_NAMESPACE::TensorProto_DataType_INT64);
      }
      auto* p = sub_gp->mutable_input()->Add();
      *p->mutable_name() = wait_pipeline_id;
      p->mutable_type()->mutable_tensor_type()->set_elem_type(ONNX_NAMESPACE::TensorProto_DataType_INT64);
    }
  }

  template <typename TValueInfoLookupFn>
  void FillOutputRecord(
      ONNX_NAMESPACE::GraphProto* sub_gp,
      const ONNX_NAMESPACE::GraphProto& /*main_gp*/,
      TValueInfoLookupFn main_graph_lookup,
      const std::vector<std::string>& sync_outputs,
      const std::vector<std::string>& dependencies,
      size_t sub_id,
      bool bw) {
    ONNX_NAMESPACE::NodeProto* record_pipeline_np = nullptr;
    ONNX_NAMESPACE::NodeProto* record_data_np = nullptr;
    std::string record_pipeline_id = ""record_pipeline_"" + std::to_string(sub_id) + (bw ? ""_bw"" : ""_fw"");
    std::string record_data_id = ""record_data_"" + std::to_string(sub_id) + (bw ? ""_bw"" : ""_fw"");
    bool is_last = (sub_id == 0 && bw);
    if (sync_outputs.size() + dependencies.size() > 0) {
      record_pipeline_np = sub_gp->add_node();
      *record_pipeline_np->mutable_op_type() = ""RecordEvent"";
      *record_pipeline_np->mutable_domain() = kMSDomain;
      *record_pipeline_np->mutable_input()->Add() = record_pipeline_id;

      if (!is_last) {
        record_data_np = sub_gp->add_node();
        *record_data_np->mutable_op_type() = ""RecordEvent"";
        *record_data_np->mutable_domain() = kMSDomain;
        *record_data_np->mutable_input()->Add() = record_data_id;
      }
    }

    if (sync_outputs.size() > 0) {
      for (const auto& name : sync_outputs) {
        *record_pipeline_np->mutable_input()->Add() = name;
        if (record_data_np) {
          *record_pipeline_np->mutable_output()->Add() = name + ""_send"";
          *record_data_np->mutable_input()->Add() = name + ""_send"";
          *record_data_np->mutable_output()->Add() = name + ""_sync"";
        } else {
          *record_pipeline_np->mutable_output()->Add() = name + ""_sync"";
        }
      }
    }

    if (record_pipeline_np) {
      for (const auto& name : dependencies)
        *record_pipeline_np->mutable_input()->Add() = name;

      // add input for event_id
      auto* p = sub_gp->mutable_input()->Add();
      *p->mutable_name() = record_pipeline_id;
      p->mutable_type()->mutable_tensor_type()->set_elem_type(ONNX_NAMESPACE::TensorProto_DataType_INT64);

      if (record_data_np) {
        p = sub_gp->mutable_input()->Add();
        *p->mutable_name() = record_data_id;
        p->mutable_type()->mutable_tensor_type()->set_elem_type(ONNX_NAMESPACE::TensorProto_DataType_INT64);
      }
    }

    // add graph output and shape info
    for (const auto& name : sync_outputs) {
      AddValueInfoByNameFromLookup(*sub_gp->mutable_output(),
                                   main_graph_lookup,
                                   name,
                                   name + ""_sync"");
      if (!is_last) {
        AddValueInfoByNameFromLookup(*sub_gp->mutable_value_info(),
                                     main_graph_lookup,
                                     name,
                                     name + ""_send"");
      }
      AddValueInfoByNameFromLookup(*sub_gp->mutable_value_info(),
                                   main_graph_lookup,
                                   name,
                                   name);
    }
  }
};

// TODO: move to a proper location for pipeline training

// pipeline plan for each batch
struct PipelineBatchInfo {
  // Event pairs for each pipeline slot to WaitEvent when start, and RecordEvent when end
  std::vector<std::pair<int64_t, int64_t>> events;
  // indices of retired batches, so their data could be reused
  // a batch can only be retired after finished backward in stage 0
  // this can be used to join worker threads or reuse buffers
  // for example, in a node with N GPUs and B batches to run in pipeline (with one stage for each GPU)
  // there will be (N * B) threads created, and by being able to retire,
  // only at most (N * (2 * N - 1)) concurrent threads are needed
  // for small number of B, there's no retired threads so total count would be the same.
  // for big number of B, this would be helpful
  std::vector<int64_t> retired_batches;
};

class PipelineTimeline {
 public:
  struct Slot {
    enum class Type {
      Unused,
      Forward,
      Backward
    };
    Type type;
    size_t batch_id;

    Slot() : type(Type::Unused) {}
  };

  PipelineTimeline() = default;

  void Initialize(size_t num_stages, size_t num_slots) {
    slots_.resize(num_stages);
    for (size_t s = 0; s < num_stages; ++s) {
      slots_[s].resize(num_slots);
    }
  }

  bool IsOccupied(size_t s, size_t t) const {
    return slots_[s][t].type != Slot::Type::Unused;
  }

  const Slot& Get(size_t s, size_t t) const {
    return slots_[s][t];
  }

  size_t GetNumSlots() const {
    return slots_[0].size();
  }

  void Occupy(size_t s, size_t t, size_t batch_id, Slot::Type st) {
    Slot& slot = slots_[s][t];
    ORT_ENFORCE(slot.type == Slot::Type::Unused);
    slot.type = st;
    slot.batch_id = batch_id;
  }

 private:
  std::vector<std::vector<Slot>> slots_;
};

// pipeline planner for batches
class PipelineBatchPlanner {
 private:
  int64_t max_id_;
  PipelineTimeline timeline_;

 public:
  PipelineBatchPlanner()
      : max_id_(::onnxruntime::contrib::OrtEventPool::GetPoolSize() - 1) {
  }

  // Generate timeline for one-forward-one-backward scheduling,
  // which schedules execution in batch order to minimize latency for onging batches
  // each stage requires 2 pair of wait/record events for FW/BW
  void GenerateOneFWOneBWTimeline(size_t num_stages, size_t num_batches) {
    // The first batch has 2 * (num_stages - 1) gaps between FW and BW
    // then 2 slots for FW/BW in each batch
    size_t num_slots = 2 * (num_stages - 1) + num_batches * 2;
    timeline_.Initialize(num_stages, num_slots);

    // fw time slot to start the search for empty ones in each stage
    std::vector<size_t> t_fw(num_stages, 0);
    // bw time slot to start the search for empty ones in each stage
    std::vector<size_t> t_bw(num_stages, 0);

    // generate timeline in batch order to minimize latency for ongoing batches
    for (size_t batch_id = 0; batch_id < num_batches; ++batch_id) {
      // plan for FW
      for (size_t s = 0; s < num_stages; ++s) {
        while (timeline_.IsOccupied(s, t_fw[s])) {
          ++t_fw[s];
        }
        // after find a slot, update t[s+1..] if needed
        for (size_t ss = s + 1; ss < num_stages; ++ss) {
          t_fw[ss] = std::max(t_fw[ss], t_fw[s] + (ss - s));
        }
        // occupy slot in timeline
        timeline_.Occupy(s, t_fw[s]++, batch_id, PipelineTimeline::Slot::Type::Forward);
      }
      // plan for BW
      for (int s = gsl::narrow<int>(num_stages - 1); s >= 0; --s) {
        t_bw[s] = std::max(t_fw[s], t_bw[s]);
        while (timeline_.IsOccupied(s, t_bw[s])) {
          t_bw[s]++;
        }
        // after find a slot, update t_bw[s-1..]
        for (int ss = s - 1; ss >= 0; --ss) {
          t_bw[ss] = std::max(t_bw[ss], t_bw[s] + (s - ss));
        }
        // occupy slot in timeline
        timeline_.Occupy(s, t_bw[s], batch_id, PipelineTimeline::Slot::Type::Backward);
      }
    }
  }

  // create pipeline plans according to generated timeline
  // with start_event_id = s, the output of each stage is [-1, s], [s, s+1], [s+1, s+2]... for each occupied slot
  // and will be assigned to each batch's PipelineBatchInfo
  // returns the first unused event_id after creating
  int64_t CreatePlan(int64_t start_event_id, const size_t stage, std::vector<PipelineBatchInfo>& plan) {
    // fill in plan
    int64_t prev_event_id = -1;
    int64_t event_id = start_event_id;
    std::vector<int64_t> retired_batches;
    for (size_t t = 0; t < timeline_.GetNumSlots(); ++t) {
      if (!timeline_.IsOccupied(stage, t))
        continue;

      const auto& slot = timeline_.Get(stage, t);
      ORT_ENFORCE(event_id < max_id_);
      if (stage == 0) {
        if (slot.type == PipelineTimeline::Slot::Type::Forward) {
          // set retired batches when starting a new batch (s == 0 && !bw)
          plan[slot.batch_id].retired_batches = retired_batches;
          retired_batches.clear();
        } else if (slot.type == PipelineTimeline::Slot::Type::Backward) {
          // add to retired batches after backward of stage 0
          retired_batches.push_back(gsl::narrow<int64_t>(slot.batch_id));
        }
      }
      // add a pair of wait/record event ids to given batch_id
      plan[slot.batch_id].events.emplace_back(prev_event_id, event_id);
      prev_event_id = event_id;
      ++event_id;
    }
    return event_id;
  }
};

void RetrieveEventOperators(
  Graph& graph, 
  Node** forward_wait_before_recv,
  Node** forward_wait_after_recv,
  Node** forward_record_before_send,
  Node** forward_record_after_send,
  Node** backward_wait_before_recv,
  Node** backward_wait_after_recv,
  Node** backward_record_before_send,
  Node** backward_record_after_send) {
  // Initialize retrieved nodes.
  // Non-existing nodes may hold NULL forever.
  // Existing nodes may get valid pointers below.
  *forward_wait_before_recv = nullptr;
  *forward_wait_after_recv = nullptr;
  *forward_record_before_send = nullptr;
  *forward_record_after_send = nullptr;
  *backward_wait_before_recv = nullptr;
  *backward_wait_after_recv = nullptr;
  *backward_record_before_send = nullptr;
  *backward_record_after_send = nullptr;

  // Declare container for WaitEvent's in topological order.
  std::vector<Node*> waits;
  // Declare container for RecordEvent's in topological order.
  std::vector<Node*> records;

  // Find out WaitEvent's and RecordEvent's.
  GraphViewer graph_viewer(graph);
  for (auto& node_idx : graph_viewer.GetNodesInTopologicalOrder()) {
    Node* node = graph.GetNode(node_idx);
    if (node->OpType() == ""WaitEvent"") {
      waits.push_back(node);
    } else if (node->OpType() == ""RecordEvent"") {
      records.push_back(node);
    }
  }

  if (waits.size() == size_t(4)) {
    // Each of first stage and middle stages has 4 WaitEvent's.
    *forward_wait_before_recv = waits[0];
    *forward_wait_after_recv = waits[1];
    *backward_wait_before_recv = waits[2];
    *backward_wait_after_recv = waits[3];
  } else if (waits.size() == size_t(2)) {
    // Last stage has 2 WaitEvent's.
    *forward_wait_before_recv = waits[0];
    *forward_wait_after_recv = waits[1];
  } else {
    ORT_THROW(""Wrong number of WaitEvent operators: "", waits.size(), ""Expected value is either 2 or 4."");
  }

  if (records.size() == size_t(4)) {
    // Each of first stage and middle stages has 4 RecordEvent's.
    *forward_record_before_send = records[0];
    *forward_record_after_send = records[1];
    *backward_record_before_send = records[2];
    *backward_record_after_send = records[3];
  } else if (waits.size() == size_t(2)) {
    // Last stage has 2 RecordEvent's.
    *backward_record_before_send = records[0];
    *backward_record_after_send = records[1];
  } else {
    ORT_THROW(""Wrong number of RecordEvent operators: "", waits.size(), "". Expected value is either 2 or 4."");
  }
}

void RetrieveSendRecvOperators(
  Graph& graph, 
  Node** forward_recv,
  Node** forward_send,
  Node** backward_recv,
  Node** backward_send) {
  // Initialize retrieved nodes.
  // Non-existing nodes may hold NULL forever.
  // Existing nodes may get valid pointers below.
  *forward_recv = nullptr;
  *forward_send = nullptr;
  *backward_recv = nullptr;
  *backward_send = nullptr;

  auto is_backward = [](Node& node) {
    return (node.Description() == ""Backward pass"");
  };

  // Search for Send's and Recv's by assuming that
  // there are only one Send and one Recv in forward/backward.
  for (auto& node : graph.Nodes()) {
    if (node.OpType() == ""Send"") {
      if (is_backward(node)) {
        // backward_send can only be assigned one valid pointer.
        // If it is assigned more than once, it means we have multiple
        // Send in backward pass and therefore our assumption doesn't hold. 
        // This check ensure that only we only update *backward_send when
        // its value is NULL and guards our one-Recv assumption. 
        ASSERT_TRUE(!(*backward_send));
        *backward_send = &node;
      } else {
        // Guard the uniqueness of Send in the forward pass by throwing
        // when *forward_send already carries a valid pointer.
        ASSERT_TRUE(!(*forward_send));
        *forward_send = &node;
      }
    } else if (node.OpType() == ""Recv"") {
      if (is_backward(node)) {
        // Guard the uniqueness of Recv in the backward pass by throwing
        // when *backward_recv already carries a valid pointer.
        ASSERT_TRUE(!(*backward_recv));
        *backward_recv = &node;
      } else {
        // Guard the uniqueness of Recv in the forwaard pass by throwing
        // when *forward_recv already carries a valid pointer.
        *forward_recv = &node;
      }
    }
  }
}

// verify pipeline config can load and gradient graph can construct.
TEST(GradientGraphBuilderTest, TrainingSession_PipelineTransform_base) {
  PathString filename_base = ORT_TSTR(""testdata/test_training_model_"");

  auto load_and_check_gradient_graph = [](int stageIdx, PathString& input_file, PathString& output_file) {
    auto config = MakeBasicTrainingConfig();

    TrainingSession::TrainingConfiguration::PipelineConfiguration pipe_config{};
    config.pipeline_config = pipe_config;

    PathString backprop_model_file;
    ASSERT_STATUS_OK(BuildBackPropGraph(input_file, config, backprop_model_file));

    std::shared_ptr<Model> model;
    ASSERT_STATUS_OK(Model::Load(backprop_model_file, model, nullptr, DefaultLoggingManager().DefaultLogger()));

    Graph& graph = model->MainGraph();

    // Declare forward event nodes.
    // The nodes are declared according to their topological order.
    Node* forward_wait_before_recv{nullptr};
    Node* forward_wait_after_recv{nullptr};
    Node* forward_record_before_send{nullptr};
    Node* forward_record_after_send{nullptr};

    // Declare backward event nodes.
    // The nodes are declared according to their topological order.
    Node* backward_wait_before_recv{nullptr};
    Node* backward_wait_after_recv{nullptr};
    Node* backward_record_before_send{nullptr};
    Node* backward_record_after_send{nullptr};

    // Find event nodes.
    RetrieveEventOperators(
      graph,
      &forward_wait_before_recv,
      &forward_wait_after_recv,
      &forward_record_before_send,
      &forward_record_after_send,
      &backward_wait_before_recv,
      &backward_wait_after_recv,
      &backward_record_before_send,
      &backward_record_after_send);

    // Check event nodes.
    if (stageIdx == 2) {
      ASSERT_TRUE(forward_wait_before_recv);
      ASSERT_TRUE(forward_wait_after_recv);

      // Last pipeline stage can perform backward right after its forward.
      // It won't have event operators to divide forward from backward.
      ASSERT_TRUE(!forward_record_before_send);
      ASSERT_TRUE(!forward_record_after_send);
      ASSERT_TRUE(!backward_wait_before_recv);
      ASSERT_TRUE(!backward_wait_after_recv);

      ASSERT_TRUE(backward_record_before_send);
      ASSERT_TRUE(backward_record_after_send);
    } else {
      // Beginning of forward.
      ASSERT_TRUE(forward_wait_before_recv);
      ASSERT_TRUE(forward_wait_after_recv);

      // End of forward.
      ASSERT_TRUE(forward_record_before_send);
      ASSERT_TRUE(forward_record_after_send);

      // Beginning of backward.
      ASSERT_TRUE(backward_wait_before_recv);
      ASSERT_TRUE(backward_wait_after_recv);

      // End of backward.
      ASSERT_TRUE(backward_record_before_send);
      ASSERT_TRUE(backward_record_after_send);
    }

    Node* forward_send{nullptr};
    Node* forward_recv{nullptr};
    Node* backward_recv{nullptr};
    Node* backward_send{nullptr};

    RetrieveSendRecvOperators(
      graph, 
      &forward_recv,
      &forward_send,
      &backward_recv,
      &backward_send);

    // Except the last partion, each partition should have send forward and recv backward.
    if (stageIdx == 0 || stageIdx == 1) {
      ASSERT_TRUE(forward_send && backward_recv);
    } else {
      ASSERT_TRUE(!forward_send && !backward_recv);
    }
    // Except the first partion, each partition should have recv forward and send backward.
    if (stageIdx == 1 || stageIdx == 2) {
      ASSERT_TRUE(forward_recv && backward_send);
    } else {
      ASSERT_TRUE(!forward_recv && !backward_send);
    }

    auto mp = model->ToProto();
    std::ofstream ofs(output_file, std::ofstream::binary);
    mp.SerializeToOstream(&ofs);
    ofs.close();
  };

  for (int i = 0; i < 3; ++i) {
#ifdef _WIN32
    auto surfix = std::to_wstring(i);
#else
    auto surfix = std::to_string(i);
#endif
    PathString input_file = filename_base + surfix + ORT_TSTR("".onnx"");
    PathString output_file = filename_base + surfix + ORT_TSTR(""_back.onnx"");
    load_and_check_gradient_graph(i, input_file, output_file);
  }
}

TEST(GradientGraphBuilderTest, TrainingSession_WithPipeline) {
  auto config = MakeBasicTrainingConfig();
  //config.set_gradients_as_graph_outputs = true;
  PathString backprop_model_file;
  ASSERT_STATUS_OK(BuildBackPropGraph(ORIGINAL_MODEL_PATH, config, backprop_model_file));

  // cut the model using outputs
  const std::vector<PipelineSplitter::CutInfo> cuts = {
      //sub model 0
      {{{""T1"", ""T2"", ""T3""},
        {""X""},
        {""T3""},
        {},
        {}},
       {{""T2_grad"", ""T1_grad"", ""B1_grad"", ""W1_grad""},
        {""T3_grad""},
        {},
        {""T3_sync""},
        {""B1_grad"", ""W1_grad""}}},
      // sub model 1
      {{{""T4"", ""T5"", ""T6""},
        {""T3""},
        {""T6""},
        {},
        {}},
       {{""T5_grad"", ""T4_grad"", ""T3_grad"", ""B2_grad"", ""W2_grad""},
        {""T6_grad""},
        {""T3_grad""},
        {""T6_sync""},
        {""B2_grad"", ""W2_grad""}}},
      // sub model 2
      {{{""T7"", ""MeanSquaredError_diff"", ""MeanSquaredError_diff_square"", ""loss"", ""predictions""},
        {""T6""},
        {},
        {},
        {}},
       {{""MeanSquaredError_reduce_mean_Grad/Unqueezed_Grad"", ""MeanSquaredError_reduce_mean_Grad/Tiled_Grad"", ""MeanSquaredError_diff_square_grad"", ""MeanSquaredError_diff_grad"", ""predictions_grad"", ""B3_grad"", ""T7_grad"", ""W3_grad"", ""T6_grad""},
        {},
        {""T6_grad""},
        {},
        {""loss"", ""predictions"", ""B3_grad"", ""W3_grad""}}}};

  const auto num_subs = cuts.size();

  std::vector<PathString> sub_model_files(num_subs);
  for (size_t sub_id = 0; sub_id < num_subs; ++sub_id) {
#ifdef _WIN32
    auto sub_id_str = std::to_wstring(sub_id);
#else
    auto sub_id_str = std::to_string(sub_id);
#endif
    sub_model_files[sub_id] = ORT_TSTR(""sub_"") + sub_id_str + ORT_TSTR("".onnx"");
  }

  PipelineSplitter splitter;
  splitter.Split(backprop_model_file, sub_model_files, cuts);

  // create training sessions
  std::unique_ptr<Environment> env;
  ASSERT_STATUS_OK(Environment::Create(nullptr, env));

  struct SubSession {
    std::unique_ptr<TrainingSession> sess;
    SessionOptions so;
    RunOptions run_options;
  };

  std::vector<SubSession> subs(num_subs);
  for (size_t sub_id = 0; sub_id < num_subs; ++sub_id) {
    auto& sub_sess = subs[sub_id];
    sub_sess.so.enable_profiling = true;
#ifdef _WIN32
    auto sub_id_str = std::to_wstring(sub_id);
#else
    auto sub_id_str = std::to_string(sub_id);
#endif
    sub_sess.so.profile_file_prefix = ORT_TSTR(""pipeline"") + sub_id_str;

    sub_sess.run_options.run_log_verbosity_level = sub_sess.so.session_log_verbosity_level;
    sub_sess.run_options.run_tag = sub_sess.so.session_logid;

    sub_sess.sess = onnxruntime::make_unique<TrainingSession>(sub_sess.so, *env);
    ASSERT_STATUS_OK(sub_sess.sess->Load(sub_model_files[sub_id]));
    ASSERT_STATUS_OK(sub_sess.sess->Initialize());
  }

  // pipeline inputs for each batch
  struct PipelineFeed {
    MLValue x_value;
    MLValue label_value;
    std::vector<MLValue> record_data_values;
    std::vector<std::pair<MLValue, MLValue>> wait_record_pipeline_values;

    void SetInputs(const std::vector<float>& x, const std::vector<float>& label) {
      // dummy data for model inputs
      std::vector<int64_t> x_dims = {1, 784};
      std::vector<int64_t> label_dims = {1, 10};
      TrainingUtil::CreateCpuMLValue<float>(x_dims, x, &x_value);
      TrainingUtil::CreateCpuMLValue<float>(label_dims, label, &label_value);
    }

    void SetEvents(const std::vector<int64_t>& record_data,
                   const std::vector<std::pair<int64_t, int64_t>>& wait_record_pipeline) {
      record_data_values.resize(record_data.size());
      for (size_t i = 0; i < record_data.size(); ++i) {
        TrainingUtil::CreateCpuMLValue<int64_t>({}, {record_data[i]}, &record_data_values[i]);
      }
      wait_record_pipeline_values.resize(wait_record_pipeline.size());
      for (size_t i = 0; i < wait_record_pipeline.size(); ++i) {
        TrainingUtil::CreateCpuMLValue<int64_t>(
            {}, {wait_record_pipeline[i].first},
            &wait_record_pipeline_values[i].first);
        TrainingUtil::CreateCpuMLValue<int64_t>(
            {}, {wait_record_pipeline[i].second},
            &wait_record_pipeline_values[i].second);
      }
    }
  };

  // pipeline data for each batch
  struct PipelineData : public PipelineFeed {
    MLValue t3_value;
    MLValue t3_grad_value;
    MLValue t6_value;
    MLValue t6_grad_value;

    PipelineData() {
      std::vector<int64_t> t3_dims = {1, 128};
      std::vector<int64_t> t6_dims = {1, 32};
      std::vector<float> t3_data(128);
      std::vector<float> t6_data(32);
      TrainingUtil::CreateCpuMLValue<float>(t3_dims, t3_data, &t3_value);
      TrainingUtil::CreateCpuMLValue<float>(t3_dims, t3_data, &t3_grad_value);
      TrainingUtil::CreateCpuMLValue<float>(t6_dims, t6_data, &t6_value);
      TrainingUtil::CreateCpuMLValue<float>(t6_dims, t6_data, &t6_grad_value);
    };
  };

  auto worker = [&subs](size_t sub_id, PipelineData& data) {
    std::vector<std::string> input_names;
    std::vector<MLValue> input_values;
    std::vector<std::string> output_names;
    std::vector<MLValue> output_values;
    switch (sub_id) {
      case 0:
        input_names = {
            ""X_sync"", ""T3_grad_sync"",
            ""wait_pipeline_0_fw"",
            ""record_pipeline_0_fw"", ""record_data_0_fw"",
            ""wait_data_0_bw"", ""wait_pipeline_0_bw"",
            ""record_pipeline_0_bw""};
        input_values = {
            data.x_value, data.t3_grad_value,
            data.wait_record_pipeline_values[0].first,
            data.wait_record_pipeline_values[0].second,
            data.record_data_values[0],
            data.record_data_values[3],
            data.wait_record_pipeline_values[1].first,
            data.wait_record_pipeline_values[1].second};
        output_names = {""T3_sync""};
        output_values = {data.t3_value};
        break;
      case 1:
        input_names = {
            ""T3_sync"", ""T6_grad_sync"",
            ""wait_data_1_fw"", ""wait_pipeline_1_fw"",
            ""record_pipeline_1_fw"", ""record_data_1_fw"",
            ""wait_data_1_bw"", ""wait_pipeline_1_bw"",
            ""record_pipeline_1_bw"", ""record_data_1_bw""};
        input_values = {
            data.t3_value, data.t6_grad_value,
            data.record_data_values[0],
            data.wait_record_pipeline_values[2].first,
            data.wait_record_pipeline_values[2].second,
            data.record_data_values[1],
            data.record_data_values[2],
            data.wait_record_pipeline_values[3].first,
            data.wait_record_pipeline_values[3].second,
            data.record_data_values[3]};
        output_names = {""T6_sync"", ""T3_grad_sync""};
        output_values = {data.t6_value, data.t3_grad_value};
        break;
      case 2:
        // note that last stage only need to wait on FW and record and BW
        // there's no wait/record in between
        input_names = {
            ""T6_sync"", ""labels"",
            ""wait_data_2_fw"", ""wait_pipeline_2_fw"",
            ""record_pipeline_2_bw"", ""record_data_2_bw""};
        input_values = {
            data.t6_value, data.label_value,
            data.record_data_values[1],
            data.wait_record_pipeline_values[4].first,   // wait on FW
            data.wait_record_pipeline_values[5].second,  // record on BW
            data.record_data_values[2]};
        output_names = {""T6_grad_sync""};
        output_values = {data.t6_grad_value};
        break;
      default:
        ASSERT_TRUE(false);
    }
    EXPECT_STATUS_OK(subs[sub_id].sess->Run(subs[sub_id].run_options, input_names, input_values, output_names, &output_values));
  };

  const std::vector<int64_t> start_ids = {100, 200, 300};
  const std::vector<int64_t> expected_end_ids = {112, 212, 312};
  const size_t num_stages = start_ids.size();
  const int num_batches = 6;
  std::vector<PipelineBatchInfo> plan(num_batches);
  PipelineBatchPlanner planner;
  planner.GenerateOneFWOneBWTimeline(num_stages, num_batches);

  // create plan for all stages for testing purpose
  // in actual execution, only one stage would be needed for each rank
  for (size_t stage = 0; stage < num_stages; ++stage) {
    int64_t end_id = planner.CreatePlan(start_ids[stage], stage, plan);
    EXPECT_TRUE(end_id == expected_end_ids[stage]);
  }

  // Timeline view of ground truth for plan
  // sub 0: F0 F1 F2 F3 F4 B0 F5 B1    B2    B3    B4    B5
  // sub 1:    F0 F1 F2 B0 F3 B1 F4 B2 F5 B3    B4    B5
  // sub 2:       F0 B0 F1 B1 F2 B2 F3 B3 F4 B4 F5 B5
  // Note that in distributed training, event id would be local to each pipeline
  // We use different ranges for event ids for pipelines here:
  // 0 -> 99: data dependencies for record_data
  // 100 -> 199: sub 0
  // 200 -> 299: sub 1
  // 300 -> 399: sub 2
  // so for sub 0, the schedule is:
  //   F0(-1, 100), F1(100,101), F2(101,102)...
  // for sub 1, the schedule is:
  //   F0(-1, 200), F1(200,201), F2(201,202)...
  // for sub 2, the schedule is:
  //   F0 (-1, 300), B0 (300, 301), F1 (301, 302), B1(302, 303)...
  // Note the chart above is timeline view, execution plan needs to change it to batch view
  const std::vector<PipelineBatchInfo> expected_plan = {
      // each batch event pairs are in order of:
      // batch 0 events on {sub0_fw, sub0_bw, sub1_fw, sub1_bw, sub2_fwbw}
      {{{-1, 100}, {104, 105}, {-1, 200}, {202, 203}, {-1, 300}, {300, 301}}, {}},
      // batch 1
      {{{100, 101}, {106, 107}, {200, 201}, {204, 205}, {301, 302}, {302, 303}}, {}},
      // batch 2
      {{{101, 102}, {107, 108}, {201, 202}, {206, 207}, {303, 304}, {304, 305}}, {}},
      // batch 3
      {{{102, 103}, {108, 109}, {203, 204}, {208, 209}, {305, 306}, {306, 307}}, {}},
      // batch 4
      {{{103, 104}, {109, 110}, {205, 206}, {209, 210}, {307, 308}, {308, 309}}, {}},
      // batch 5
      {{{105, 106}, {110, 111}, {207, 208}, {210, 211}, {309, 310}, {310, 311}}, {0}},
  };
  for (int batch = 0; batch < num_batches; ++batch) {
    EXPECT_TRUE(expected_plan[batch].retired_batches == plan[batch].retired_batches);
    EXPECT_TRUE(expected_plan[batch].events.size() == plan[batch].events.size());
    for (size_t evt_id = 0; evt_id < expected_plan[batch].events.size(); ++evt_id) {
      EXPECT_TRUE(expected_plan[batch].events[evt_id] == plan[batch].events[evt_id]);
    }
  }

  struct BatchContext {
    PipelineData data;
    std::vector<std::thread> workers;
  };
  std::unordered_map<int64_t, std::shared_ptr<BatchContext>> batch_ctx_pool;
  for (int batch_id = 0; batch_id < num_batches; ++batch_id) {
    std::vector<float> x(784);
    std::vector<float> label(10);
    std::shared_ptr<BatchContext> batch_ctx;
    bool reuse_batch_ctx = false;
    if (!plan[batch_id].retired_batches.empty()) {
      auto iter = batch_ctx_pool.find(plan[batch_id].retired_batches[0]);
      if (iter != batch_ctx_pool.end()) {
        batch_ctx = iter->second;
        // clean up retired batch, and reclaim data for reuse
        for (auto& w : batch_ctx->workers) {
          w.join();
        }
        batch_ctx->workers.resize(0);
        batch_ctx_pool.erase(plan[batch_id].retired_batches[0]);
        reuse_batch_ctx = true;
      }
    }
    if (!reuse_batch_ctx) {
      batch_ctx = std::make_shared<BatchContext>();
    }

    // set inputs
    batch_ctx->data.SetInputs(x, label);
    batch_ctx->data.SetEvents({batch_id * 4, batch_id * 4 + 1, batch_id * 4 + 2, batch_id * 4 + 3}, plan[batch_id].events);

    // create one worker thread for each batch and each pipeline stage
    for (size_t sub_id = 0; sub_id < num_subs; ++sub_id) {
      auto* pd = &(batch_ctx->data);
      batch_ctx->workers.emplace_back([&worker, pd, sub_id]() {
        worker(sub_id, *pd);
      });
    }
    batch_ctx_pool.emplace(batch_id, batch_ctx);
  }

  // wait until all workers done
  for (auto& pair : batch_ctx_pool) {
    for (auto& w : pair.second->workers) {
      w.join();
    }
  }

  // finish profiler
  for (size_t sub_id = 0; sub_id < num_subs; ++sub_id) {
    subs[sub_id].sess->EndProfiling();
  }
}

}  // namespace test
}  // namespace onnxruntime
",16235,False,2412.3411463778825,median
"/*
 * Copyright (C) 2008, 2009 Apple Inc. 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.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``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 APPLE INC. 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. 
 */

#include ""config.h""

#if ENABLE(JIT)
#if USE(JSVALUE32_64)
#include ""JIT.h""

#include ""CodeBlock.h""
#include ""GCAwareJITStubRoutine.h""
#include ""Interpreter.h""
#include ""JITInlines.h""
#include ""JITStubCall.h""
#include ""JSArray.h""
#include ""JSFunction.h""
#include ""JSPropertyNameIterator.h""
#include ""JSVariableObject.h""
#include ""LinkBuffer.h""
#include ""RepatchBuffer.h""
#include ""ResultType.h""
#include ""SamplingTool.h""
#include <wtf/StringPrintStream.h>

#ifndef NDEBUG
#include <stdio.h>
#endif

using namespace std;

namespace JSC {
    
void JIT::emit_op_put_by_index(Instruction* currentInstruction)
{
    unsigned base = currentInstruction[1].u.operand;
    unsigned property = currentInstruction[2].u.operand;
    unsigned value = currentInstruction[3].u.operand;
    
    JITStubCall stubCall(this, cti_op_put_by_index);
    stubCall.addArgument(base);
    stubCall.addArgument(TrustedImm32(property));
    stubCall.addArgument(value);
    stubCall.call();
}

void JIT::emit_op_put_getter_setter(Instruction* currentInstruction)
{
    unsigned base = currentInstruction[1].u.operand;
    unsigned property = currentInstruction[2].u.operand;
    unsigned getter = currentInstruction[3].u.operand;
    unsigned setter = currentInstruction[4].u.operand;
    
    JITStubCall stubCall(this, cti_op_put_getter_setter);
    stubCall.addArgument(base);
    stubCall.addArgument(TrustedImmPtr(&m_codeBlock->identifier(property)));
    stubCall.addArgument(getter);
    stubCall.addArgument(setter);
    stubCall.call();
}

void JIT::emit_op_del_by_id(Instruction* currentInstruction)
{
    unsigned dst = currentInstruction[1].u.operand;
    unsigned base = currentInstruction[2].u.operand;
    unsigned property = currentInstruction[3].u.operand;
    
    JITStubCall stubCall(this, cti_op_del_by_id);
    stubCall.addArgument(base);
    stubCall.addArgument(TrustedImmPtr(&m_codeBlock->identifier(property)));
    stubCall.call(dst);
}

JIT::CodeRef JIT::stringGetByValStubGenerator(VM* vm)
{
    JSInterfaceJIT jit;
    JumpList failures;
    failures.append(jit.branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), TrustedImmPtr(vm->stringStructure.get())));
    
    // Load string length to regT1, and start the process of loading the data pointer into regT0
    jit.load32(Address(regT0, ThunkHelpers::jsStringLengthOffset()), regT1);
    jit.loadPtr(Address(regT0, ThunkHelpers::jsStringValueOffset()), regT0);
    failures.append(jit.branchTest32(Zero, regT0));
    
    // Do an unsigned compare to simultaneously filter negative indices as well as indices that are too large
    failures.append(jit.branch32(AboveOrEqual, regT2, regT1));
    
    // Load the character
    JumpList is16Bit;
    JumpList cont8Bit;
    // Load the string flags
    jit.loadPtr(Address(regT0, StringImpl::flagsOffset()), regT1);
    jit.loadPtr(Address(regT0, StringImpl::dataOffset()), regT0);
    is16Bit.append(jit.branchTest32(Zero, regT1, TrustedImm32(StringImpl::flagIs8Bit())));
    jit.load8(BaseIndex(regT0, regT2, TimesOne, 0), regT0);
    cont8Bit.append(jit.jump());
    is16Bit.link(&jit);
    jit.load16(BaseIndex(regT0, regT2, TimesTwo, 0), regT0);

    cont8Bit.link(&jit);
    
    failures.append(jit.branch32(AboveOrEqual, regT0, TrustedImm32(0x100)));
    jit.move(TrustedImmPtr(vm->smallStrings.singleCharacterStrings()), regT1);
    jit.loadPtr(BaseIndex(regT1, regT0, ScalePtr, 0), regT0);
    jit.move(TrustedImm32(JSValue::CellTag), regT1); // We null check regT0 on return so this is safe
    jit.ret();

    failures.link(&jit);
    jit.move(TrustedImm32(0), regT0);
    jit.ret();
    
    LinkBuffer patchBuffer(*vm, &jit, GLOBAL_THUNK_ID);
    return FINALIZE_CODE(patchBuffer, (""String get_by_val stub""));
}

void JIT::emit_op_get_by_val(Instruction* currentInstruction)
{
    unsigned dst = currentInstruction[1].u.operand;
    unsigned base = currentInstruction[2].u.operand;
    unsigned property = currentInstruction[3].u.operand;
    ArrayProfile* profile = currentInstruction[4].u.arrayProfile;
    
    emitLoad2(base, regT1, regT0, property, regT3, regT2);
    
    addSlowCase(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
    emitJumpSlowCaseIfNotJSCell(base, regT1);
    loadPtr(Address(regT0, JSCell::structureOffset()), regT1);
    emitArrayProfilingSite(regT1, regT3, profile);
    and32(TrustedImm32(IndexingShapeMask), regT1);

    PatchableJump badType;
    JumpList slowCases;
    
    JITArrayMode mode = chooseArrayMode(profile);
    switch (mode) {
    case JITInt32:
        slowCases = emitInt32GetByVal(currentInstruction, badType);
        break;
    case JITDouble:
        slowCases = emitDoubleGetByVal(currentInstruction, badType);
        break;
    case JITContiguous:
        slowCases = emitContiguousGetByVal(currentInstruction, badType);
        break;
    case JITArrayStorage:
        slowCases = emitArrayStorageGetByVal(currentInstruction, badType);
        break;
    default:
        CRASH();
    }
    
    addSlowCase(badType);
    addSlowCase(slowCases);
    
    Label done = label();

#if !ASSERT_DISABLED
    Jump resultOK = branch32(NotEqual, regT1, TrustedImm32(JSValue::EmptyValueTag));
    breakpoint();
    resultOK.link(this);
#endif

    emitValueProfilingSite();
    emitStore(dst, regT1, regT0);
    map(m_bytecodeOffset + OPCODE_LENGTH(op_get_by_val), dst, regT1, regT0);
    
    m_byValCompilationInfo.append(ByValCompilationInfo(m_bytecodeOffset, badType, mode, done));
}

JIT::JumpList JIT::emitContiguousGetByVal(Instruction*, PatchableJump& badType, IndexingType expectedShape)
{
    JumpList slowCases;
    
    badType = patchableBranch32(NotEqual, regT1, TrustedImm32(expectedShape));
    
    loadPtr(Address(regT0, JSObject::butterflyOffset()), regT3);
    slowCases.append(branch32(AboveOrEqual, regT2, Address(regT3, Butterfly::offsetOfPublicLength())));
    
    load32(BaseIndex(regT3, regT2, TimesEight, OBJECT_OFFSETOF(JSValue, u.asBits.tag)), regT1); // tag
    load32(BaseIndex(regT3, regT2, TimesEight, OBJECT_OFFSETOF(JSValue, u.asBits.payload)), regT0); // payload
    slowCases.append(branch32(Equal, regT1, TrustedImm32(JSValue::EmptyValueTag)));
    
    return slowCases;
}

JIT::JumpList JIT::emitDoubleGetByVal(Instruction*, PatchableJump& badType)
{
    JumpList slowCases;
    
    badType = patchableBranch32(NotEqual, regT1, TrustedImm32(DoubleShape));
    
    loadPtr(Address(regT0, JSObject::butterflyOffset()), regT3);
    slowCases.append(branch32(AboveOrEqual, regT2, Address(regT3, Butterfly::offsetOfPublicLength())));
    
    loadDouble(BaseIndex(regT3, regT2, TimesEight), fpRegT0);
    slowCases.append(branchDouble(DoubleNotEqualOrUnordered, fpRegT0, fpRegT0));
    moveDoubleToInts(fpRegT0, regT0, regT1);
    
    return slowCases;
}

JIT::JumpList JIT::emitArrayStorageGetByVal(Instruction*, PatchableJump& badType)
{
    JumpList slowCases;
    
    add32(TrustedImm32(-ArrayStorageShape), regT1, regT3);
    badType = patchableBranch32(Above, regT3, TrustedImm32(SlowPutArrayStorageShape - ArrayStorageShape));
    
    loadPtr(Address(regT0, JSObject::butterflyOffset()), regT3);
    slowCases.append(branch32(AboveOrEqual, regT2, Address(regT3, ArrayStorage::vectorLengthOffset())));
    
    load32(BaseIndex(regT3, regT2, TimesEight, OBJECT_OFFSETOF(ArrayStorage, m_vector[0]) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), regT1); // tag
    load32(BaseIndex(regT3, regT2, TimesEight, OBJECT_OFFSETOF(ArrayStorage, m_vector[0]) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)), regT0); // payload
    slowCases.append(branch32(Equal, regT1, TrustedImm32(JSValue::EmptyValueTag)));
    
    return slowCases;
}
    
void JIT::emitSlow_op_get_by_val(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
{
    unsigned dst = currentInstruction[1].u.operand;
    unsigned base = currentInstruction[2].u.operand;
    unsigned property = currentInstruction[3].u.operand;
    ArrayProfile* profile = currentInstruction[4].u.arrayProfile;
    
    linkSlowCase(iter); // property int32 check
    linkSlowCaseIfNotJSCell(iter, base); // base cell check

    Jump nonCell = jump();
    linkSlowCase(iter); // base array check
    Jump notString = branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), TrustedImmPtr(m_vm->stringStructure.get()));
    emitNakedCall(m_vm->getCTIStub(stringGetByValStubGenerator).code());
    Jump failed = branchTestPtr(Zero, regT0);
    emitStore(dst, regT1, regT0);
    emitJumpSlowToHot(jump(), OPCODE_LENGTH(op_get_by_val));
    failed.link(this);
    notString.link(this);
    nonCell.link(this);
    
    Jump skipProfiling = jump();

    linkSlowCase(iter); // vector length check
    linkSlowCase(iter); // empty value
    
    emitArrayProfileOutOfBoundsSpecialCase(profile);
    
    skipProfiling.link(this);
    
    Label slowPath = label();
    
    JITStubCall stubCall(this, cti_op_get_by_val);
    stubCall.addArgument(base);
    stubCall.addArgument(property);
    Call call = stubCall.call(dst);

    m_byValCompilationInfo[m_byValInstructionIndex].slowPathTarget = slowPath;
    m_byValCompilationInfo[m_byValInstructionIndex].returnAddress = call;
    m_byValInstructionIndex++;

    emitValueProfilingSite();
}

void JIT::emit_op_put_by_val(Instruction* currentInstruction)
{
    unsigned base = currentInstruction[1].u.operand;
    unsigned property = currentInstruction[2].u.operand;
    ArrayProfile* profile = currentInstruction[4].u.arrayProfile;
    
    emitLoad2(base, regT1, regT0, property, regT3, regT2);
    
    addSlowCase(branch32(NotEqual, regT3, TrustedImm32(JSValue::Int32Tag)));
    emitJumpSlowCaseIfNotJSCell(base, regT1);
    loadPtr(Address(regT0, JSCell::structureOffset()), regT1);
    emitArrayProfilingSite(regT1, regT3, profile);
    and32(TrustedImm32(IndexingShapeMask), regT1);
    
    PatchableJump badType;
    JumpList slowCases;
    
    JITArrayMode mode = chooseArrayMode(profile);
    switch (mode) {
    case JITInt32:
        slowCases = emitInt32PutByVal(currentInstruction, badType);
        break;
    case JITDouble:
        slowCases = emitDoublePutByVal(currentInstruction, badType);
        break;
    case JITContiguous:
        slowCases = emitContiguousPutByVal(currentInstruction, badType);
        break;
    case JITArrayStorage:
        slowCases = emitArrayStoragePutByVal(currentInstruction, badType);
        break;
    default:
        CRASH();
        break;
    }
    
    addSlowCase(badType);
    addSlowCase(slowCases);
    
    Label done = label();
    
    m_byValCompilationInfo.append(ByValCompilationInfo(m_bytecodeOffset, badType, mode, done));
}

JIT::JumpList JIT::emitGenericContiguousPutByVal(Instruction* currentInstruction, PatchableJump& badType, IndexingType indexingShape)
{
    unsigned value = currentInstruction[3].u.operand;
    ArrayProfile* profile = currentInstruction[4].u.arrayProfile;
    
    JumpList slowCases;
    
    badType = patchableBranch32(NotEqual, regT1, TrustedImm32(ContiguousShape));
    
    loadPtr(Address(regT0, JSObject::butterflyOffset()), regT3);
    Jump outOfBounds = branch32(AboveOrEqual, regT2, Address(regT3, Butterfly::offsetOfPublicLength()));
    
    Label storeResult = label();
    emitLoad(value, regT1, regT0);
    switch (indexingShape) {
    case Int32Shape:
        slowCases.append(branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag)));
        // Fall through.
    case ContiguousShape:
        store32(regT0, BaseIndex(regT3, regT2, TimesEight, OBJECT_OFFSETOF(JSValue, u.asBits.payload)));
        store32(regT1, BaseIndex(regT3, regT2, TimesEight, OBJECT_OFFSETOF(JSValue, u.asBits.tag)));
        break;
    case DoubleShape: {
        Jump notInt = branch32(NotEqual, regT1, TrustedImm32(JSValue::Int32Tag));
        convertInt32ToDouble(regT0, fpRegT0);
        Jump ready = jump();
        notInt.link(this);
        moveIntsToDouble(regT0, regT1, fpRegT0, fpRegT1);
        slowCases.append(branchDouble(DoubleNotEqualOrUnordered, fpRegT0, fpRegT0));
        ready.link(this);
        storeDouble(fpRegT0, BaseIndex(regT3, regT2, TimesEight));
        break;
    }
    default:
        CRASH();
        break;
    }
        
    Jump done = jump();
    
    outOfBounds.link(this);
    slowCases.append(branch32(AboveOrEqual, regT2, Address(regT3, Butterfly::offsetOfVectorLength())));
    
    emitArrayProfileStoreToHoleSpecialCase(profile);
    
    add32(TrustedImm32(1), regT2, regT1);
    store32(regT1, Address(regT3, Butterfly::offsetOfPublicLength()));
    jump().linkTo(storeResult, this);
    
    done.link(this);
    
    emitWriteBarrier(regT0, regT1, regT1, regT3, UnconditionalWriteBarrier, WriteBarrierForPropertyAccess);
    
    return slowCases;
}

JIT::JumpList JIT::emitArrayStoragePutByVal(Instruction* currentInstruction, PatchableJump& badType)
{
    unsigned value = currentInstruction[3].u.operand;
    ArrayProfile* profile = currentInstruction[4].u.arrayProfile;
    
    JumpList slowCases;
    
    badType = patchableBranch32(NotEqual, regT1, TrustedImm32(ArrayStorageShape));
    
    loadPtr(Address(regT0, JSObject::butterflyOffset()), regT3);
    slowCases.append(branch32(AboveOrEqual, regT2, Address(regT3, ArrayStorage::vectorLengthOffset())));

    Jump empty = branch32(Equal, BaseIndex(regT3, regT2, TimesEight, OBJECT_OFFSETOF(ArrayStorage, m_vector[0]) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), TrustedImm32(JSValue::EmptyValueTag));
    
    Label storeResult(this);
    emitLoad(value, regT1, regT0);
    store32(regT0, BaseIndex(regT3, regT2, TimesEight, OBJECT_OFFSETOF(ArrayStorage, m_vector[0]) + OBJECT_OFFSETOF(JSValue, u.asBits.payload))); // payload
    store32(regT1, BaseIndex(regT3, regT2, TimesEight, OBJECT_OFFSETOF(ArrayStorage, m_vector[0]) + OBJECT_OFFSETOF(JSValue, u.asBits.tag))); // tag
    Jump end = jump();
    
    empty.link(this);
    emitArrayProfileStoreToHoleSpecialCase(profile);
    add32(TrustedImm32(1), Address(regT3, OBJECT_OFFSETOF(ArrayStorage, m_numValuesInVector)));
    branch32(Below, regT2, Address(regT3, ArrayStorage::lengthOffset())).linkTo(storeResult, this);
    
    add32(TrustedImm32(1), regT2, regT0);
    store32(regT0, Address(regT3, ArrayStorage::lengthOffset()));
    jump().linkTo(storeResult, this);
    
    end.link(this);
    
    emitWriteBarrier(regT0, regT1, regT1, regT3, UnconditionalWriteBarrier, WriteBarrierForPropertyAccess);
    
    return slowCases;
}

void JIT::emitSlow_op_put_by_val(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
{
    unsigned base = currentInstruction[1].u.operand;
    unsigned property = currentInstruction[2].u.operand;
    unsigned value = currentInstruction[3].u.operand;
    ArrayProfile* profile = currentInstruction[4].u.arrayProfile;
    
    linkSlowCase(iter); // property int32 check
    linkSlowCaseIfNotJSCell(iter, base); // base cell check
    linkSlowCase(iter); // base not array check
    
    JITArrayMode mode = chooseArrayMode(profile);
    switch (mode) {
    case JITInt32:
    case JITDouble:
        linkSlowCase(iter); // value type check
        break;
    default:
        break;
    }
    
    Jump skipProfiling = jump();
    linkSlowCase(iter); // out of bounds
    emitArrayProfileOutOfBoundsSpecialCase(profile);
    skipProfiling.link(this);

    Label slowPath = label();
    
    JITStubCall stubPutByValCall(this, cti_op_put_by_val);
    stubPutByValCall.addArgument(base);
    stubPutByValCall.addArgument(property);
    stubPutByValCall.addArgument(value);
    Call call = stubPutByValCall.call();
    
    m_byValCompilationInfo[m_byValInstructionIndex].slowPathTarget = slowPath;
    m_byValCompilationInfo[m_byValInstructionIndex].returnAddress = call;
    m_byValInstructionIndex++;
}

void JIT::emit_op_get_by_id(Instruction* currentInstruction)
{
    int dst = currentInstruction[1].u.operand;
    int base = currentInstruction[2].u.operand;
    Identifier* ident = &(m_codeBlock->identifier(currentInstruction[3].u.operand));
    
    emitLoad(base, regT1, regT0);
    emitJumpSlowCaseIfNotJSCell(base, regT1);
    compileGetByIdHotPath(ident);
    emitValueProfilingSite();
    emitStore(dst, regT1, regT0);
    map(m_bytecodeOffset + OPCODE_LENGTH(op_get_by_id), dst, regT1, regT0);
}

void JIT::compileGetByIdHotPath(Identifier* ident)
{
    // As for put_by_id, get_by_id requires the offset of the Structure and the offset of the access to be patched.
    // Additionally, for get_by_id we need patch the offset of the branch to the slow case (we patch this to jump
    // to array-length / prototype access tranpolines, and finally we also the the property-map access offset as a label
    // to jump back to if one of these trampolies finds a match.
    
    if (*ident == m_vm->propertyNames->length && shouldEmitProfiling()) {
        loadPtr(Address(regT0, JSCell::structureOffset()), regT2);
        emitArrayProfilingSiteForBytecodeIndex(regT2, regT3, m_bytecodeOffset);
    }

    BEGIN_UNINTERRUPTED_SEQUENCE(sequenceGetByIdHotPath);
    
    Label hotPathBegin(this);
    
    DataLabelPtr structureToCompare;
    PatchableJump structureCheck = patchableBranchPtrWithPatch(NotEqual, Address(regT0, JSCell::structureOffset()), structureToCompare, TrustedImmPtr(reinterpret_cast<void*>(patchGetByIdDefaultStructure)));
    addSlowCase(structureCheck);
    
    ConvertibleLoadLabel propertyStorageLoad = convertibleLoadPtr(Address(regT0, JSObject::butterflyOffset()), regT2);
    DataLabelCompact displacementLabel1 = loadPtrWithCompactAddressOffsetPatch(Address(regT2, patchGetByIdDefaultOffset), regT0); // payload
    DataLabelCompact displacementLabel2 = loadPtrWithCompactAddressOffsetPatch(Address(regT2, patchGetByIdDefaultOffset), regT1); // tag
    
    Label putResult(this);
    
    END_UNINTERRUPTED_SEQUENCE(sequenceGetByIdHotPath);

    m_propertyAccessCompilationInfo.append(PropertyStubCompilationInfo(PropertyStubGetById, m_bytecodeOffset, hotPathBegin, structureToCompare, structureCheck, propertyStorageLoad, displacementLabel1, displacementLabel2, putResult));
}

void JIT::emitSlow_op_get_by_id(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
{
    int dst = currentInstruction[1].u.operand;
    int base = currentInstruction[2].u.operand;
    int ident = currentInstruction[3].u.operand;
    
    compileGetByIdSlowCase(dst, base, &(m_codeBlock->identifier(ident)), iter);
    emitValueProfilingSite();
}

void JIT::compileGetByIdSlowCase(int dst, int base, Identifier* ident, Vector<SlowCaseEntry>::iterator& iter)
{
    // As for the hot path of get_by_id, above, we ensure that we can use an architecture specific offset
    // so that we only need track one pointer into the slow case code - we track a pointer to the location
    // of the call (which we can use to look up the patch information), but should a array-length or
    // prototype access trampoline fail we want to bail out back to here.  To do so we can subtract back
    // the distance from the call to the head of the slow case.
    linkSlowCaseIfNotJSCell(iter, base);
    linkSlowCase(iter);
    
    BEGIN_UNINTERRUPTED_SEQUENCE(sequenceGetByIdSlowCase);
    
    Label coldPathBegin(this);
    JITStubCall stubCall(this, cti_op_get_by_id);
    stubCall.addArgument(regT1, regT0);
    stubCall.addArgument(TrustedImmPtr(ident));
    Call call = stubCall.call(dst);
    
    END_UNINTERRUPTED_SEQUENCE_FOR_PUT(sequenceGetByIdSlowCase, dst);
    
    // Track the location of the call; this will be used to recover patch information.
    m_propertyAccessCompilationInfo[m_propertyAccessInstructionIndex++].slowCaseInfo(PropertyStubGetById, coldPathBegin, call);
}

void JIT::emit_op_put_by_id(Instruction* currentInstruction)
{
    // In order to be able to patch both the Structure, and the object offset, we store one pointer,
    // to just after the arguments have been loaded into registers 'hotPathBegin', and we generate code
    // such that the Structure & offset are always at the same distance from this.
    
    int base = currentInstruction[1].u.operand;
    int value = currentInstruction[3].u.operand;
    
    emitLoad2(base, regT1, regT0, value, regT3, regT2);
    
    emitJumpSlowCaseIfNotJSCell(base, regT1);
    
    BEGIN_UNINTERRUPTED_SEQUENCE(sequencePutById);
    
    Label hotPathBegin(this);
    
    // It is important that the following instruction plants a 32bit immediate, in order that it can be patched over.
    DataLabelPtr structureToCompare;
    addSlowCase(branchPtrWithPatch(NotEqual, Address(regT0, JSCell::structureOffset()), structureToCompare, TrustedImmPtr(reinterpret_cast<void*>(patchGetByIdDefaultStructure))));
    
    ConvertibleLoadLabel propertyStorageLoad = convertibleLoadPtr(Address(regT0, JSObject::butterflyOffset()), regT1);
    DataLabel32 displacementLabel1 = storePtrWithAddressOffsetPatch(regT2, Address(regT1, patchPutByIdDefaultOffset)); // payload
    DataLabel32 displacementLabel2 = storePtrWithAddressOffsetPatch(regT3, Address(regT1, patchPutByIdDefaultOffset)); // tag
    
    END_UNINTERRUPTED_SEQUENCE(sequencePutById);

    emitWriteBarrier(regT0, regT2, regT1, regT2, ShouldFilterImmediates, WriteBarrierForPropertyAccess);

    m_propertyAccessCompilationInfo.append(PropertyStubCompilationInfo(PropertyStubPutById, m_bytecodeOffset, hotPathBegin, structureToCompare, propertyStorageLoad, displacementLabel1, displacementLabel2));
}

void JIT::emitSlow_op_put_by_id(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
{
    int base = currentInstruction[1].u.operand;
    int ident = currentInstruction[2].u.operand;
    int direct = currentInstruction[8].u.operand;

    linkSlowCaseIfNotJSCell(iter, base);
    linkSlowCase(iter);
    
    JITStubCall stubCall(this, direct ? cti_op_put_by_id_direct : cti_op_put_by_id);
    stubCall.addArgument(base);
    stubCall.addArgument(TrustedImmPtr(&(m_codeBlock->identifier(ident))));
    stubCall.addArgument(regT3, regT2); 
    Call call = stubCall.call();
    
    // Track the location of the call; this will be used to recover patch information.
    m_propertyAccessCompilationInfo[m_propertyAccessInstructionIndex++].slowCaseInfo(PropertyStubPutById, call);
}

// Compile a store into an object's property storage.  May overwrite base.
void JIT::compilePutDirectOffset(RegisterID base, RegisterID valueTag, RegisterID valuePayload, PropertyOffset cachedOffset)
{
    if (isOutOfLineOffset(cachedOffset))
        loadPtr(Address(base, JSObject::butterflyOffset()), base);
    emitStore(indexRelativeToBase(cachedOffset), valueTag, valuePayload, base);
}

// Compile a load from an object's property storage.  May overwrite base.
void JIT::compileGetDirectOffset(RegisterID base, RegisterID resultTag, RegisterID resultPayload, PropertyOffset cachedOffset)
{
    if (isInlineOffset(cachedOffset)) {
        emitLoad(indexRelativeToBase(cachedOffset), resultTag, resultPayload, base);
        return;
    }
    
    RegisterID temp = resultPayload;
    loadPtr(Address(base, JSObject::butterflyOffset()), temp);
    emitLoad(indexRelativeToBase(cachedOffset), resultTag, resultPayload, temp);
}

void JIT::compileGetDirectOffset(JSObject* base, RegisterID resultTag, RegisterID resultPayload, PropertyOffset cachedOffset)
{
    if (isInlineOffset(cachedOffset)) {
        move(TrustedImmPtr(base->locationForOffset(cachedOffset)), resultTag);
        load32(Address(resultTag, OBJECT_OFFSETOF(JSValue, u.asBits.payload)), resultPayload);
        load32(Address(resultTag, OBJECT_OFFSETOF(JSValue, u.asBits.tag)), resultTag);
        return;
    }
    
    loadPtr(base->butterflyAddress(), resultTag);
    load32(Address(resultTag, offsetInButterfly(cachedOffset) * sizeof(WriteBarrier<Unknown>) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)), resultPayload);
    load32(Address(resultTag, offsetInButterfly(cachedOffset) * sizeof(WriteBarrier<Unknown>) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), resultTag);
}

void JIT::privateCompilePutByIdTransition(StructureStubInfo* stubInfo, Structure* oldStructure, Structure* newStructure, PropertyOffset cachedOffset, StructureChain* chain, ReturnAddressPtr returnAddress, bool direct)
{
    // The code below assumes that regT0 contains the basePayload and regT1 contains the baseTag. Restore them from the stack.
#if CPU(MIPS) || CPU(SH4) || CPU(ARM)
    // For MIPS, we don't add sizeof(void*) to the stack offset.
    load32(Address(stackPointerRegister, OBJECT_OFFSETOF(JITStackFrame, args[0]) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)), regT0);
    // For MIPS, we don't add sizeof(void*) to the stack offset.
    load32(Address(stackPointerRegister, OBJECT_OFFSETOF(JITStackFrame, args[0]) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), regT1);
#else
    load32(Address(stackPointerRegister, OBJECT_OFFSETOF(JITStackFrame, args[0]) + sizeof(void*) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)), regT0);
    load32(Address(stackPointerRegister, OBJECT_OFFSETOF(JITStackFrame, args[0]) + sizeof(void*) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), regT1);
#endif

    JumpList failureCases;
    failureCases.append(branch32(NotEqual, regT1, TrustedImm32(JSValue::CellTag)));
    failureCases.append(branchPtr(NotEqual, Address(regT0, JSCell::structureOffset()), TrustedImmPtr(oldStructure)));
    testPrototype(oldStructure->storedPrototype(), failureCases, stubInfo);
    
    if (!direct) {
        // Verify that nothing in the prototype chain has a setter for this property. 
        for (WriteBarrier<Structure>* it = chain->head(); *it; ++it)
            testPrototype((*it)->storedPrototype(), failureCases, stubInfo);
    }

    // If we succeed in all of our checks, and the code was optimizable, then make sure we
    // decrement the rare case counter.
#if ENABLE(VALUE_PROFILER)
    if (m_codeBlock->canCompileWithDFG() >= DFG::MayInline) {
        sub32(
            TrustedImm32(1),
            AbsoluteAddress(&m_codeBlock->rareCaseProfileForBytecodeOffset(stubInfo->bytecodeIndex)->m_counter));
    }
#endif
    
    // Reallocate property storage if needed.
    Call callTarget;
    bool willNeedStorageRealloc = oldStructure->outOfLineCapacity() != newStructure->outOfLineCapacity();
    if (willNeedStorageRealloc) {
        // This trampoline was called to like a JIT stub; before we can can call again we need to
        // remove the return address from the stack, to prevent the stack from becoming misaligned.
        preserveReturnAddressAfterCall(regT3);
        
        JITStubCall stubCall(this, cti_op_put_by_id_transition_realloc);
        stubCall.skipArgument(); // base
        stubCall.skipArgument(); // ident
        stubCall.skipArgument(); // value
        stubCall.addArgument(TrustedImm32(oldStructure->outOfLineCapacity()));
        stubCall.addArgument(TrustedImmPtr(newStructure));
        stubCall.call(regT0);

        restoreReturnAddressBeforeReturn(regT3);

#if CPU(MIPS) || CPU(SH4) || CPU(ARM)
        // For MIPS, we don't add sizeof(void*) to the stack offset.
        load32(Address(stackPointerRegister, OBJECT_OFFSETOF(JITStackFrame, args[0]) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)), regT0);
        // For MIPS, we don't add sizeof(void*) to the stack offset.
        load32(Address(stackPointerRegister, OBJECT_OFFSETOF(JITStackFrame, args[0]) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), regT1);
#else
        load32(Address(stackPointerRegister, OBJECT_OFFSETOF(JITStackFrame, args[0]) + sizeof(void*) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)), regT0);
        load32(Address(stackPointerRegister, OBJECT_OFFSETOF(JITStackFrame, args[0]) + sizeof(void*) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), regT1);
#endif
    }

    emitWriteBarrier(regT0, regT1, regT1, regT3, UnconditionalWriteBarrier, WriteBarrierForPropertyAccess);

    storePtr(TrustedImmPtr(newStructure), Address(regT0, JSCell::structureOffset()));
#if CPU(MIPS) || CPU(SH4) || CPU(ARM)
    // For MIPS, we don't add sizeof(void*) to the stack offset.
    load32(Address(stackPointerRegister, OBJECT_OFFSETOF(JITStackFrame, args[2]) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)), regT3);
    load32(Address(stackPointerRegister, OBJECT_OFFSETOF(JITStackFrame, args[2]) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), regT2);
#else
    load32(Address(stackPointerRegister, OBJECT_OFFSETOF(JITStackFrame, args[2]) + sizeof(void*) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)), regT3);
    load32(Address(stackPointerRegister, OBJECT_OFFSETOF(JITStackFrame, args[2]) + sizeof(void*) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)), regT2);
#endif
    compilePutDirectOffset(regT0, regT2, regT3, cachedOffset);
    
    ret();
    
    ASSERT(!failureCases.empty());
    failureCases.link(this);
    restoreArgumentReferenceForTrampoline();
    Call failureCall = tailRecursiveCall();
    
    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
    
    patchBuffer.link(failureCall, FunctionPtr(direct ? cti_op_put_by_id_direct_fail : cti_op_put_by_id_fail));
    
    if (willNeedStorageRealloc) {
        ASSERT(m_calls.size() == 1);
        patchBuffer.link(m_calls[0].from, FunctionPtr(cti_op_put_by_id_transition_realloc));
    }
    
    stubInfo->stubRoutine = createJITStubRoutine(
        FINALIZE_CODE(
            patchBuffer,
            (""Baseline put_by_id transition stub for %s, return point %p"",
                toCString(*m_codeBlock).data(), returnAddress.value())),
        *m_vm,
        m_codeBlock->ownerExecutable(),
        willNeedStorageRealloc,
        newStructure);
    RepatchBuffer repatchBuffer(m_codeBlock);
    repatchBuffer.relinkCallerToTrampoline(returnAddress, CodeLocationLabel(stubInfo->stubRoutine->code().code()));
}

void JIT::patchGetByIdSelf(CodeBlock* codeBlock, StructureStubInfo* stubInfo, Structure* structure, PropertyOffset cachedOffset, ReturnAddressPtr returnAddress)
{
    RepatchBuffer repatchBuffer(codeBlock);
    
    // We don't want to patch more than once - in future go to cti_op_get_by_id_generic.
    // Should probably go to JITStubs::cti_op_get_by_id_fail, but that doesn't do anything interesting right now.
    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(cti_op_get_by_id_self_fail));
    
    // Patch the offset into the propoerty map to load from, then patch the Structure to look for.
    repatchBuffer.repatch(stubInfo->hotPathBegin.dataLabelPtrAtOffset(stubInfo->patch.baseline.u.get.structureToCompare), structure);
    repatchBuffer.setLoadInstructionIsActive(stubInfo->hotPathBegin.convertibleLoadAtOffset(stubInfo->patch.baseline.u.get.propertyStorageLoad), isOutOfLineOffset(cachedOffset));
    repatchBuffer.repatch(stubInfo->hotPathBegin.dataLabelCompactAtOffset(stubInfo->patch.baseline.u.get.displacementLabel1), offsetRelativeToPatchedStorage(cachedOffset) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)); // payload
    repatchBuffer.repatch(stubInfo->hotPathBegin.dataLabelCompactAtOffset(stubInfo->patch.baseline.u.get.displacementLabel2), offsetRelativeToPatchedStorage(cachedOffset) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)); // tag
}

void JIT::patchPutByIdReplace(CodeBlock* codeBlock, StructureStubInfo* stubInfo, Structure* structure, PropertyOffset cachedOffset, ReturnAddressPtr returnAddress, bool direct)
{
    RepatchBuffer repatchBuffer(codeBlock);
    
    // We don't want to patch more than once - in future go to cti_op_put_by_id_generic.
    // Should probably go to cti_op_put_by_id_fail, but that doesn't do anything interesting right now.
    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(direct ? cti_op_put_by_id_direct_generic : cti_op_put_by_id_generic));
    
    // Patch the offset into the propoerty map to load from, then patch the Structure to look for.
    repatchBuffer.repatch(stubInfo->hotPathBegin.dataLabelPtrAtOffset(stubInfo->patch.baseline.u.put.structureToCompare), structure);
    repatchBuffer.setLoadInstructionIsActive(stubInfo->hotPathBegin.convertibleLoadAtOffset(stubInfo->patch.baseline.u.put.propertyStorageLoad), isOutOfLineOffset(cachedOffset));
    repatchBuffer.repatch(stubInfo->hotPathBegin.dataLabel32AtOffset(stubInfo->patch.baseline.u.put.displacementLabel1), offsetRelativeToPatchedStorage(cachedOffset) + OBJECT_OFFSETOF(JSValue, u.asBits.payload)); // payload
    repatchBuffer.repatch(stubInfo->hotPathBegin.dataLabel32AtOffset(stubInfo->patch.baseline.u.put.displacementLabel2), offsetRelativeToPatchedStorage(cachedOffset) + OBJECT_OFFSETOF(JSValue, u.asBits.tag)); // tag
}

void JIT::privateCompilePatchGetArrayLength(ReturnAddressPtr returnAddress)
{
    StructureStubInfo* stubInfo = &m_codeBlock->getStubInfo(returnAddress);
    
    // regT0 holds a JSCell*
    
    // Check for array
    loadPtr(Address(regT0, JSCell::structureOffset()), regT2);
    Jump failureCases1 = branchTest32(Zero, regT2, TrustedImm32(IsArray));
    Jump failureCases2 = branchTest32(Zero, regT2, TrustedImm32(IndexingShapeMask));
    
    // Checks out okay! - get the length from the storage
    loadPtr(Address(regT0, JSArray::butterflyOffset()), regT2);
    load32(Address(regT2, ArrayStorage::lengthOffset()), regT2);
    
    Jump failureCases3 = branch32(Above, regT2, TrustedImm32(INT_MAX));
    move(regT2, regT0);
    move(TrustedImm32(JSValue::Int32Tag), regT1);
    Jump success = jump();
    
    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
    
    // Use the patch information to link the failure cases back to the original slow case routine.
    CodeLocationLabel slowCaseBegin = stubInfo->callReturnLocation.labelAtOffset(-stubInfo->patch.baseline.u.get.coldPathBegin);
    patchBuffer.link(failureCases1, slowCaseBegin);
    patchBuffer.link(failureCases2, slowCaseBegin);
    patchBuffer.link(failureCases3, slowCaseBegin);
    
    // On success return back to the hot patch code, at a point it will perform the store to dest for us.
    patchBuffer.link(success, stubInfo->hotPathBegin.labelAtOffset(stubInfo->patch.baseline.u.get.putResult));
    
    // Track the stub we have created so that it will be deleted later.
    stubInfo->stubRoutine = FINALIZE_CODE_FOR_STUB(
        patchBuffer,
        (""Baseline get_by_id array length stub for %s, return point %p"",
            toCString(*m_codeBlock).data(), stubInfo->hotPathBegin.labelAtOffset(
                stubInfo->patch.baseline.u.get.putResult).executableAddress()));
    
    // Finally patch the jump to slow case back in the hot path to jump here instead.
    CodeLocationJump jumpLocation = stubInfo->hotPathBegin.jumpAtOffset(stubInfo->patch.baseline.u.get.structureCheck);
    RepatchBuffer repatchBuffer(m_codeBlock);
    repatchBuffer.relink(jumpLocation, CodeLocationLabel(stubInfo->stubRoutine->code().code()));
    
    // We don't want to patch more than once - in future go to cti_op_put_by_id_generic.
    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(cti_op_get_by_id_array_fail));
}

void JIT::privateCompileGetByIdProto(StructureStubInfo* stubInfo, Structure* structure, Structure* prototypeStructure, const Identifier& ident, const PropertySlot& slot, PropertyOffset cachedOffset, ReturnAddressPtr returnAddress, CallFrame* callFrame)
{
    // regT0 holds a JSCell*
    
    // The prototype object definitely exists (if this stub exists the CodeBlock is referencing a Structure that is
    // referencing the prototype object - let's speculatively load it's table nice and early!)
    JSObject* protoObject = asObject(structure->prototypeForLookup(callFrame));
    
    Jump failureCases1 = checkStructure(regT0, structure);
    
    // Check the prototype object's Structure had not changed.
    Jump failureCases2 = addStructureTransitionCheck(protoObject, prototypeStructure, stubInfo, regT3);

    bool needsStubLink = false;
    // Checks out okay!
    if (slot.cachedPropertyType() == PropertySlot::Getter) {
        needsStubLink = true;
        compileGetDirectOffset(protoObject, regT2, regT1, cachedOffset);
        JITStubCall stubCall(this, cti_op_get_by_id_getter_stub);
        stubCall.addArgument(regT1);
        stubCall.addArgument(regT0);
        stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
        stubCall.call();
    } else if (slot.cachedPropertyType() == PropertySlot::Custom) {
        needsStubLink = true;
        JITStubCall stubCall(this, cti_op_get_by_id_custom_stub);
        stubCall.addArgument(TrustedImmPtr(protoObject));
        stubCall.addArgument(TrustedImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
        stubCall.addArgument(TrustedImmPtr(const_cast<Identifier*>(&ident)));
        stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
        stubCall.call();
    } else
        compileGetDirectOffset(protoObject, regT1, regT0, cachedOffset);
    
    Jump success = jump();
    
    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
    
    // Use the patch information to link the failure cases back to the original slow case routine.
    CodeLocationLabel slowCaseBegin = stubInfo->callReturnLocation.labelAtOffset(-stubInfo->patch.baseline.u.get.coldPathBegin);
    patchBuffer.link(failureCases1, slowCaseBegin);
    if (failureCases2.isSet())
        patchBuffer.link(failureCases2, slowCaseBegin);
    
    // On success return back to the hot patch code, at a point it will perform the store to dest for us.
    patchBuffer.link(success, stubInfo->hotPathBegin.labelAtOffset(stubInfo->patch.baseline.u.get.putResult));

    if (needsStubLink) {
        for (Vector<CallRecord>::iterator iter = m_calls.begin(); iter != m_calls.end(); ++iter) {
            if (iter->to)
                patchBuffer.link(iter->from, FunctionPtr(iter->to));
        }
    }

    // Track the stub we have created so that it will be deleted later.
    stubInfo->stubRoutine = createJITStubRoutine(
        FINALIZE_CODE(
            patchBuffer,
            (""Baseline get_by_id proto stub for %s, return point %p"",
                toCString(*m_codeBlock).data(), stubInfo->hotPathBegin.labelAtOffset(
                    stubInfo->patch.baseline.u.get.putResult).executableAddress())),
        *m_vm,
        m_codeBlock->ownerExecutable(),
        needsStubLink);
    
    // Finally patch the jump to slow case back in the hot path to jump here instead.
    CodeLocationJump jumpLocation = stubInfo->hotPathBegin.jumpAtOffset(stubInfo->patch.baseline.u.get.structureCheck);
    RepatchBuffer repatchBuffer(m_codeBlock);
    repatchBuffer.relink(jumpLocation, CodeLocationLabel(stubInfo->stubRoutine->code().code()));
    
    // We don't want to patch more than once - in future go to cti_op_put_by_id_generic.
    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(cti_op_get_by_id_proto_list));
}


void JIT::privateCompileGetByIdSelfList(StructureStubInfo* stubInfo, PolymorphicAccessStructureList* polymorphicStructures, int currentIndex, Structure* structure, const Identifier& ident, const PropertySlot& slot, PropertyOffset cachedOffset)
{
    // regT0 holds a JSCell*
    Jump failureCase = checkStructure(regT0, structure);
    bool needsStubLink = false;
    bool isDirect = false;
    if (slot.cachedPropertyType() == PropertySlot::Getter) {
        needsStubLink = true;
        compileGetDirectOffset(regT0, regT2, regT1, cachedOffset);
        JITStubCall stubCall(this, cti_op_get_by_id_getter_stub);
        stubCall.addArgument(regT1);
        stubCall.addArgument(regT0);
        stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
        stubCall.call();
    } else if (slot.cachedPropertyType() == PropertySlot::Custom) {
        needsStubLink = true;
        JITStubCall stubCall(this, cti_op_get_by_id_custom_stub);
        stubCall.addArgument(regT0);
        stubCall.addArgument(TrustedImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
        stubCall.addArgument(TrustedImmPtr(const_cast<Identifier*>(&ident)));
        stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
        stubCall.call();
    } else {
        isDirect = true;
        compileGetDirectOffset(regT0, regT1, regT0, cachedOffset);
    }

    Jump success = jump();
    
    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
    if (needsStubLink) {
        for (Vector<CallRecord>::iterator iter = m_calls.begin(); iter != m_calls.end(); ++iter) {
            if (iter->to)
                patchBuffer.link(iter->from, FunctionPtr(iter->to));
        }
    }    
    // Use the patch information to link the failure cases back to the original slow case routine.
    CodeLocationLabel lastProtoBegin = CodeLocationLabel(JITStubRoutine::asCodePtr(polymorphicStructures->list[currentIndex - 1].stubRoutine));
    if (!lastProtoBegin)
        lastProtoBegin = stubInfo->callReturnLocation.labelAtOffset(-stubInfo->patch.baseline.u.get.coldPathBegin);
    
    patchBuffer.link(failureCase, lastProtoBegin);
    
    // On success return back to the hot patch code, at a point it will perform the store to dest for us.
    patchBuffer.link(success, stubInfo->hotPathBegin.labelAtOffset(stubInfo->patch.baseline.u.get.putResult));

    RefPtr<JITStubRoutine> stubRoutine = createJITStubRoutine(
        FINALIZE_CODE(
            patchBuffer,
            (""Baseline get_by_id self list stub for %s, return point %p"",
                toCString(*m_codeBlock).data(), stubInfo->hotPathBegin.labelAtOffset(
                    stubInfo->patch.baseline.u.get.putResult).executableAddress())),
        *m_vm,
        m_codeBlock->ownerExecutable(),
        needsStubLink);

    polymorphicStructures->list[currentIndex].set(*m_vm, m_codeBlock->ownerExecutable(), stubRoutine, structure, isDirect);
    
    // Finally patch the jump to slow case back in the hot path to jump here instead.
    CodeLocationJump jumpLocation = stubInfo->hotPathBegin.jumpAtOffset(stubInfo->patch.baseline.u.get.structureCheck);
    RepatchBuffer repatchBuffer(m_codeBlock);
    repatchBuffer.relink(jumpLocation, CodeLocationLabel(stubRoutine->code().code()));
}

void JIT::privateCompileGetByIdProtoList(StructureStubInfo* stubInfo, PolymorphicAccessStructureList* prototypeStructures, int currentIndex, Structure* structure, Structure* prototypeStructure, const Identifier& ident, const PropertySlot& slot, PropertyOffset cachedOffset, CallFrame* callFrame)
{
    // regT0 holds a JSCell*
    
    // The prototype object definitely exists (if this stub exists the CodeBlock is referencing a Structure that is
    // referencing the prototype object - let's speculatively load it's table nice and early!)
    JSObject* protoObject = asObject(structure->prototypeForLookup(callFrame));
    
    // Check eax is an object of the right Structure.
    Jump failureCases1 = checkStructure(regT0, structure);
    
    // Check the prototype object's Structure had not changed.
    Jump failureCases2 = addStructureTransitionCheck(protoObject, prototypeStructure, stubInfo, regT3);
    
    bool needsStubLink = false;
    bool isDirect = false;
    if (slot.cachedPropertyType() == PropertySlot::Getter) {
        needsStubLink = true;
        compileGetDirectOffset(protoObject, regT2, regT1, cachedOffset);
        JITStubCall stubCall(this, cti_op_get_by_id_getter_stub);
        stubCall.addArgument(regT1);
        stubCall.addArgument(regT0);
        stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
        stubCall.call();
    } else if (slot.cachedPropertyType() == PropertySlot::Custom) {
        needsStubLink = true;
        JITStubCall stubCall(this, cti_op_get_by_id_custom_stub);
        stubCall.addArgument(TrustedImmPtr(protoObject));
        stubCall.addArgument(TrustedImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
        stubCall.addArgument(TrustedImmPtr(const_cast<Identifier*>(&ident)));
        stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
        stubCall.call();
    } else {
        isDirect = true;
        compileGetDirectOffset(protoObject, regT1, regT0, cachedOffset);
    }
    
    Jump success = jump();
    
    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
    if (needsStubLink) {
        for (Vector<CallRecord>::iterator iter = m_calls.begin(); iter != m_calls.end(); ++iter) {
            if (iter->to)
                patchBuffer.link(iter->from, FunctionPtr(iter->to));
        }
    }
    // Use the patch information to link the failure cases back to the original slow case routine.
    CodeLocationLabel lastProtoBegin = CodeLocationLabel(JITStubRoutine::asCodePtr(prototypeStructures->list[currentIndex - 1].stubRoutine));
    patchBuffer.link(failureCases1, lastProtoBegin);
    if (failureCases2.isSet())
        patchBuffer.link(failureCases2, lastProtoBegin);
    
    // On success return back to the hot patch code, at a point it will perform the store to dest for us.
    patchBuffer.link(success, stubInfo->hotPathBegin.labelAtOffset(stubInfo->patch.baseline.u.get.putResult));
    
    RefPtr<JITStubRoutine> stubRoutine = createJITStubRoutine(
        FINALIZE_CODE(
            patchBuffer,
            (""Baseline get_by_id proto list stub for %s, return point %p"",
                toCString(*m_codeBlock).data(), stubInfo->hotPathBegin.labelAtOffset(
                    stubInfo->patch.baseline.u.get.putResult).executableAddress())),
        *m_vm,
        m_codeBlock->ownerExecutable(),
        needsStubLink);

    prototypeStructures->list[currentIndex].set(callFrame->vm(), m_codeBlock->ownerExecutable(), stubRoutine, structure, prototypeStructure, isDirect);
    
    // Finally patch the jump to slow case back in the hot path to jump here instead.
    CodeLocationJump jumpLocation = stubInfo->hotPathBegin.jumpAtOffset(stubInfo->patch.baseline.u.get.structureCheck);
    RepatchBuffer repatchBuffer(m_codeBlock);
    repatchBuffer.relink(jumpLocation, CodeLocationLabel(stubRoutine->code().code()));
}

void JIT::privateCompileGetByIdChainList(StructureStubInfo* stubInfo, PolymorphicAccessStructureList* prototypeStructures, int currentIndex, Structure* structure, StructureChain* chain, size_t count, const Identifier& ident, const PropertySlot& slot, PropertyOffset cachedOffset, CallFrame* callFrame)
{
    // regT0 holds a JSCell*
    ASSERT(count);
    
    JumpList bucketsOfFail;
    
    // Check eax is an object of the right Structure.
    bucketsOfFail.append(checkStructure(regT0, structure));
    
    Structure* currStructure = structure;
    WriteBarrier<Structure>* it = chain->head();
    JSObject* protoObject = 0;
    for (unsigned i = 0; i < count; ++i, ++it) {
        protoObject = asObject(currStructure->prototypeForLookup(callFrame));
        currStructure = it->get();
        testPrototype(protoObject, bucketsOfFail, stubInfo);
    }
    ASSERT(protoObject);
    
    bool needsStubLink = false;
    bool isDirect = false;
    if (slot.cachedPropertyType() == PropertySlot::Getter) {
        needsStubLink = true;
        compileGetDirectOffset(protoObject, regT2, regT1, cachedOffset);
        JITStubCall stubCall(this, cti_op_get_by_id_getter_stub);
        stubCall.addArgument(regT1);
        stubCall.addArgument(regT0);
        stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
        stubCall.call();
    } else if (slot.cachedPropertyType() == PropertySlot::Custom) {
        needsStubLink = true;
        JITStubCall stubCall(this, cti_op_get_by_id_custom_stub);
        stubCall.addArgument(TrustedImmPtr(protoObject));
        stubCall.addArgument(TrustedImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
        stubCall.addArgument(TrustedImmPtr(const_cast<Identifier*>(&ident)));
        stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
        stubCall.call();
    } else {
        isDirect = true;
        compileGetDirectOffset(protoObject, regT1, regT0, cachedOffset);
    }

    Jump success = jump();
    
    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
    if (needsStubLink) {
        for (Vector<CallRecord>::iterator iter = m_calls.begin(); iter != m_calls.end(); ++iter) {
            if (iter->to)
                patchBuffer.link(iter->from, FunctionPtr(iter->to));
        }
    }
    // Use the patch information to link the failure cases back to the original slow case routine.
    CodeLocationLabel lastProtoBegin = CodeLocationLabel(JITStubRoutine::asCodePtr(prototypeStructures->list[currentIndex - 1].stubRoutine));
    
    patchBuffer.link(bucketsOfFail, lastProtoBegin);
    
    // On success return back to the hot patch code, at a point it will perform the store to dest for us.
    patchBuffer.link(success, stubInfo->hotPathBegin.labelAtOffset(stubInfo->patch.baseline.u.get.putResult));
    
    RefPtr<JITStubRoutine> stubRoutine = createJITStubRoutine(
        FINALIZE_CODE(
            patchBuffer,
            (""Baseline get_by_id chain list stub for %s, return point %p"",
                toCString(*m_codeBlock).data(), stubInfo->hotPathBegin.labelAtOffset(
                    stubInfo->patch.baseline.u.get.putResult).executableAddress())),
        *m_vm,
        m_codeBlock->ownerExecutable(),
        needsStubLink);
    
    // Track the stub we have created so that it will be deleted later.
    prototypeStructures->list[currentIndex].set(callFrame->vm(), m_codeBlock->ownerExecutable(), stubRoutine, structure, chain, isDirect);
    
    // Finally patch the jump to slow case back in the hot path to jump here instead.
    CodeLocationJump jumpLocation = stubInfo->hotPathBegin.jumpAtOffset(stubInfo->patch.baseline.u.get.structureCheck);
    RepatchBuffer repatchBuffer(m_codeBlock);
    repatchBuffer.relink(jumpLocation, CodeLocationLabel(stubRoutine->code().code()));
}

void JIT::privateCompileGetByIdChain(StructureStubInfo* stubInfo, Structure* structure, StructureChain* chain, size_t count, const Identifier& ident, const PropertySlot& slot, PropertyOffset cachedOffset, ReturnAddressPtr returnAddress, CallFrame* callFrame)
{
    // regT0 holds a JSCell*
    ASSERT(count);
    
    JumpList bucketsOfFail;
    
    // Check eax is an object of the right Structure.
    bucketsOfFail.append(checkStructure(regT0, structure));
    
    Structure* currStructure = structure;
    WriteBarrier<Structure>* it = chain->head();
    JSObject* protoObject = 0;
    for (unsigned i = 0; i < count; ++i, ++it) {
        protoObject = asObject(currStructure->prototypeForLookup(callFrame));
        currStructure = it->get();
        testPrototype(protoObject, bucketsOfFail, stubInfo);
    }
    ASSERT(protoObject);
    
    bool needsStubLink = false;
    if (slot.cachedPropertyType() == PropertySlot::Getter) {
        needsStubLink = true;
        compileGetDirectOffset(protoObject, regT2, regT1, cachedOffset);
        JITStubCall stubCall(this, cti_op_get_by_id_getter_stub);
        stubCall.addArgument(regT1);
        stubCall.addArgument(regT0);
        stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
        stubCall.call();
    } else if (slot.cachedPropertyType() == PropertySlot::Custom) {
        needsStubLink = true;
        JITStubCall stubCall(this, cti_op_get_by_id_custom_stub);
        stubCall.addArgument(TrustedImmPtr(protoObject));
        stubCall.addArgument(TrustedImmPtr(FunctionPtr(slot.customGetter()).executableAddress()));
        stubCall.addArgument(TrustedImmPtr(const_cast<Identifier*>(&ident)));
        stubCall.addArgument(TrustedImmPtr(stubInfo->callReturnLocation.executableAddress()));
        stubCall.call();
    } else
        compileGetDirectOffset(protoObject, regT1, regT0, cachedOffset);
    Jump success = jump();
    
    LinkBuffer patchBuffer(*m_vm, this, m_codeBlock);
    if (needsStubLink) {
        for (Vector<CallRecord>::iterator iter = m_calls.begin(); iter != m_calls.end(); ++iter) {
            if (iter->to)
                patchBuffer.link(iter->from, FunctionPtr(iter->to));
        }
    }
    // Use the patch information to link the failure cases back to the original slow case routine.
    patchBuffer.link(bucketsOfFail, stubInfo->callReturnLocation.labelAtOffset(-stubInfo->patch.baseline.u.get.coldPathBegin));
    
    // On success return back to the hot patch code, at a point it will perform the store to dest for us.
    patchBuffer.link(success, stubInfo->hotPathBegin.labelAtOffset(stubInfo->patch.baseline.u.get.putResult));
    
    // Track the stub we have created so that it will be deleted later.
    RefPtr<JITStubRoutine> stubRoutine = createJITStubRoutine(
        FINALIZE_CODE(
            patchBuffer,
            (""Baseline get_by_id chain stub for %s, return point %p"",
                toCString(*m_codeBlock).data(), stubInfo->hotPathBegin.labelAtOffset(
                    stubInfo->patch.baseline.u.get.putResult).executableAddress())),
        *m_vm,
        m_codeBlock->ownerExecutable(),
        needsStubLink);
    stubInfo->stubRoutine = stubRoutine;
    
    // Finally patch the jump to slow case back in the hot path to jump here instead.
    CodeLocationJump jumpLocation = stubInfo->hotPathBegin.jumpAtOffset(stubInfo->patch.baseline.u.get.structureCheck);
    RepatchBuffer repatchBuffer(m_codeBlock);
    repatchBuffer.relink(jumpLocation, CodeLocationLabel(stubRoutine->code().code()));
    
    // We don't want to patch more than once - in future go to cti_op_put_by_id_generic.
    repatchBuffer.relinkCallerToFunction(returnAddress, FunctionPtr(cti_op_get_by_id_proto_list));
}

void JIT::compileGetDirectOffset(RegisterID base, RegisterID resultTag, RegisterID resultPayload, RegisterID offset, FinalObjectMode finalObjectMode)
{
    ASSERT(sizeof(JSValue) == 8);
    
    if (finalObjectMode == MayBeFinal) {
        Jump isInline = branch32(LessThan, offset, TrustedImm32(firstOutOfLineOffset));
        loadPtr(Address(base, JSObject::butterflyOffset()), base);
        neg32(offset);
        Jump done = jump();
        isInline.link(this);
        addPtr(TrustedImmPtr(JSObject::offsetOfInlineStorage() - (firstOutOfLineOffset - 2) * sizeof(EncodedJSValue)), base);
        done.link(this);
    } else {
#if !ASSERT_DISABLED
        Jump isOutOfLine = branch32(GreaterThanOrEqual, offset, TrustedImm32(firstOutOfLineOffset));
        breakpoint();
        isOutOfLine.link(this);
#endif
        loadPtr(Address(base, JSObject::butterflyOffset()), base);
        neg32(offset);
    }
    load32(BaseIndex(base, offset, TimesEight, OBJECT_OFFSETOF(JSValue, u.asBits.payload) + (firstOutOfLineOffset - 2) * sizeof(EncodedJSValue)), resultPayload);
    load32(BaseIndex(base, offset, TimesEight, OBJECT_OFFSETOF(JSValue, u.asBits.tag) + (firstOutOfLineOffset - 2) * sizeof(EncodedJSValue)), resultTag);
}

void JIT::emit_op_get_by_pname(Instruction* currentInstruction)
{
    unsigned dst = currentInstruction[1].u.operand;
    unsigned base = currentInstruction[2].u.operand;
    unsigned property = currentInstruction[3].u.operand;
    unsigned expected = currentInstruction[4].u.operand;
    unsigned iter = currentInstruction[5].u.operand;
    unsigned i = currentInstruction[6].u.operand;
    
    emitLoad2(property, regT1, regT0, base, regT3, regT2);
    emitJumpSlowCaseIfNotJSCell(property, regT1);
    addSlowCase(branchPtr(NotEqual, regT0, payloadFor(expected)));
    // Property registers are now available as the property is known
    emitJumpSlowCaseIfNotJSCell(base, regT3);
    emitLoadPayload(iter, regT1);
    
    // Test base's structure
    loadPtr(Address(regT2, JSCell::structureOffset()), regT0);
    addSlowCase(branchPtr(NotEqual, regT0, Address(regT1, OBJECT_OFFSETOF(JSPropertyNameIterator, m_cachedStructure))));
    load32(addressFor(i), regT3);
    sub32(TrustedImm32(1), regT3);
    addSlowCase(branch32(AboveOrEqual, regT3, Address(regT1, OBJECT_OFFSETOF(JSPropertyNameIterator, m_numCacheableSlots))));
    Jump inlineProperty = branch32(Below, regT3, Address(regT1, OBJECT_OFFSETOF(JSPropertyNameIterator, m_cachedStructureInlineCapacity)));
    add32(TrustedImm32(firstOutOfLineOffset), regT3);
    sub32(Address(regT1, OBJECT_OFFSETOF(JSPropertyNameIterator, m_cachedStructureInlineCapacity)), regT3);
    inlineProperty.link(this);
    compileGetDirectOffset(regT2, regT1, regT0, regT3);    
    
    emitStore(dst, regT1, regT0);
    map(m_bytecodeOffset + OPCODE_LENGTH(op_get_by_pname), dst, regT1, regT0);
}

void JIT::emitSlow_op_get_by_pname(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
{
    unsigned dst = currentInstruction[1].u.operand;
    unsigned base = currentInstruction[2].u.operand;
    unsigned property = currentInstruction[3].u.operand;
    
    linkSlowCaseIfNotJSCell(iter, property);
    linkSlowCase(iter);
    linkSlowCaseIfNotJSCell(iter, base);
    linkSlowCase(iter);
    linkSlowCase(iter);
    
    JITStubCall stubCall(this, cti_op_get_by_val_generic);
    stubCall.addArgument(base);
    stubCall.addArgument(property);
    stubCall.call(dst);
}

void JIT::emit_op_get_scoped_var(Instruction* currentInstruction)
{
    int dst = currentInstruction[1].u.operand;
    int index = currentInstruction[2].u.operand;
    int skip = currentInstruction[3].u.operand;

    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT2);
    bool checkTopLevel = m_codeBlock->codeType() == FunctionCode && m_codeBlock->needsFullScopeChain();
    ASSERT(skip || !checkTopLevel);
    if (checkTopLevel && skip--) {
        Jump activationNotCreated;
        if (checkTopLevel)
            activationNotCreated = branch32(Equal, tagFor(m_codeBlock->activationRegister()), TrustedImm32(JSValue::EmptyValueTag));
        loadPtr(Address(regT2, JSScope::offsetOfNext()), regT2);
        activationNotCreated.link(this);
    }
    while (skip--)
        loadPtr(Address(regT2, JSScope::offsetOfNext()), regT2);

    loadPtr(Address(regT2, JSVariableObject::offsetOfRegisters()), regT2);

    emitLoad(index, regT1, regT0, regT2);
    emitValueProfilingSite();
    emitStore(dst, regT1, regT0);
    map(m_bytecodeOffset + OPCODE_LENGTH(op_get_scoped_var), dst, regT1, regT0);
}

void JIT::emit_op_put_scoped_var(Instruction* currentInstruction)
{
    int index = currentInstruction[1].u.operand;
    int skip = currentInstruction[2].u.operand;
    int value = currentInstruction[3].u.operand;

    emitLoad(value, regT1, regT0);

    emitGetFromCallFrameHeaderPtr(JSStack::ScopeChain, regT2);
    bool checkTopLevel = m_codeBlock->codeType() == FunctionCode && m_codeBlock->needsFullScopeChain();
    ASSERT(skip || !checkTopLevel);
    if (checkTopLevel && skip--) {
        Jump activationNotCreated;
        if (checkTopLevel)
            activationNotCreated = branch32(Equal, tagFor(m_codeBlock->activationRegister()), TrustedImm32(JSValue::EmptyValueTag));
        loadPtr(Address(regT2, JSScope::offsetOfNext()), regT2);
        activationNotCreated.link(this);
    }
    while (skip--)
        loadPtr(Address(regT2, JSScope::offsetOfNext()), regT2);

    loadPtr(Address(regT2, JSVariableObject::offsetOfRegisters()), regT3);
    emitStore(index, regT1, regT0, regT3);
    emitWriteBarrier(regT2, regT1, regT0, regT1, ShouldFilterImmediates, WriteBarrierForVariableAccess);
}

void JIT::emit_op_init_global_const(Instruction* currentInstruction)
{
    WriteBarrier<Unknown>* registerPointer = currentInstruction[1].u.registerPointer;
    int value = currentInstruction[2].u.operand;

    JSGlobalObject* globalObject = m_codeBlock->globalObject();

    emitLoad(value, regT1, regT0);
    
    if (Heap::isWriteBarrierEnabled()) {
        move(TrustedImmPtr(globalObject), regT2);
        
        emitWriteBarrier(globalObject, regT1, regT3, ShouldFilterImmediates, WriteBarrierForVariableAccess);
    }

    store32(regT1, registerPointer->tagPointer());
    store32(regT0, registerPointer->payloadPointer());
    map(m_bytecodeOffset + OPCODE_LENGTH(op_init_global_const), value, regT1, regT0);
}

void JIT::emit_op_init_global_const_check(Instruction* currentInstruction)
{
    WriteBarrier<Unknown>* registerPointer = currentInstruction[1].u.registerPointer;
    int value = currentInstruction[2].u.operand;
    
    JSGlobalObject* globalObject = m_codeBlock->globalObject();
    
    emitLoad(value, regT1, regT0);
    
    addSlowCase(branchTest8(NonZero, AbsoluteAddress(currentInstruction[3].u.predicatePointer)));
    
    if (Heap::isWriteBarrierEnabled()) {
        move(TrustedImmPtr(globalObject), regT2);
        emitWriteBarrier(globalObject, regT1, regT3, ShouldFilterImmediates, WriteBarrierForVariableAccess);
    }
    
    store32(regT1, registerPointer->tagPointer());
    store32(regT0, registerPointer->payloadPointer());
    unmap();
}

void JIT::emitSlow_op_init_global_const_check(Instruction* currentInstruction, Vector<SlowCaseEntry>::iterator& iter)
{
    linkSlowCase(iter);
    
    JITStubCall stubCall(this, cti_op_init_global_const_check);
    stubCall.addArgument(regT1, regT0);
    stubCall.addArgument(TrustedImm32(currentInstruction[4].u.operand));
    stubCall.call();
}

void JIT::resetPatchGetById(RepatchBuffer& repatchBuffer, StructureStubInfo* stubInfo)
{
    repatchBuffer.relink(stubInfo->callReturnLocation, cti_op_get_by_id);
    repatchBuffer.repatch(stubInfo->hotPathBegin.dataLabelPtrAtOffset(stubInfo->patch.baseline.u.get.structureToCompare), reinterpret_cast<void*>(unusedPointer));
    repatchBuffer.repatch(stubInfo->hotPathBegin.dataLabelCompactAtOffset(stubInfo->patch.baseline.u.get.displacementLabel1), 0);
    repatchBuffer.repatch(stubInfo->hotPathBegin.dataLabelCompactAtOffset(stubInfo->patch.baseline.u.get.displacementLabel2), 0);
    repatchBuffer.relink(stubInfo->hotPathBegin.jumpAtOffset(stubInfo->patch.baseline.u.get.structureCheck), stubInfo->callReturnLocation.labelAtOffset(-stubInfo->patch.baseline.u.get.coldPathBegin));
}

void JIT::resetPatchPutById(RepatchBuffer& repatchBuffer, StructureStubInfo* stubInfo)
{
    if (isDirectPutById(stubInfo))
        repatchBuffer.relink(stubInfo->callReturnLocation, cti_op_put_by_id_direct);
    else
        repatchBuffer.relink(stubInfo->callReturnLocation, cti_op_put_by_id);
    repatchBuffer.repatch(stubInfo->hotPathBegin.dataLabelPtrAtOffset(stubInfo->patch.baseline.u.put.structureToCompare), reinterpret_cast<void*>(unusedPointer));
    repatchBuffer.repatch(stubInfo->hotPathBegin.dataLabel32AtOffset(stubInfo->patch.baseline.u.put.displacementLabel1), 0);
    repatchBuffer.repatch(stubInfo->hotPathBegin.dataLabel32AtOffset(stubInfo->patch.baseline.u.put.displacementLabel2), 0);
}

} // namespace JSC

#endif // USE(JSVALUE32_64)
#endif // ENABLE(JIT)
",16173,True,3317.659364192923,median
"---
title: Συχνές Ερωτήσεις Σχετικά με τις Λίστες Ηλεκτρονικού Ταχυδρομείου του FreeBSD
authors:
  - author: Η Ομάδα Τεκμηρίωσης του FreeBSD
releaseinfo: ""$FreeBSD: head/el_GR.ISO8859-7/articles/mailing-list-faq/article.xml 43184 2013-11-13 07:52:45Z hrs $"" 
---

= Συχνές Ερωτήσεις Σχετικά με τις Λίστες Ηλεκτρονικού Ταχυδρομείου του FreeBSD
:doctype: article
:toc: macro
:toclevels: 1
:icons: font
:sectnums:
:source-highlighter: rouge
:experimental:
:figure-caption: Figure

include::share/authors.adoc[]
include::share/gr/mailing-lists.adoc[lines=10..-1]
include::share/gr/urls.adoc[]

[.abstract-title]
Περίληψη

Το άρθρο αυτό αποτελεί τις συχνές ερωτήσεις για τις λίστες ταχυδρομείου του FreeBSD. Αν ενδιαφέρεστε να βοηθήσετε σε αυτό το έργο, στείλτε ένα email στην {freebsd-doc}. Η τελευταία έκδοση αυτού του εγγράφου είναι πάντοτε διαθέσιμη στην link:{mailing-list-faq}[Δικτυακή τοποθεσία του FreeBSD]. Μπορείτε επίσης να το κατεβάσετε ως ένα μεγάλο αρχείο link:.[HTML] ή και ως απλό κείμενο, PostScript, PDF, κ.λ.π. από τον link:ftp://ftp.FreeBSD.org/pub/FreeBSD/doc/[Διακομιστή FTP του FreeBSD]. Μπορεί επίσης να θέλετε να link:https://www.FreeBSD.org/search/[ψάξετε σε αυτό το άρθρο].

'''

toc::[]

[[introduction]]
[.title]
== Εισαγωγή

Όπως συνηθίζεται στα κείμενα των Συχνών Ερωτήσεων (FAQ), το κείμενο αυτό περιέχει τις πιο συχνές ερωτήσεις που σχετίζονται με τις λίστες ταχυδρομείου του FreeBSD (και φυσικά τις απαντάει!). Αν και ο αρχικός σκοπός των FAQ ήταν να μειώσουν το εύρος ζώνης που απαιτείται από την συνεχόμενη απάντηση των ίδιων και ίδιων ερωτήσεων, τα FAQ τελικά καθιερώθηκαν ως μια πολύ χρήσιμη αυτόνομη πηγή πληροφοριών.

Το κείμενο αυτό προσπαθεί να αντιπροσωπεύσει την κοινά αποδεκτή γνώμη της κοινότητας και ως τέτοιο, δεν μπορεί σε καμιά περίπτωση να θεωρηθεί ότι είναι απόλυτα __έγκυρο__. Αν ωστόσο βρείτε τεχνικά λάθη ή έχετε να προτείνετε θέματα που πρέπει να προστεθούν, παρακαλούμε στείλτε μας μια αναφορά προβλήματος (PR) ή ένα email στην {freebsd-doc}. Ευχαριστούμε!

=== Ποιος είναι ο σκοπός των λιστών ταχυδρομείου του FreeBSD;

Οι λίστες ταχυδρομείου του FreeBSD αποτελούν το βασικό κανάλι επικοινωνίας για την κοινότητα του FreeBSD. Καλύπτουν πολλές διαφορετικές περιοχές θεμάτων και ενδιαφερόντων.

=== Ποιο είναι το κοινό για τις λίστες ταχυδρομείου του FreeBSD;

Αυτό εξαρτάται από τον κανονισμό της κάθε λίστας. Μερικές λίστες είναι περισσότερο προσανατολισμένες στους προγραμματιστές. Άλλες προσανατολίζονται περισσότερο στην κοινότητα του FreeBSD ως σύνολο. Παρακαλούμε δείτε http://lists.FreeBSD.org/mailman/listinfo[αυτή τη λίστα] για την τρέχουσα περίληψη.

=== Είναι όλες οι λίστες του FreeBSD ανοιχτές για συμμετοχή από τον καθένα;

Και πάλι, αυτό εξαρτάται από τον κανονισμό της κάθε λίστας. Σας παρακαλούμε να διαβάσετε τον κανονισμό της λίστας που σας ενδιαφέρει πριν αρχίσετε να δημοσιεύετε σε αυτήν και να τον σέβεστε σε κάθε δημοσίευση σας. Αυτό βοηθάει όλους τους συμμετέχοντες να έχουν την καλύτερη δυνατή εμπειρία από τις λίστες μας.

Αν διαβάζοντας τους κανονισμούς για τις παραπάνω λίστες, δεν μπορείτε ακόμα να αποφασίσετε σε ποια λίστα να στείλετε την ερώτηση σας, μάλλον θα πρέπει να την στείλετε στην {freebsd-questions} (αλλά δείτε πρώτα παρακάτω).

Σημειώστε επίσης ότι κατά παράδοση οι λίστες είναι ανοιχτές και σε άτομα που δεν έχουν εγγραφεί σε αυτές. Αυτή η επιλογή είναι εσκεμμένη, με σκοπό να βοηθήσει τους νέους χρήστες να εισέλθουν πιο εύκολα στην κοινότητα του FreeBSD, και να ενισχύσει την ανοιχτή ανταλλαγή ιδεών. Ωστόσο, λόγω κακής χρήσης από συγκεκριμένα άτομα, κάποιες λίστες έχουν τώρα τον περιορισμό ότι κάθε μήνυμα από μη-μέλος θα πρέπει να ελέγχεται χειροκίνητα για να εξασφαλιστεί ότι είναι κατάλληλο.

=== Πως μπορώ να εγγραφώ;

Μπορείτε να χρησιμοποιήσετε την http://lists.FreeBSD.org/mailman/listinfo[διεπαφή Web του Mailman] για να γραφείτε σε οποιαδήποτε από τις δημόσιες λίστες.

=== Πως μπορώ να διαγραφώ;

Με τον ίδιο τρόπο που εγγραφήκατε. Ή μπορείτε επίσης να ακολουθήσετε τις οδηγίες που βρίσκονται στο τέλος κάθε μηνύματος που στέλνει η λίστα.

Σας παρακαλούμε μη στέλνετε μηνύματα διαγραφής απευθείας σε δημόσιες λίστες. Πρώτα από όλα, αυτό δεν θα επιτύχει το σκοπό σας, και δεύτερον θα εκνευρίσει τους υπάρχοντες συνδρομητές οι οποίοι θα λογομαχήσουν εναντίον σας. Πρόκειται για κλασικό λάθος κατά τη χρήση λιστών ταχυδρομείου και σας παρακαλούμε να προσπαθήσετε να το αποφύγετε.

=== Είναι διαθέσιμα τα αρχεία των λιστών;

Ναι. Μπορείτε να τα βρείτε http://docs.FreeBSD.org/mail/[εδώ], ταξινομημένα κατά θέμα.

=== Είναι διαθέσιμες οι λίστες σε μορφή περίληψης;

Ναι. Δείτε http://lists.FreeBSD.org/mailman/listinfo[τη διεπαφή web του Mailman].

[[etiquette]]
[.title]
== Συμπεριφορά (Etiquette) στις Λίστες

Η συμμετοχή στις λίστες ηλεκτρονικού ταχυδρομείου, όπως και η συμμετοχή σε οποιαδήποτε κοινότητα, απαιτεί μια κοινή βάση επικοινωνίας. Σας παρακαλούμε να κάνετε μόνο κατάλληλες δημοσιεύσεις, και να ακολουθείτε τους κοινούς κανόνες συμπεριφοράς.

=== Τι πρέπει να κάνω πριν από μια δημοσίευση;

Διαβάζοντας αυτό το κείμενο, έχετε ήδη κάνει το πιο σημαντικό βήμα. Ωστόσο, αν είστε νέος στο FreeBSD, θα πρέπει πρώτα να εξοικειωθείτε με το λογισμικό και όλη την κοινωνική ιστορία που το περιβάλλει, διαβάζοντας τα διάφορα link:https://www.FreeBSD.org/docs/books/[άρθρα και βιβλία] τα οποία είναι διαθέσιμα. Ιδιαίτερο ενδιαφέρον έχουν link:{faq}[Οι Συχνές Ερωτήσεις (FAQ) του FreeBSD], το link:{handbook}[Εγχειρίδιο του FreeBSD] καθώς και τα άρθρα link:{freebsd-questions}[Πως να χρησιμοποιείτε με επιτυχία τη λίστα ηλεκτρονικού ταχυδρομείου FreeBSD-questions], link:{explaining-bsd}[Περιγραφή των Συστημάτων BSD], και link:{new-users}[Για Χρήστες Νέους τόσο στο FreeBSD όσο και στο UNIX(R)].

Θεωρείται γενικά κακή συμπεριφορά να ρωτήσετε μια ερώτηση η οποία μπορεί να απαντηθεί από κάποιο από τα παραπάνω κείμενα. Αυτό δεν συμβαίνει επειδή οι εθελοντές που δουλεύουν σε αυτό το έργο είναι κακοί άνθρωποι, αλλά επειδή όταν έχουν απαντήσει την ίδια ερώτηση πολλές φορές, αρχίζει να τους ενοχλεί. Αυτό συμβαίνει ειδικά αν υπάρχει διαθέσιμη η απάντηση της ερώτησης. Να θυμάστε πάντα ότι σχεδόν όλη η δουλειά στο FreeBSD γίνεται από εθελοντές και τελικά είμαστε απλώς άνθρωποι.

=== Τι δημοσίευση μπορεί να θεωρηθεί ακατάλληλη;

* Η δημοσίευση πρέπει να είναι σύμφωνη με τους κανονισμούς της λίστας.
* Οι προσωπικές επιθέσεις είναι γενικά ανεπιθύμητες. Σαν καλοί διαδικτυακοί πολίτες, θα πρέπει να προσπαθούμε να κρατάμε υψηλά επίπεδα συμπεριφοράς.
* Το spam δεν επιτρέπεται ποτέ. Γίνεται επεξεργασία στις λίστες για να απαγορευτούν οι δημοσιεύσεις σε όσους παραβαίνουν αυτό τον κανόνα.

=== Ποια θεωρείται σωστή συμπεριφορά στην αποστολή μηνυμάτων στις λίστες;

* Παρακαλούμε να κάνετε αναδίπλωση των γραμμών κάθε 75 χαρακτήρες. Δεν χρησιμοποιούν όλοι GUI προγράμματα για να διαβάζουν το mail τους.
* Παρακαλούμε σεβαστείτε το γεγονός ότι το εύρος ζώνης δεν είναι απεριόριστο. Δεν διαβάζει καθένας το email του μέσω συνδέσεων υψηλής ταχύτητας, έτσι αν το μήνυμα σας περιέχει κάτι σαν το περιεχόμενο του αρχείου [.filename]#config.log# ή ένα εκτεταμένο stack trace, σας παρακαλούμε να ανεβάσετε αυτές τις πληροφορίες σε κάποια δικτυακή τοποθεσία και να στείλετε ένα σύνδεσμο προς αυτές. Να θυμάστε επίσης ότι γίνεται αρχειοθέτηση αυτών των μηνυμάτων, έτσι αν στείλετε ένα τεράστιο μήνυμα θα μεγαλώσετε και το μέγεθος των αρχείων, ακόμα και όταν αυτές οι πληροφορίες δεν θα είναι πια χρήσιμες.
* Μορφοποιήστε το μήνυμα σας ώστε να είναι ευανάγνωστο και σας παρακαλούμε ΜΗ ΦΩΝΑΖΕΤΕ!!!. Μην υποτιμάτε το αποτέλεσμα που θα έχει ένα φτωχά μορφοποιημένο μήνυμα, και αυτό δεν συμβαίνει μόνο στις λίστες του FreeBSD. Το μήνυμα σας είναι το μόνο που σας γνωστοποιεί στους υπόλοιπους ανθρώπους, και αν είναι άσχημα μορφοποιημένο, γεμάτο θαυμαστικά, θα αφήσει στους άλλους άσχημη εντύπωση για εσάς.
* Χρησιμοποιήστε την κατάλληλη γλώσσα για τη λίστα ταχυδρομείου που πρόκειται να στείλετε μήνυμα. Μπορείτε να δείτε link:https://www.FreeBSD.org/community/mailinglists/[εδώ] τις λίστες που υπάρχουν σε γλώσσες εκτός της Αγγλικής.
+ 
Όσο αφορά τις Αγγλικές λίστες, αντιλαμβανόμαστε ότι για πολλούς η Αγγλική δεν είναι η μητρική τους γλώσσα και δείχνουμε κατανόηση. Θεωρείται κακή συμπεριφορά να κατακρίνετε όσους δεν έχουν τα Αγγλικά ως μητρική γλώσσα για λάθη γραμματικής ή ορθογραφίας. Το FreeBSD έχει μια πολύ καλή παράδοση σε αυτό το θέμα, σας παρακαλούμε να μας βοηθήσετε να τη διατηρήσουμε.
* Παρακαλούμε χρησιμοποιήστε ένα πρόγραμμα αποστολής ταχυδρομείου (MUA) που να ακολουθεί σωστά τα πρότυπα. Πολλά από τα άσχημα μορφοποιημένα μηνύματα προέρχονται από http://www.lemis.com/email.html[κακής ποιότητας ή κακορυθμισμένα προγράμματα ταχυδρομείου]. Τα παρακάτω προγράμματα είναι γνωστό ότι στέλνουν προβληματικά μηνύματα, χωρίς εσείς να το γνωρίζετε:

** cc:Mail
** Eudora(R) (παλιότερες εκδόσεις)
** exmh
** Microsoft(R) Exchange
** Microsoft(R) Internet Mail
** Microsoft(R) Outlook(R)
** Netscape(R) (παλιότερες εκδόσεις)

+ 
Όπως μπορείτε να δείτε, πολλά από τα προβληματικά προγράμματα προέρχονται από τον κόσμο της Microsoft. Αν είναι δυνατόν χρησιμοποιήστε ένα πρόγραμμα που να προέρχεται από το UNIX(R). Αν πρέπει να χρησιμοποιήσετε ένα πρόγραμμα σε περιβάλλον Microsoft, φροντίστε να είναι ρυθμισμένο σωστά. Προσπαθήστε να μην χρησιμοποιήσετε MIME: αρκετός κόσμος χρησιμοποιεί προγράμματα ταχυδρομείου που δεν τα πάνε πολύ καλά με το MIME.
* Βεβαιωθείτε ότι η ώρα και η ζώνη ώρας στον υπολογιστή σας είναι σωστά ρυθμισμένα. Αυτό μπορεί να φαίνεται κάπως ανόητο, ειδικά καθώς το μήνυμα σας θα φτάσει έτσι και αλλιώς, αλλά αρκετοί άνθρωποι σε αυτές τις λίστες λαμβάνουν εκατοντάδες μηνύματα κάθε μέρα. Συχνά τα ταξινομούν κατά θέμα και ημερομηνία, έτσι αν το μήνυμα σας έρθει μετά την πρώτη απάντηση θα θεωρήσουν ότι το έχασαν και δεν θα ασχοληθούν να το ψάξουν.
* Πολλές φορές οι πληροφορίες που πρέπει να παρέχετε περιέχουν την έξοδο προγραμμάτων όπως το man:dmesg[8], ή τα μηνύματα που εμφανίζονται στην κονσόλα, τα οποία συνήθως γράφονται στο [.filename]#/var/log/messages#. Μην προσπαθήσετε να αντιγράψετε αυτές τις πληροφορίες πληκτρολογώντας τις ξανά: όχι μόνο είναι βασανιστικό, αλλά είναι σχεδόν σίγουρο ότι θα κάνετε κάποιο λάθος. Για να στείλετε τα περιεχόμενα κάποιου αρχείου καταγραφής, είτε αντιγράψτε το αρχείο και χρησιμοποιήστε κάποιο συντάκτη κειμένου για να κόψετε τα κομμάτια που σας ενδιαφέρουν, ή κάντε αποκοπή και επικόλληση μέσα στο μήνυμα σας. Για την έξοδο προγραμμάτων όπως το `dmesg`, χρησιμοποιήστε ανακατεύθυνση της εξόδου σε ένα αρχείο και στείλτε αυτό. Για παράδειγμα:
+
[source,bash]
....
% dmesg > /tmp/dmesg.out
....
+ 
Το παραπάνω θα ανακατευθύνει τις πληροφορίες στο αρχείο [.filename]#/tmp/dmesg.out#.
* Όταν χρησιμοποιείτε αποκοπή και επικόλληση να έχετε υπόψη σας ότι αυτές οι λειτουργίες μπορεί να καταστρέψουν το νόημα των μηνυμάτων. Αυτό συμβαίνει ιδιαίτερα όταν στέλνετε αρχεία όπως τα [.filename]#Makefiles#, όπου το `tab` είναι σημαντικός χαρακτήρας. Πρόκειται για πολύ κοινό και ενοχλητικό πρόβλημα ειδικά σε μηνύματα που απευθύνονται στη link:https://www.FreeBSD.org/support/gnats[Βάση Δεδομένων Προβλημάτων GNATS]. Τα [.filename]#Makefiles# όπου τα tabs έχουν αλλάξει είτε σε κενά ή στον ενοχλητικό χαρακτήρα `=3B` δημιουργούν πολλά ενοχλητικά προβλήματα στους committers.

=== Τι πρέπει να έχω υπόψη μου όσο αφορά τη συμπεριφορά στη λίστα όταν απαντάω σε κάποιο υπάρχον μήνυμα;

* Παρακαλούμε να συμπεριλάβετε το σχετικό κείμενο από το αρχικό κείμενο. Περιορίστε το στο ελάχιστο, αλλά μη το παρακάνετε. Θα πρέπει κάποιος που δεν έχει δει το αρχικό μήνυμα να μπορεί να καταλάβει σε τι αναφέρεται η συζήτηση.
+ 
Αυτό είναι ιδιαίτερα σημαντικό σε μηνύματα του τύπου ""Ναι και σε μένα συμβαίνει το ίδιο"", όπου το αρχικό μήνυμα μπορεί να ήταν αρκετές δεκάδες ή εκατοντάδες γραμμές.
* Χρησιμοποιήστε κάποια τεχνική με την οποία να γίνεται δυνατή η αναγνώριση του κειμένου που ανήκει στο αρχικό μήνυμα και του κειμένου που προσθέσατε. Μια συνηθισμένη σύμβαση είναι να χρησιμοποιείται το ""`> `"" μπροστά από το αρχικό μήνυμα. Είναι επίσης καλή ιδέα να αφήνετε κενό διάστημα μετά το ""`> `"" και κενές γραμμές ανάμεσα στο δικό σας και το αρχικό, ώστε το τελικό αποτέλεσμα να είναι πιο ευανάγνωστο.
* Να βεβαιώνεστε πάντα ότι οι αναφορές στον αρχικό συγγραφέα του μηνύματος είναι σωστές. Συχνά οι άνθρωποι προσβάλλονται αν τους εμφανίζετε να έχουν γράψει λέξεις ενώ αυτό δεν συμβαίνει.
* Παρακαλούμε μην κάνετε `top post`. Αυτό σημαίνει να μην ξεκινάτε την απάντηση σας πάνω από το κείμενο του μηνύματος στο οποίο απαντάτε.
+
** Απ: Γιατί αντιστρέφει τη λογική ροή της συζήτησης.
** Ερ: Γιατί θεωρείται κακό το top posting;
+ 
(Ευχαριστούμε το Randy Bush για το ανέκδοτο.)

[[recurring]]
[.title]
== Επαναλαμβανόμενα Θέματα στις Λίστες Ταχυδρομείου

Η συμμετοχή στις λίστες ταχυδρομείου, όπως και η συμμετοχή σε κάθε κοινότητα, απαιτεί μια κοινή βάση επικοινωνίας. Πολλές από τις λίστες ταχυδρομείου προϋποθέτουν γνώση της ιστορίας του Project. Ειδικότερα, φαίνεται ότι κάποια θέματα προκύπτουν ξανά και ξανά στα νεώτερα μέλη της κοινότητας. Είναι ευθύνη του καθένα που συμμετέχει να φροντίζει ώστε τα μηνύματα του να μην εμπίπτουν σε κάποια από αυτές τις κατηγορίες. Με τον τρόπο αυτό, βοηθάτε τις λίστες ταχυδρομείου να μην ξεφεύγουν από το θέμα τους, και πιθανόν προφυλάσσετε και τον εαυτό σας από τυχόν λεκτικές επιθέσεις (flames).

Η καλύτερη μέθοδος για να αποφύγετε το παραπάνω πρόβλημα είναι να εξοικειωθείτε με τα http://docs.FreeBSD.org/mail/[αρχεία των λιστών] για να μπορέσετε να καταλάβετε το ιστορικό της συζήτησης. Ιδιαίτερα χρήσιμη για αυτό το σκοπό θα σας φανεί και η link:https://www.FreeBSD.org/search/#mailinglists[λειτουργία αναζήτησης της λίστας]. (Αν η μέθοδος αυτή δεν φέρει το επιθυμητό αποτέλεσμα, συμπληρώστε την με μια αναζήτηση μέσω της μηχανής αναζήτησης που προτιμάτε).

Όταν θα έχετε εξοικειωθεί με τα αρχεία της λίστας, όχι μόνο θα γνωρίζετε ποια θέματα έχουν συζητηθεί παλιότερα, αλλά και με ποιο τρόπο εξελίσσονται συνήθως οι συζητήσεις σε αυτή τη λίστα, ποιοι είναι οι συμμετέχοντες και σε ποιο κοινό απευθύνεται. Είναι πάντοτε καλό να γνωρίζετε εκ των προτέρων τα παραπάνω πριν στείλετε μήνυμα σε οποιαδήποτε λίστα (όχι μόνο του FreeBSD).

Δεν υπάρχει αμφιβολία ότι τα αρχεία έχουν μεγάλη έκταση και μερικές ερωτήσεις φαίνονται να επαναλαμβάνονται πιο συχνά από άλλες, μερικές φορές σαν απαντήσεις όπου το θέμα που αναγράφεται στο μήνυμα δεν αντιπροσωπεύει πλέον το νέο περιεχόμενο. Ωστόσο πέφτει σε σας το βάρος να κάνετε όλη την εργασία που χρειάζεται ώστε να αποφύγετε αυτά τα επαναλαμβανόμενα θέματα.

[[bikeshed]]
[.title]
== Τι είναι το ""Bikeshed"";

Κυριολεκτικά το `bikeshed` είναι ένα μικρό εξωτερικό καταφύγιο όπου κάποιος μπορεί να φυλάξει το δίτροχο του (υπόστεγο ποδηλάτων). Στην ορολογία του FreeBSD ωστόσο, η λέξη αυτή χρησιμοποιείται για να αναφερόμαστε σε θέματα συζήτησης που είναι τόσο απλά ώστε (σχεδόν) καθένας να μπορεί να εκφέρει μια γνώμη για αυτά - και πολύ συχνά συμβαίνει ακριβώς αυτό. Η γέννηση αυτού του όρου εξηγείται με περισσότερη λεπτομέρεια σε link:{faq}#BIKESHED-PAINTING[αυτό το κείμενο]. Θα πρέπει να κατανοείτε την έννοια αυτού του όρου πριν αρχίσετε να στέλνετε μηνύματα σε οποιαδήποτε λίστα του FreeBSD.

Πιο γενικά, το bikeshed είναι ένα θέμα το οποίο τείνει να δημιουργεί περισσότερες παράπλευρες συζητήσεις και λεκτικούς διαξιφισμούς, αν δεν έχετε διαβάσει σχετικά με την προϊστορία του.

Σας παρακαλούμε να μας βοηθήσετε να κρατήσουμε τις λίστες ταχυδρομείου όσο το δυνατόν πιο χρήσιμες γίνεται για τον περισσότερο κόσμο, προσπαθώντας να αποφύγετε τα bikesheds όποτε είναι δυνατόν. Ευχαριστούμε!

[[acknowledgments]]
[.title]
== Ευχαριστίες

`{grog}`::
Ο αρχικός συγγραφέας του περισσότερου υλικού που αφορά τους κανονισμούς των λιστών, που προέρχονται από το άρθρο link:{freebsd-questions}[Πως να χρησιμοποιείτε με επιτυχία την λίστα ηλεκτρονικού ταχυδρομείου FreeBSD-questions].

`{linimon}`::
Δημιουργία του πρόχειρου αντίγραφου αυτού του FAQ.
",12246,True,3003.217983763436,median
"class ZCL_GEOCODER_CES definition
  public
  final
  create public .

public section.

  interfaces IF_GEOCODING_TOOL .

  class-data XNL type ABAP_CHAR1 value %_NEWLINE ##NO_TEXT.
  data JSON_DESERIALIZER type STRING value 'ABAP' ##NO_TEXT.

  methods HTTP_SEND
    importing
      !POST_DATA type STRING optional
      !URL type STRING optional
      !METHOD type STRING default 'GET'
      !HTTP_RFC_DEST type RFCDEST optional
      !FORM_FIELDS type TIHTTPNVP optional
      !CONTENT_TYPE type STRING optional
    exporting
      !HTTP_STATUS_CODE type I
      !HTTP_STATUS_MESSAGE type STRING
      value(RESPONSE_TEXT) type STRING
    exceptions
      SEND_ERROR
      RECEIVE_ERROR
      ERROR_CREATE_BY_URL
      ERROR_CREATE_BY_DEST
      PLEASE_SET_DESTINATION .
  class-methods GET_ABAP_REGION_BY_NAME
    importing
      !REGION type STRING
      !COUNTRY type LAND1
    returning
      value(REG_CODE) type REGIO .
  class-methods GET_ABAP_REGION_BY_POSTALCODE
    importing
      !POSTALCODE type AD_PSTCD1
      !COUNTRY type LAND1 optional
    returning
      value(REGION) type REGIO .
protected section.

  methods GEOCODE_ONE_ADDRESS_GOOGLE
    importing
      !AES_ADDRESS type AES_ADDR
      !XINFO type GEOCDXINFO optional
      !ALT_STRING type STRING optional
    changing
      !RESULTS type GEOCD_RES_TABLE
      !CHOICE type GEOCD_CHOICE_TABLE
      !RELEVANT_FIELDS type GEOCD_ADDR_RELFIELDS_SORTEDTAB
      !MESSAGES type AES_MSG_TABLE
      !CONTAINERS type AESC_SORTEDTABLE
      !CORRECTED_ADDRESSES type AES_ADDR_SORTEDTABLE
    exceptions
      HTTP_SEND_ERROR
      JSON_PARSE_ERROR
      ZCX_JSON .
  methods GEOCODE_ONE_ADDRESS_HCPQM
    importing
      !AES_ADDRESS type AES_ADDR
      !XINFO type GEOCDXINFO optional
      !ALT_STRING type STRING optional
    changing
      !RESULTS type GEOCD_RES_TABLE
      !CHOICE type GEOCD_CHOICE_TABLE
      !RELEVANT_FIELDS type GEOCD_ADDR_RELFIELDS_SORTEDTAB
      !MESSAGES type AES_MSG_TABLE
      !CONTAINERS type AESC_SORTEDTABLE
      !CORRECTED_ADDRESSES type AES_ADDR_SORTEDTABLE
    exceptions
      HTTP_SEND_ERROR
      ZCX_JSON .
private section.

  data HTTP_RFC_DEST type RFC_DEST .
  data GEOSERVICE type STRING value 'GOOGLE' ##NO_TEXT.
  data APIKEY type STRING .

  methods GET_CUSTOMIZING
    importing
      !SRCID type GEOSRCID
    exporting
      !RFC_DEST type RFCDEST
      !GEOSERVICE type STRING
      !APIKEY type STRING .
  methods SET_SAP_PRECISION
    importing
      !ACCURACY type I
    returning
      value(SAP_PRECISION) type STRING .
  methods PARSE_GMAPS_JSON
    importing
      !JSON_TEXT type STRING
    exporting
      !GEOCODE_HEADER type GEOCODE_HEADER_TYPE
      !PLACEMARKS type PLACEMARK_TTAB
    exceptions
      JSON_PARSE_ERROR
      ZCX_JSON .
  methods DESERIALIZE_JSON
    importing
      !JSON_STRING type STRING
      !DATA_TYPE type STRING optional
    changing
      value(ABAP_DATA) type ANY
    raising
      ZCX_JSON .
ENDCLASS.



CLASS ZCL_GEOCODER_CES IMPLEMENTATION.


  method DESERIALIZE_JSON.

    type-pools: abap.

    data:
      rtab       type abap_trans_resbind_tab,
      rlin       type abap_trans_resbind,
      oexcp      type ref to cx_root,
      etext      type string,
      json_xtext type xstring,
      json_text  type string.

    data:
      datadesc type ref to cl_abap_typedescr,
      strudesc type ref to cl_abap_structdescr,
      l_comp   type line of abap_compdescr_tab,
      dataref  type ref to data.

    field-symbols: <comp> type any.

    break-point id z_cesar.

    case me->json_deserializer.

      when 'ABAP'.

        call method zcl_json_handler=>json2abap
          exporting
            json_string = json_string
          changing
            abap_data   = abap_data.


      when 'TRID'.

        "" First, built table rtab for id transformation

        strudesc ?= cl_abap_structdescr=>describe_by_data( abap_data ).
        loop at strudesc->components into l_comp.
          rlin-name = l_comp-name.
          assign component l_comp-name of structure abap_data to <comp>.
          get reference of <comp> into dataref.
          rlin-value = dataref.
          append rlin to rtab.
          clear rlin.
          clear dataref.
        endloop.

        "" Second, convert JSON variable names to upper case.

        json_xtext = cl_abap_codepage=>convert_to( json_string ).
        data(reader) = cl_sxml_string_reader=>create( json_xtext ).
        data(writer) = cast if_sxml_writer( cl_sxml_string_writer=>create( type = if_sxml=>co_xt_json ) ).
        do.
          data(node) = reader->read_next_node( ).
          if node is initial.
            exit.
          endif.
          if node->type = if_sxml_node=>co_nt_element_open.
            data(attributes)  = cast if_sxml_open_element( node )->get_attributes( ).
            loop at attributes assigning field-symbol(<attribute>).
              if <attribute>->qname-name = 'name'.
                <attribute>->set_value(
                  to_upper( <attribute>->get_value( ) ) ).
              endif.
            endloop.
          endif.
          writer->write_node( node ).
        enddo.

        break-point id z_cesar.

        json_xtext = cast cl_sxml_string_writer( writer )->get_output( ) .
        json_text = cl_abap_codepage=>convert_from( json_xtext ).

        try.

            "" Then, do the transformation:

            call transformation id source xml json_text result (rtab).

          catch cx_root into oexcp.

            etext = oexcp->if_message~get_text( ).

            raise exception type zcx_json
              exporting
                message = etext.

        endtry.

      when others.
    endcase.

    break-point id z_cesar.


  endmethod.


method GEOCODE_ONE_ADDRESS_GOOGLE.

  data:
    lv_address     type adrc_struc,
    lv_result      type geocd_ress,
    lv_choice      type geocd_choi,
    lv_aesc        type aesc_tabs,
    lv_message     type aes_msg,
    aesc_container type aesc,
    ls_container   type line of aesc_sortedtable,
    corr_address   type line of aes_addr_sortedtable,
    wa_aesc        type aesc_struc.

  data:
    lv_address_query type string, "" Parámetro address para google maps
    form_fields      type tihttpnvp,
    waff             type ihttpnvp,
    jsonresp         type string,
*  cxmlresp           type xstring,
    geocode_header   type geocode_header_type,
    placemarks       type placemark_ttab,
    wa_placemark     type line of placemark_ttab,
    lv_timezone_r3   type timezone,
    lv_timestamp     type timestamp,
    abap_country     type land1,
    str_country      type landx,
    iso_country      type intca,
    li               type i,
    idx              type i.


  if alt_string is not initial.
    lv_address_query = alt_string.

  else.

    if aes_address-address-street is not initial.
*      concatenate aes_address-address-street ' ' into lv_address_query.
      lv_address_query = aes_address-address-street.
    endif.

    if aes_address-address-house_num1 is not initial.
      concatenate lv_address_query aes_address-address-house_num1 into lv_address_query separated by space.
    endif.

    if aes_address-address-post_code1 is not initial.
      concatenate lv_address_query aes_address-address-post_code1 into lv_address_query separated by space.
    endif.

    if aes_address-address-city1 is not initial.
      concatenate lv_address_query aes_address-address-city1 into lv_address_query separated by space.
    endif.

    if aes_address-address-country is not initial.
      call function 'DR_GET_COUNTRY_NAME'
        EXPORTING
          country  = aes_address-address-country
          language = 'E'
        IMPORTING
          name     = str_country.
      concatenate lv_address_query str_country into lv_address_query separated by space.
    endif.

  endif.


* Conecta con google
  waff-name = 'key'.
  waff-value = me->apikey.
  append waff to form_fields. clear waff.

  waff-name = 'address'.
  waff-value = lv_address_query.
  append waff to form_fields. clear waff.

** Google option for components=country:<XX>
  waff-name = 'components'.
  concatenate 'country' aes_address-address-country into waff-value separated by ':'.
  append waff to form_fields. clear waff.


  call method me->http_send
    exporting
*     POST_DATA              =
*     URL                    =
      method                 = 'GET'
      http_rfc_dest          = me->http_rfc_dest
      form_fields            = form_fields
    importing
*     HTTP_STATUS_CODE       =
*     HTTP_STATUS_MESSAGE    =
      response_text          = jsonresp
    exceptions
      send_error             = 1
      receive_error          = 2
      error_create_by_url    = 3
      error_create_by_dest   = 4
      please_set_destination = 5
      others                 = 6.
  if sy-subrc <> 0.
    raise http_send_error.
  endif.
*
*  data conv type ref to CL_ABAP_CONV_IN_CE.
*    data xlen type i.
*  conv = CL_ABAP_CONV_IN_CE=>create( encoding = 'UTF-8' ). "" ISO-8859-1
*  conv->convert( exporting input = cxmlresp  importing data = xmlresp len = xlen ).


* Parse google geocode JSON results

  call method me->parse_gmaps_json
    EXPORTING
      json_text        = jsonresp
    IMPORTING
      geocode_header   = geocode_header
      placemarks       = placemarks
    EXCEPTIONS
      json_parse_error = 1.

  if sy-subrc <> 0.
    raise json_parse_error.
  endif.

* Prepara result y choices, solo si google devuelve OK
  lv_result-id = aes_address-id.
  lv_result-info = geocode_header-status.


  if geocode_header-status eq 'OK'.

    describe table placemarks lines li.

* Dominio de valores para res:
*0  Geocodificación con éxito. Resultado unívoco.
*1  Geocodificación innecesaria (ninguna modificación relevante)
*2  Resultado no unívoco. La mejor selección (proceso de fondo)
*3  Resultado no unívoco. Existe selección de dirección.
*4  Resultado no unívoco. Ning.selección dirección (demasiados)
*5  Geocodificación no ha tenido éxito. Lon=Lat=Alt=invariable
*6  Herramienta no competente. Lon=Lat=Alt=invariable.
    if li eq 1.
      lv_result-res = 0.
      lv_result-info = 'Univoque Address'.
    elseif li gt 1.
      lv_result-res = 3.
      lv_result-info = 'Multiple Choice'.
    else.
      lv_result-res = 5.
      lv_result-info = 'Cannot Geocode Address'.
    endif.

    idx = 0.

    loop at placemarks into wa_placemark.

      add 1 to idx.

      lv_address = aes_address-address.
      ls_container-id = aes_address-id.
      lv_choice-id = aes_address-id.
      lv_choice-ranking = idx.
      lv_choice-percentage = '100'.

* Longitud y latitud y otros datos de geocodificación

      wa_aesc-service = 'GEOCODING'.
      wa_aesc-field   = 'SRCID'.
      wa_aesc-value   = xinfo-srcid.
      append wa_aesc to aesc_container.  clear wa_aesc.
      wa_aesc-service = 'GEOCODING'.
      wa_aesc-field   = 'LONGITUDE'.
      wa_aesc-value   = wa_placemark-longitude.
      append wa_aesc to aesc_container.  clear wa_aesc.
      wa_aesc-service = 'GEOCODING'.
      wa_aesc-field   = 'LATITUDE'.
      wa_aesc-value   = wa_placemark-latitude.
      append wa_aesc to aesc_container.  clear wa_aesc.
*      wa_aesc-service = 'GEOCODING'.
*      wa_aesc-field   = 'ALTITUDE'.
*      wa_aesc-value   = wa_placemark-altitude.
*      append wa_aesc to aesc_container.  clear wa_aesc.
      wa_aesc-service = 'GEOCODING'.
      wa_aesc-field   = 'PRECISID'.
      wa_aesc-value   = wa_placemark-accuracy.  "" Use google accuracy for that????
      append wa_aesc to aesc_container. clear wa_aesc.
      wa_aesc-service = 'GEOCODING'.
      wa_aesc-field   = 'TZONE'.
*  take the r/3 timezone for country
      data country type land1.
      country = wa_placemark-country.
      call function 'TZON_LOCATION_TIMEZONE'
        EXPORTING
          if_country        = country
        IMPORTING
          ef_timezone       = lv_timezone_r3
        EXCEPTIONS
          no_timezone_found = 1
          others            = 2.
      if sy-subrc eq 0.
        wa_aesc-value   = lv_timezone_r3.
      endif.
      append wa_aesc to aesc_container.  clear wa_aesc.
* Timestamp geocoding
      get time stamp field lv_timestamp.
      wa_aesc-service = 'GEOCODING'.
      wa_aesc-field   = 'SRCTSTMP'.
      wa_aesc-value   = lv_timestamp.
      append wa_aesc to aesc_container.  clear wa_aesc.

      ls_container-container = aesc_container.

* add container to Choices Dialog

      lv_choice-container = aesc_container.

      lv_address-city1 = wa_placemark-locality.
      lv_address-city2 = wa_placemark-distrito.
      lv_address-post_code1 = wa_placemark-postalcodenumber.
      lv_address-street = wa_placemark-street.
      lv_address-house_num1 = wa_placemark-street_number.
      iso_country = wa_placemark-country.
      call function 'COUNTRY_CODE_ISO_TO_SAP_ABA'
        exporting
          iso_code  = iso_country
        importing
          sap_code  = abap_country
*         NOT_UNIQUE       =
        exceptions
          not_found = 1
          others    = 2.
      if sy-subrc eq 0.
        lv_address-country = abap_country.
      endif.

      lv_address-region = get_abap_region_by_name( REGION = wa_placemark-provincia_name COUNTRY = abap_country ).
      if lv_address-region is initial.
        lv_address-region = get_abap_region_by_postalcode( postalcode = lv_address-post_code1 country = abap_country ).
      endif.


      lv_choice-address = lv_address.
      lv_choice-addr_short = wa_placemark-fulladdress.


      append lv_choice to choice.

      "" Solo si el resultado es unívoco devuelve containers y dirección corregida
      if lv_result-res = 0.
        modify table containers from ls_container.
        corr_address-id = aes_address-id.
        corr_address-address = lv_address.
        append corr_address to corrected_addresses.
      endif. ""lv_result-res = 0

      break-point id z_cesar.

      "" Y borras variables temporales
      clear corr_address.
      clear lv_choice.
      clear lv_address.
      clear ls_container.
      clear aesc_container.

    endloop.  "" Placemarks



  else.       "" Google Status other than OK
*5  Geocodificación no ha tenido éxito. Lon=Lat=Alt=invariable
*    lv_result-res = 5.
    lv_result-res = 6.
    lv_result-info = 'Failed Geocoding'.

  endif.      "" Google Status OK

  append lv_result to results.


endmethod.


method GEOCODE_ONE_ADDRESS_HCPQM.

  data:
    lv_address     type adrc_struc,
    lv_result      type geocd_ress,
    lv_choice      type geocd_choi,
    lv_aesc        type aesc_tabs,
    lv_message     type aes_msg,
    aesc_container type aesc,
    ls_container   type line of aesc_sortedtable,
    corr_address   type line of aes_addr_sortedtable,
    wa_aesc        type aesc_struc.

  data:
    lv_address_query type string, "" Parámetro address para google maps
    form_fields      type tihttpnvp,
    waff             type ihttpnvp,
    jsontext         type string,
    jsonquery        type string,
    jsonresp         type string,
*  cxmlresp           type xstring,
    geocode_header   type geocode_header_type,
    placemarks       type placemark_ttab,
    wa_placemark     type line of placemark_ttab,
    lv_timezone_r3   type timezone,
    lv_timestamp     type timestamp,
    abap_country     type land1,
    str_country      type landx,
    iso_country      type intca,
    li               type i,
    idx              type i,
    http_status_code type i,
    http_status_msg  type string.

* Prepare JSON query

  data: addressinput type hcp_query_addrinput.
  data: outputfields type stringtab.
  data: hcpresponse  type hcp_response.

  append 'addr_latitude' to outputfields.
  append 'addr_longitude' to outputfields.
  append 'geo_asmt_level' to outputfields.
  append 'geo_info_code' to outputfields.
  append 'geo_info_code_msg' to outputfields.
  append 'std_addr_prim_name1_4' to outputfields.
  append 'std_addr_prim_number_full' to outputfields.
  append 'std_addr_secaddr_no_floor_room' to outputfields.
  append 'std_addr_floor_number' to outputfields.
  append 'std_addr_room_number' to outputfields.
  append 'std_addr_building_name1_2' to outputfields.
  append 'addr_remainder_extra_pmb_full' to outputfields.
  append 'std_addr_point_of_ref1_2' to outputfields.
  append 'std_addr_locality3_4_full' to outputfields.
  append 'std_addr_locality_full' to outputfields.
  append 'std_addr_locality2_full' to outputfields.
  append 'std_addr_region_full' to outputfields.
  append 'std_addr_postcode_full' to outputfields.
  append 'std_addr_country_2char' to outputfields.
  append 'std_addr_po_box_number' to outputfields.
  append 'std_addr_po_box_locality_full' to outputfields.
  append 'std_addr_po_box_region_full' to outputfields.
  append 'std_addr_po_box_postcode_full' to outputfields.
  append 'std_addr_po_box_country_2char' to outputfields.
  append 'addr_info_code' to outputfields.
  append 'addr_info_code_msg' to outputfields.
  append 'addr_po_box_info_code' to outputfields.
  append 'addr_po_box_info_code_msg' to outputfields.

* Fill address input

  addressinput-street      = aes_address-address-street.
  addressinput-house_num   = aes_address-address-house_num1.
  addressinput-locality    = aes_address-address-city1.
  addressinput-postcode    = aes_address-address-post_code1.
  addressinput-country     = aes_address-address-country.

* Prepare post json query

  jsonquery = zcl_json_handler=>abap2json( name = 'addressInput' abap_data = addressinput ).
  jsontext = zcl_json_handler=>abap2json( name = 'outputFields' abap_data = outputfields ).
  concatenate '{' jsonquery ',' jsontext '}' into jsonquery.

  break-point id z_cesar.

  call method me->http_send
    exporting
      POST_DATA              = jsonquery
*     URL                    =
      method                 = 'POST'
      http_rfc_dest          = me->http_rfc_dest
      content_type           = 'application/json'
*     form_fields            = form_fields
    importing
      HTTP_STATUS_CODE       = http_status_code
      HTTP_STATUS_MESSAGE    = http_status_msg
      response_text          = jsonresp
    exceptions
      send_error             = 1
      receive_error          = 2
      error_create_by_url    = 3
      error_create_by_dest   = 4
      please_set_destination = 5
      others                 = 6.
  if sy-subrc <> 0.
    raise http_send_error.
  endif.

  break-point id z_cesar.

  deserialize_json( exporting json_string = jsonresp changing abap_data = hcpresponse ).

  break-point id z_cesar.

* HCP indicates success by 200 at HTTP status level
  if http_status_code eq 200.
    "" HCP only returns unique address, no multiple lists
    lv_result-res = 0.
    lv_result-info = 'Univoque Address'.
    lv_address = aes_address-address.
    ls_container-id = aes_address-id.
    lv_choice-id = aes_address-id.
    lv_choice-ranking = 1.
    lv_choice-percentage = '100'.

* Set longitude, latitude and others
    wa_aesc-service = 'GEOCODING'.
    wa_aesc-field   = 'SRCID'.
    wa_aesc-value   = xinfo-srcid.
    append wa_aesc to aesc_container.  clear wa_aesc.
    wa_aesc-service = 'GEOCODING'.
    wa_aesc-field   = 'LONGITUDE'.
    wa_aesc-value   = hcpresponse-addr_longitude.
    append wa_aesc to aesc_container.  clear wa_aesc.
    wa_aesc-service = 'GEOCODING'.
    wa_aesc-field   = 'LATITUDE'.
    wa_aesc-value   = hcpresponse-addr_latitude.
    append wa_aesc to aesc_container.  clear wa_aesc.
    wa_aesc-service = 'GEOCODING'.
    wa_aesc-field   = 'PRECISID'.
    wa_aesc-value   = hcpresponse-geo_asmt_level.  "" Use google accuracy for that????
    append wa_aesc to aesc_container. clear wa_aesc.
    wa_aesc-service = 'GEOCODING'.
    wa_aesc-field   = 'TZONE'.
*  take the r/3 timezone for country
    data country type land1.
    country = wa_placemark-country.
    call function 'TZON_LOCATION_TIMEZONE'
      EXPORTING
        if_country        = country
      IMPORTING
        ef_timezone       = lv_timezone_r3
      EXCEPTIONS
        no_timezone_found = 1
        others            = 2.
    if sy-subrc eq 0.
      wa_aesc-value   = lv_timezone_r3.
    endif.
    append wa_aesc to aesc_container.  clear wa_aesc.
* Timestamp geocoding
    get time stamp field lv_timestamp.
    wa_aesc-service = 'GEOCODING'.
    wa_aesc-field   = 'SRCTSTMP'.
    wa_aesc-value   = lv_timestamp.
    append wa_aesc to aesc_container.  clear wa_aesc.

    ls_container-container = aesc_container.
    lv_choice-container = aesc_container.

    lv_address-city1         = hcpresponse-std_addr_locality_full.
*      lv_address-city2        = wa_placemark-distrito.
    lv_address-post_code1    = hcpresponse-std_addr_postcode_full.
    lv_address-street        = hcpresponse-std_addr_prim_name1_4.
    lv_address-house_num1    = hcpresponse-std_addr_prim_number_full.
    iso_country              = hcpresponse-std_addr_country_2char.

    call function 'COUNTRY_CODE_ISO_TO_SAP_ABA'
      exporting
        iso_code  = iso_country
      importing
        sap_code  = abap_country
*       NOT_UNIQUE       =
      exceptions
        not_found = 1
        others    = 2.
    if sy-subrc eq 0.
      lv_address-country = abap_country.
    endif.

    lv_address-region = get_abap_region_by_name( REGION = hcpresponse-std_addr_region_full COUNTRY = abap_country ).
    if lv_address-region is initial.
      lv_address-region = get_abap_region_by_postalcode( postalcode = lv_address-post_code1 country = abap_country ).
    endif.

    lv_choice-address = lv_address.
    lv_choice-addr_short = lv_address-street.

    append lv_choice to choice.

    "" Solo si el resultado es unívoco devuelve containers y dirección corregida
    if lv_result-res = 0.
      modify table containers from ls_container.
      corr_address-id = aes_address-id.
      corr_address-address = lv_address.
      append corr_address to corrected_addresses.
    endif. ""lv_result-res = 0

    append lv_result to results.


  endif.





endmethod.


  method GET_ABAP_REGION_BY_NAME.

    types:
      begin of reglist_type,
        bezei type string,
        bland type regio,
      end of reglist_type.

    data reglist type hashed table of reglist_type with unique key bezei.
    field-symbols <reg> type reglist_type.

    select * from T005U into corresponding fields of table reglist  where land1 eq country and spras eq SY-LANGU.

    if sy-subrc eq 0.

      read table reglist with table key bezei = region assigning <reg>.

      if sy-subrc eq 0.

        reg_code = <reg>-bland.

      endif.

    endif.


  endmethod.


  method GET_ABAP_REGION_BY_POSTALCODE.

    "" Get region from postal code
    "" It only works like this in France and Spain: (AFAIK)
    "" The first two digits indicate the 'département' (France) or ""provicia"" (Spain).

    data(pcode) = postalcode.
    condense pcode.

    if strlen( pcode ) eq 5.

       region = substring( val = pcode off = 0 len = 2 ).

    endif.


  endmethod.


method GET_CUSTOMIZING.

  data:
  lv_geocd2cls type geocd2cls.

* read http rfc dest from customizing
  select single * from geocd2cls into lv_geocd2cls where srcid = srcid.

  if sy-subrc ne 0.
*     if nothing found set a ""sensible"" default
    rfc_dest = 'HTTP_GMAPS_GEOCODE_SIM'.
    geoservice = 'GOOGLE'.
    exit.
  else.

    rfc_dest = lv_geocd2cls-rfc_dest.

    if lv_geocd2cls-funcname is not initial.
      geoservice = lv_geocd2cls-funcname.
      translate geoservice to upper case.
    endif.

    apikey = lv_geocd2cls-infostring.

  endif.

endmethod.


method HTTP_SEND.

  data client type ref to if_http_client.
  data destination(255) type c.
  data errcode type sysubrc.
  data errmesg type string.
  data oref type ref to cx_root.

  if http_rfc_dest is not initial.

    destination = http_rfc_dest.

    call method cl_http_client=>create_by_destination
      exporting
        destination              = destination
      importing
        client                   = client
      exceptions
        argument_not_found       = 1
        destination_not_found    = 2
        destination_no_authority = 3
        plugin_not_active        = 4
        internal_error           = 5
        others                   = 6.
    if sy-subrc <> 0.
      raise error_create_by_dest.
    endif.

  elseif url is not initial.

    call method cl_http_client=>create_by_url
      exporting
        url                = url
*    PROXY_HOST         =
*    PROXY_SERVICE      =
*    SSL_ID             =
*    SAP_USERNAME       =
*    SAP_CLIENT         =
      importing
        client             = client
      exceptions
        argument_not_found = 1
        plugin_not_active  = 2
        internal_error     = 3
        others             = 4
            .
    if sy-subrc <> 0.
      raise error_create_by_url.
    endif.

  else.

    raise please_set_destination.

  endif.

  client->request->set_method( method ).
  if method eq 'POST' and post_data is not initial.
    client->request->set_cdata( post_data ).
    if content_type is not initial.
      client->request->set_content_type( content_type ).
    endif.
  endif.

  if form_fields is not initial.
    client->request->set_form_fields( form_fields ).
  endif.

  try.
      client->send( ).
    catch cx_root into oref.
  endtry.
  client->get_last_error( importing code = errcode message = errmesg ).

  if errcode ne 0.
    raise send_error.
  endif.

  try.
      client->receive( ).
    catch cx_root into oref.
  endtry.
  client->get_last_error( importing code = errcode message = errmesg ).

  if errcode ne 0.
    raise receive_error.
  endif.


  client->response->get_status( importing code = http_status_code reason = http_status_message ).
  response_text = client->response->get_cdata( ).



endmethod.


method IF_GEOCODING_TOOL~GEOCODE.

  break-point id z_cesar.

  data method_name type string.

  data:
  lv_aes_address type aes_addr.


* Get HTTP rfc destination from customizing:
  get_customizing(
        exporting
                    srcid = xinfo-srcid
        importing
                    rfc_dest   = me->http_rfc_dest
                    geoservice = me->geoservice
                    apikey     = me->apikey ).

* Set method for geoservice:
  concatenate 'GEOCODE_ONE_ADDRESS_' me->geoservice into method_name.

* Process addresses:
  loop at addresses into lv_aes_address.

*   geocode addresses one by one
    call method (method_name)
      exporting
        aes_address         = lv_aes_address
        xinfo               = xinfo
      changing
        results             = results
        choice              = choice
        relevant_fields     = relevant_fields
        messages            = messages
        containers          = containers
        corrected_addresses = corrected_addresses.

  endloop.

endmethod.


method PARSE_GMAPS_JSON.

  data google_results type zgoogle_results_type.
  data grestabfortrid type table of zgoogle_results_type.
  data res_wa         type ZGOOGLE_RESULTS_ITEM.
  data adc_wa         type ZGOOGLE_ADDCOMP_ITEM.

  data res_type type string.  "" result types
  data adc_type type string.  "" address components types

  data wa_placemark type line of placemark_ttab.

* Process Google returned JSON:

  CALL METHOD ME->DESERIALIZE_JSON
    EXPORTING
      JSON_STRING = json_text
      DATA_TYPE   = 'ZGOOGLE_RESULTS_TYPE'
    CHANGING
      ABAP_DATA   = google_results.

  geocode_header-status = google_results-status.
  geocode_header-error_message = google_results-error_message.

  if google_results-status ne 'OK'.
    exit.
  endif.

  loop at google_results-results into res_wa.

    wa_placemark-id           = res_wa-place_id.
    wa_placemark-fulladdress  = res_wa-formatted_address.
    wa_placemark-accuracy     = res_wa-geometry-location_type.
    wa_placemark-longitude    = res_wa-geometry-location-lng.
    wa_placemark-latitude     = res_wa-geometry-location-lat.

    find first occurrence of 'street_address' in table res_wa-types.

    if sy-subrc eq 0. "" process it, it looks like a street address

      loop at res_wa-address_components into adc_wa.

        data adcomp type string.
        read table adc_wa-types index 1 into adcomp.
        if adcomp eq 'political'.
          read table adc_wa-types index 2 into adcomp.
        endif.

        case adcomp.
          when 'street_number'.
            wa_placemark-street_number = adc_wa-long_name.
          when 'route'.
            wa_placemark-street = adc_wa-long_name.
          when 'locality'.
            wa_placemark-locality = adc_wa-long_name.
          when 'administrative_area_level_2'.
            wa_placemark-provincia = adc_wa-short_name.
            wa_placemark-provincia_name = adc_wa-long_name.
          when 'administrative_area_level_1'.
            wa_placemark-comunidad = adc_wa-long_name.
          when 'country'.
            wa_placemark-country = adc_wa-short_name.
            wa_placemark-country_name = adc_wa-long_name.
          when 'postal_code'.
            wa_placemark-postalcodenumber = adc_wa-long_name.
        endcase.

      endloop.

    endif.

    append wa_placemark to placemarks.
    clear wa_placemark.

  endloop.


endmethod.


method SET_SAP_PRECISION.
* This method sets SAP APO defined precission codes
* for geocoding, as defined in a SAP APO system.
* The mapping is a bit ""subjective"" as there is not one-to-one correspondence.
* It is not always possible to map service accuracy to APO precision.

* SAP precission codes (in APO system):
*0000  No existen datos
*0100  Mundo
*0200  Continente
*0300  País
*0400  Región
*0500  Límite de municipio
*0600  Código postal
*0700  Población
*0800  Distrito
*0900  Punto medio de calle
*1000  Punto medio rango números casas (sección de calle)
*1100  Número casa (interpolado)
*1200  Número casa (exacto)
*1300  Número casa c/suplemento (p. ej., Neurottstr.7b)


  case accuracy.
    when 0.
      sap_precision = '0000'.
    when 1.
      sap_precision = '0300'.
    when 2.
      sap_precision = '0400'.
    when 3.
      sap_precision = '0500'.
    when 4.
      sap_precision = '0700'.
    when 5.
      sap_precision = '0600'.
    when 6.
      sap_precision = '0900'.
    when 7.
      sap_precision = '1000'.
    when 8 or 9.
      sap_precision = '1300'.
    when others.
      "" which others?
  endcase.




endmethod.
ENDCLASS.
",7803,False,1505.0355720585828,median
"= v1.RoleBinding
{product-author}
{product-version}
:data-uri:
:icons:
:toc: macro
:toc-title:
:toclevels: 2

toc::[]

== Description
[%hardbreaks]
RoleBinding references a role, but does not contain it.  It can reference a Role in the same namespace or a ClusterRole in the global namespace. It adds who information via Subjects and namespace information by which namespace it exists in.  RoleBindings in a given namespace only have effect in that namespace.

== Object Schema
Expand or mouse-over a field for more information about it.

++++
<pre>
<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=""(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."">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><details><summary><span title=""(v1.RoleRef) RoleRef can reference a Role in the current namespace or a ClusterRole in the global namespace. If the RoleRef cannot be resolved, the Authorizer must return an error."">roleRef</span>:
</summary><div style=""margin-left:13px;"">  <span title=""(string) APIGroup is the group for the resource being referenced"">apiGroup</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) Kind is the type of resource being referenced"">kind</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) Name is the name of resource being referenced"">name</span>:
</div></details><details><summary><span title=""(array) Subjects holds references to the objects the role applies to."">subjects</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string) APIGroup holds the API group of the referenced subject. Defaults to &#34;&#34; for ServiceAccount subjects. Defaults to &#34;rbac.authorization.k8s.io&#34; for User and Group subjects."">apiGroup</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) Kind of object being referenced. Values defined by this API group are &#34;User&#34;, &#34;Group&#34;, and &#34;ServiceAccount&#34;. If the Authorizer does not recognized the kind value, the Authorizer should report an error."">kind</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) Name of the object being referenced."">name</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) Namespace of the referenced object.  If the object kind is non-namespace, such as &#34;User&#34; or &#34;Group&#34;, and this value is not empty the Authorizer should report an error."">namespace</span>:
</div></details>
</pre>
++++

== Operations

[[Post-apis-rbac.authorization.k8s.io-v1-rolebindings]]
=== Create a RoleBinding
Create a RoleBinding

==== HTTP request
----
POST /apis/rbac.authorization.k8s.io/v1/rolebindings HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json'

{
  ""kind"": ""RoleBinding"",
  ""apiVersion"": ""rbac.authorization.k8s.io/v1"",
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X POST \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json' \\
    https://$ENDPOINT/apis/rbac.authorization.k8s.io/v1/rolebindings <<'EOF'
{
  ""kind"": ""RoleBinding"",
  ""apiVersion"": ""rbac.authorization.k8s.io/v1"",
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.RoleBinding
|===

==== 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.RoleBinding
|201 Created|v1.RoleBinding
|202 Accepted|v1.RoleBinding
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Post-apis-rbac.authorization.k8s.io-v1-namespaces-namespace-rolebindings]]
=== Create a RoleBinding in a namespace
Create a RoleBinding

==== HTTP request
----
POST /apis/rbac.authorization.k8s.io/v1/namespaces/$NAMESPACE/rolebindings HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json'

{
  ""kind"": ""RoleBinding"",
  ""apiVersion"": ""rbac.authorization.k8s.io/v1"",
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X POST \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json' \\
    https://$ENDPOINT/apis/rbac.authorization.k8s.io/v1/namespaces/$NAMESPACE/rolebindings <<'EOF'
{
  ""kind"": ""RoleBinding"",
  ""apiVersion"": ""rbac.authorization.k8s.io/v1"",
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.RoleBinding
|===

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|namespace|object name and auth scope, such as for teams and projects
|===

==== 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.RoleBinding
|201 Created|v1.RoleBinding
|202 Accepted|v1.RoleBinding
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Get-apis-rbac.authorization.k8s.io-v1-namespaces-namespace-rolebindings-name]]
=== Get a RoleBinding in a namespace
Read the specified RoleBinding

==== HTTP request
----
GET /apis/rbac.authorization.k8s.io/v1/namespaces/$NAMESPACE/rolebindings/$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/apis/rbac.authorization.k8s.io/v1/namespaces/$NAMESPACE/rolebindings/$NAME
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the RoleBinding
|namespace|object name and auth scope, such as for teams and projects
|===

==== 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.RoleBinding
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Get-apis-rbac.authorization.k8s.io-v1-rolebindings]]
=== Get all RoleBindings
List or watch objects of kind RoleBinding

==== HTTP request
----
GET /apis/rbac.authorization.k8s.io/v1/rolebindings 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/apis/rbac.authorization.k8s.io/v1/rolebindings
----

==== 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.
|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.RoleBindingList
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Get-apis-rbac.authorization.k8s.io-v1-namespaces-namespace-rolebindings]]
=== Get all RoleBindings in a namespace
List or watch objects of kind RoleBinding

==== HTTP request
----
GET /apis/rbac.authorization.k8s.io/v1/namespaces/$NAMESPACE/rolebindings 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/apis/rbac.authorization.k8s.io/v1/namespaces/$NAMESPACE/rolebindings
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|namespace|object name and auth scope, such as for teams and projects
|===

==== 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.
|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.RoleBindingList
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Get-apis-rbac.authorization.k8s.io-v1-watch-namespaces-namespace-rolebindings-name]]
=== Watch a RoleBinding in a namespace
Watch changes to an object of kind RoleBinding

==== HTTP request
----
GET /apis/rbac.authorization.k8s.io/v1/watch/namespaces/$NAMESPACE/rolebindings/$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/apis/rbac.authorization.k8s.io/v1/watch/namespaces/$NAMESPACE/rolebindings/$NAME
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the RoleBinding
|namespace|object name and auth scope, such as for teams and projects
|===

==== 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.
|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-apis-rbac.authorization.k8s.io-v1-watch-rolebindings]]
=== Watch all RoleBindings
Watch individual changes to a list of RoleBinding

==== HTTP request
----
GET /apis/rbac.authorization.k8s.io/v1/watch/rolebindings 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/apis/rbac.authorization.k8s.io/v1/watch/rolebindings
----

==== 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.
|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-apis-rbac.authorization.k8s.io-v1-watch-namespaces-namespace-rolebindings]]
=== Watch all RoleBindings in a namespace
Watch individual changes to a list of RoleBinding

==== HTTP request
----
GET /apis/rbac.authorization.k8s.io/v1/watch/namespaces/$NAMESPACE/rolebindings 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/apis/rbac.authorization.k8s.io/v1/watch/namespaces/$NAMESPACE/rolebindings
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|namespace|object name and auth scope, such as for teams and projects
|===

==== 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.
|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-apis-rbac.authorization.k8s.io-v1-namespaces-namespace-rolebindings-name]]
=== Update a RoleBinding in a namespace
Replace the specified RoleBinding

==== HTTP request
----
PUT /apis/rbac.authorization.k8s.io/v1/namespaces/$NAMESPACE/rolebindings/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json'

{
  ""kind"": ""RoleBinding"",
  ""apiVersion"": ""rbac.authorization.k8s.io/v1"",
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X PUT \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json' \\
    https://$ENDPOINT/apis/rbac.authorization.k8s.io/v1/namespaces/$NAMESPACE/rolebindings/$NAME <<'EOF'
{
  ""kind"": ""RoleBinding"",
  ""apiVersion"": ""rbac.authorization.k8s.io/v1"",
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.RoleBinding
|===

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the RoleBinding
|namespace|object name and auth scope, such as for teams and projects
|===

==== 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.RoleBinding
|201 Created|v1.RoleBinding
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Patch-apis-rbac.authorization.k8s.io-v1-namespaces-namespace-rolebindings-name]]
=== Patch a RoleBinding in a namespace
Partially update the specified RoleBinding

==== HTTP request
----
PATCH /apis/rbac.authorization.k8s.io/v1/namespaces/$NAMESPACE/rolebindings/$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/apis/rbac.authorization.k8s.io/v1/namespaces/$NAMESPACE/rolebindings/$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 RoleBinding
|namespace|object name and auth scope, such as for teams and projects
|===

==== 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.RoleBinding
|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-apis-rbac.authorization.k8s.io-v1-namespaces-namespace-rolebindings-name]]
=== Delete a RoleBinding in a namespace
Delete a RoleBinding

==== HTTP request
----
DELETE /apis/rbac.authorization.k8s.io/v1/namespaces/$NAMESPACE/rolebindings/$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/apis/rbac.authorization.k8s.io/v1/namespaces/$NAMESPACE/rolebindings/$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 RoleBinding
|namespace|object name and auth scope, such as for teams and projects
|===

==== 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-apis-rbac.authorization.k8s.io-v1-namespaces-namespace-rolebindings]]
=== Delete all RoleBindings in a namespace
Delete collection of RoleBinding

==== HTTP request
----
DELETE /apis/rbac.authorization.k8s.io/v1/namespaces/$NAMESPACE/rolebindings 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/apis/rbac.authorization.k8s.io/v1/namespaces/$NAMESPACE/rolebindings
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|namespace|object name and auth scope, such as for teams and projects
|===

==== 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.
|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



",12523,False,2439.543710658294,median
"CLASS zcl_otlp_encode_trace DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.

* MIT License, Copyright (c) 2022 Heliconia Labs
* https://github.com/heliconialabs/abap-opentelemetry

    CLASS-METHODS encode
      IMPORTING
        !it_resource_spans TYPE zif_otlp_model_trace=>ty_resource_spans
      RETURNING
        VALUE(rv_hex)      TYPE xstring .
  PROTECTED SECTION.

    CLASS-METHODS to_xstring
      IMPORTING
        !iv_string        TYPE string
      RETURNING
        VALUE(rv_xstring) TYPE xstring .
    CLASS-METHODS encode_resource_spans
      IMPORTING
        !is_resource_spans TYPE zif_otlp_model_trace=>ty_resource_span
      RETURNING
        VALUE(rv_hex)      TYPE xstring .
    CLASS-METHODS encode_scope_spans
      IMPORTING
        !is_scope_spans TYPE zif_otlp_model_trace=>ty_scope_spans
      RETURNING
        VALUE(rv_hex)   TYPE xstring .
    CLASS-METHODS encode_instrumentation_scope
      IMPORTING
        !is_instrumentation_scope TYPE zif_otlp_model_common=>ty_instrumentation_scope
      RETURNING
        VALUE(rv_hex)             TYPE xstring .
    CLASS-METHODS encode_span
      IMPORTING
        !is_span      TYPE zif_otlp_model_trace=>ty_span
      RETURNING
        VALUE(rv_hex) TYPE xstring .
    CLASS-METHODS encode_resource
      IMPORTING
        !is_resource  TYPE zif_otlp_model_resource=>ty_resource
      RETURNING
        VALUE(rv_hex) TYPE xstring .
    CLASS-METHODS encode_key_value
      IMPORTING
        !is_key_value TYPE zif_otlp_model_common=>ty_key_value
      RETURNING
        VALUE(rv_hex) TYPE xstring .
    CLASS-METHODS encode_any_value
      IMPORTING
        !is_any_value TYPE zif_otlp_model_common=>ty_any_value
      RETURNING
        VALUE(rv_hex) TYPE xstring .
    CLASS-METHODS encode_status
      IMPORTING
        !is_status    TYPE zif_otlp_model_trace=>ty_status
      RETURNING
        VALUE(rv_hex) TYPE xstring .
    CLASS-METHODS encode_link
      IMPORTING
        !is_link      TYPE zif_otlp_model_trace=>ty_link
      RETURNING
        VALUE(rv_hex) TYPE xstring .
    CLASS-METHODS encode_event
      IMPORTING
        !is_event     TYPE zif_otlp_model_trace=>ty_event
      RETURNING
        VALUE(rv_hex) TYPE xstring .
  PRIVATE SECTION.
ENDCLASS.



CLASS ZCL_OTLP_ENCODE_TRACE IMPLEMENTATION.


  METHOD encode.

    DATA(lo_stream) = NEW lcl_protobuf_stream( ).

* top level, message TracesData
    LOOP AT it_resource_spans INTO DATA(ls_resource_span).
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 1
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( encode_resource_spans( ls_resource_span ) ).
    ENDLOOP.

    rv_hex = lo_stream->get( ).

  ENDMETHOD.


  METHOD encode_any_value.

    DATA(lo_stream) = NEW lcl_protobuf_stream( ).

    IF is_any_value-string_value IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 1
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( to_xstring( is_any_value-string_value ) ).
    ELSEIF is_any_value-bool_value IS NOT INITIAL.
      ASSERT 1 = 'todo'.
    ELSEIF is_any_value-int_value IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 3
        wire_type    = lcl_protobuf_stream=>gc_wire_type-varint ) ).
      lo_stream->encode_varint( is_any_value-int_value ).
    ELSEIF is_any_value-double_value  IS NOT INITIAL.
      ASSERT 1 = 'out of scope'.
    ELSEIF is_any_value-array_value   IS NOT INITIAL.
      ASSERT 1 = 'out of scope'.
    ELSEIF is_any_value-kvlist_value  IS NOT INITIAL.
      ASSERT 1 = 'out of scope'.
    ELSEIF is_any_value-bytes_value IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 7
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( is_any_value-bytes_value ).
    ENDIF.

    rv_hex = lo_stream->get( ).

  ENDMETHOD.


  METHOD encode_event.

    DATA(lo_stream) = NEW lcl_protobuf_stream( ).

    IF is_event-time_unix_nano IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 1
        wire_type    = lcl_protobuf_stream=>gc_wire_type-bit64 ) ).
      lo_stream->encode_fixed64( is_event-time_unix_nano ).
    ENDIF.

    IF is_event-name IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 2
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( to_xstring( is_event-name ) ).
    ENDIF.

    LOOP AT is_event-attributes INTO DATA(ls_attribute).
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 3
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( encode_key_value( ls_attribute ) ).
    ENDLOOP.

    IF is_event-dropped_attributes_count IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 4
        wire_type    = lcl_protobuf_stream=>gc_wire_type-varint ) ).
      lo_stream->encode_varint( is_event-dropped_attributes_count ).
    ENDIF.

    rv_hex = lo_stream->get( ).

  ENDMETHOD.


  METHOD encode_instrumentation_scope.

    DATA(lo_stream) = NEW lcl_protobuf_stream( ).

    IF is_instrumentation_scope-name IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 1
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( to_xstring( is_instrumentation_scope-name ) ).
    ENDIF.

    IF is_instrumentation_scope-version IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 2
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( to_xstring( is_instrumentation_scope-version ) ).
    ENDIF.

    rv_hex = lo_stream->get( ).

  ENDMETHOD.


  METHOD encode_key_value.

    DATA(lo_stream) = NEW lcl_protobuf_stream( ).

    lo_stream->encode_field_and_type( VALUE #(
      field_number = 1
      wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
    lo_stream->encode_delimited( to_xstring( is_key_value-key ) ).

    lo_stream->encode_field_and_type( VALUE #(
      field_number = 2
      wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
    lo_stream->encode_delimited( encode_any_value( is_key_value-value ) ).

    rv_hex = lo_stream->get( ).

  ENDMETHOD.


  METHOD encode_link.

    DATA(lo_stream) = NEW lcl_protobuf_stream( ).

    IF is_link-trace_id IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 1
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( is_link-trace_id ).
    ENDIF.

    IF is_link-span_id IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 2
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( is_link-span_id ).
    ENDIF.

    lo_stream->encode_field_and_type( VALUE #(
      field_number = 3
      wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
    lo_stream->encode_delimited( to_xstring( is_link-trace_state ) ).

    LOOP AT is_link-attributes INTO DATA(ls_attribute).
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 4
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( encode_key_value( ls_attribute ) ).
    ENDLOOP.

    IF is_link-dropped_attributes_count IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 5
        wire_type    = lcl_protobuf_stream=>gc_wire_type-varint ) ).
      lo_stream->encode_varint( is_link-dropped_attributes_count ).
    ENDIF.

    rv_hex = lo_stream->get( ).

  ENDMETHOD.


  METHOD encode_resource.

    DATA(lo_stream) = NEW lcl_protobuf_stream( ).

    LOOP AT is_resource-attributes INTO DATA(ls_attribute).
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 1
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( encode_key_value( ls_attribute ) ).
    ENDLOOP.

    IF is_resource-dropped_attributes_count IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 2
        wire_type    = lcl_protobuf_stream=>gc_wire_type-varint ) ).
      lo_stream->encode_varint( is_resource-dropped_attributes_count ).
    ENDIF.

    rv_hex = lo_stream->get( ).

  ENDMETHOD.


  METHOD encode_resource_spans.

    DATA(lo_stream) = NEW lcl_protobuf_stream( ).

    IF is_resource_spans-resource IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 1
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( encode_resource( is_resource_spans-resource ) ).
    ENDIF.

    LOOP AT is_resource_spans-scope_spans INTO DATA(ls_scope_spans).
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 2
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( encode_scope_spans( ls_scope_spans ) ).
    ENDLOOP.

    IF is_resource_spans-schema_url IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 3
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( to_xstring( is_resource_spans-schema_url ) ).
    ENDIF.

    rv_hex = lo_stream->get( ).

  ENDMETHOD.


  METHOD encode_scope_spans.

    DATA(lo_stream) = NEW lcl_protobuf_stream( ).

    IF is_scope_spans-scope IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 1
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( encode_instrumentation_scope( is_scope_spans-scope ) ).
    ENDIF.

    LOOP AT is_scope_spans-spans INTO DATA(ls_span).
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 2
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( encode_span( ls_span ) ).
    ENDLOOP.

    IF is_scope_spans-schema_url IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 3
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( to_xstring( is_scope_spans-schema_url ) ).
    ENDIF.

    rv_hex = lo_stream->get( ).

  ENDMETHOD.


  METHOD encode_span.

    DATA(lo_stream) = NEW lcl_protobuf_stream( ).

    IF is_span-trace_id IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 1
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( is_span-trace_id ).
    ENDIF.

    IF is_span-span_id IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 2
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( is_span-span_id ).
    ENDIF.

    IF is_span-trace_state IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 3
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( to_xstring( is_span-trace_state ) ).
    ENDIF.

    IF is_span-parent_span_id IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 4
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( is_span-parent_span_id ).
    ENDIF.

    IF is_span-name IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 5
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( to_xstring( is_span-name ) ).
    ENDIF.

    IF is_span-kind IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 6
        wire_type    = lcl_protobuf_stream=>gc_wire_type-varint ) ).
      lo_stream->encode_varint( is_span-kind ).
    ENDIF.

    IF is_span-start_time_unix_nano IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 7
        wire_type    = lcl_protobuf_stream=>gc_wire_type-bit64 ) ).
      lo_stream->encode_fixed64( is_span-start_time_unix_nano ).
    ENDIF.

    IF is_span-end_time_unix_nano IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 8
        wire_type    = lcl_protobuf_stream=>gc_wire_type-bit64 ) ).
      lo_stream->encode_fixed64( is_span-end_time_unix_nano ).
    ENDIF.

    LOOP AT is_span-attributes INTO DATA(ls_attribute).
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 9
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( encode_key_value( ls_attribute ) ).
    ENDLOOP.

    IF is_span-dropped_attributes_count IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 10
        wire_type    = lcl_protobuf_stream=>gc_wire_type-varint ) ).
      lo_stream->encode_varint( is_span-dropped_attributes_count ).
    ENDIF.

    LOOP AT is_span-events INTO DATA(ls_event).
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 11
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( encode_event( ls_event ) ).
    ENDLOOP.

    IF is_span-dropped_events_count IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 12
        wire_type    = lcl_protobuf_stream=>gc_wire_type-varint ) ).
      lo_stream->encode_varint( is_span-dropped_events_count ).
    ENDIF.

    LOOP AT is_span-links INTO DATA(ls_link).
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 13
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( encode_link( ls_link ) ).
    ENDLOOP.

    IF is_span-dropped_links_count IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 14
        wire_type    = lcl_protobuf_stream=>gc_wire_type-varint ) ).
      lo_stream->encode_varint( is_span-dropped_links_count ).
    ENDIF.

    IF is_span-status IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 14
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( encode_status( is_span-status ) ).
    ENDIF.

    rv_hex = lo_stream->get( ).

  ENDMETHOD.


  METHOD encode_status.

    DATA(lo_stream) = NEW lcl_protobuf_stream( ).

    IF is_status-message IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 2
        wire_type    = lcl_protobuf_stream=>gc_wire_type-length_delimited ) ).
      lo_stream->encode_delimited( to_xstring( is_status-message ) ).
    ENDIF.

    IF is_status-code IS NOT INITIAL.
      lo_stream->encode_field_and_type( VALUE #(
        field_number = 3
        wire_type    = lcl_protobuf_stream=>gc_wire_type-varint ) ).
      lo_stream->encode_varint( is_status-code ).
    ENDIF.

    rv_hex = lo_stream->get( ).

  ENDMETHOD.


  METHOD to_xstring.

* argh, steampunk compatibility

    DATA lo_conv TYPE REF TO object.

    TRY.
        CALL METHOD ('CL_ABAP_CONV_CODEPAGE')=>create_out
          RECEIVING
            instance = lo_conv.

        CALL METHOD lo_conv->('IF_ABAP_CONV_OUT~CONVERT')
          EXPORTING
            source = iv_string
          RECEIVING
            result = rv_xstring.
      CATCH cx_sy_dyn_call_illegal_class.
        DATA(lv_conv_out_class) = 'CL_ABAP_CONV_OUT_CE'.
* workaround for not triggering static analysis error in Steampunk
        CALL METHOD (lv_conv_out_class)=>create
          EXPORTING
            encoding = 'UTF-8'
          RECEIVING
            conv     = lo_conv.

        CALL METHOD lo_conv->('CONVERT')
          EXPORTING
            data   = iv_string
          IMPORTING
            buffer = rv_xstring.
    ENDTRY.

  ENDMETHOD.
ENDCLASS.
",4151,False,1233.3300885356957,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: 'c' for inserts/create; '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 (80 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
| *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: 'c' for inserts/create; '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[]
",12108,True,3001.869082361825,median
"int _ZN12PlayerObject10updateJumpEPvf(int arg0) {
    delta = intrinsic_movss(delta, xmm0);
    r15 = arg0;
    r14 = *(int8_t *)(r15 + 0x778);
    rax = 0x0;
    rbx = 0xd5;
    if (r14 == 0x0) {
            rbx = 0x0;
    }
    *(int32_t *)(r15 + 0x754) = rbx;
    rax = rand();
    xmm0 = intrinsic_cvtsi2ss(0x0, rax);
    xmm0 = intrinsic_mulss(xmm0, *(int32_t *)its 0.0);
    xmm0 = intrinsic_mulss(xmm0, *(int32_t *)value 1000.00);
    rax = intrinsic_cvttss2si(rax, xmm0);
    *(int32_t *)(r15 + 0x750) = rax;
    *(int32_t *)(r15 + 0x74c) = rbx + rax;
    r10 = *(int8_t *)(r15 + 0x778);
    xmm0 = intrinsic_movsd(xmm0, *(r15 + 0x618));
    rdx = *(int8_t *)(r15 + 0x745);
    r9 = *(int8_t *)(r15 + 0x774);
    rax = rdx;
    if (r9 != 0x0) {
            rax = (*(int8_t *)(r15 + 0x746) != 0x0 ? 0x1 : 0x0) & (rdx != 0x0 ? 0x1 : 0x0);
    }
    rcx = *(int8_t *)(r15 + 0x770);
    r8 = *(int8_t *)(r15 + 0x772);
    if (r8 == 0x0) goto loc_10021976c;

loc_10021972a :
    xmm1 = intrinsic_movss(xmm1, *(int32_t *)(r15 + 0x77c));
    asm{ cmpneqss   xmm1, dword [value 1.0] };
    rsi = zero_extend_32(xmm1) & 0x1;
    rdi = 0x1;
    xmm5 = intrinsic_movss(xmm5, *(int32_t *)0x100510eb8);
    if (rcx == 0x0) goto loc_100219813;

loc_100219756 :
    if (rsi == 0x0) {
            xmm6 = intrinsic_movss(xmm6, *(int32_t *)value 1.0);
    }
    else {
            xmm6 = intrinsic_movss(xmm6, *(int32_t *)0x10050d3dc);
    }
    goto loc_100219856;

loc_100219856 :
    xmm2 = intrinsic_movss(xmm2, *(int32_t *)0x10050c764);
    xmm7 = intrinsic_movaps(xmm7, xmm2);
    xmm7 = intrinsic_divss(xmm7, xmm6);
    xmm8 = intrinsic_movss(xmm8, *(int32_t *)0x100510ebc);
    xmm8 = intrinsic_divss(xmm8, xmm6);
    r8 = *(int8_t *)(r15 + 0x776);
    xmm1 = intrinsic_movsd(xmm1, *(r15 + 0x760));
    xmm3 = intrinsic_xorpd(xmm3, xmm3);
    if (r8 != 0x0) {
            xmm3 = intrinsic_ucomisd(xmm3, xmm1);
            if (xmm3 >= 0x0) {
                    xmm4 = intrinsic_movaps(xmm4, *(int128_t *)value -0.00);
                    xmm4 = intrinsic_xorps(xmm4, xmm7);
                    xmm4 = intrinsic_cvtss2sd(xmm4, xmm4);
                    xmm1 = intrinsic_ucomisd(xmm1, xmm4);
                    if (xmm1 <= 0x0) {
                            xmm1 = intrinsic_ucomisd(xmm1, xmm3);
                            if (xmm1 >= 0x0) {
                                    xmm3 = intrinsic_movaps(xmm3, *(int128_t *)value -0.00);
                                    xmm3 = intrinsic_xorps(xmm3, xmm8);
                                    xmm3 = intrinsic_cvtss2sd(xmm3, xmm3);
                                    xmm3 = intrinsic_ucomisd(xmm3, xmm1);
                                    if (xmm3 > 0x0) {
                                            *(int8_t *)(r15 + 0x732) = 0x0;
                                    }
                            }
                    }
                    else {
                            *(int8_t *)(r15 + 0x732) = 0x0;
                    }
            }
            else {
                    xmm1 = intrinsic_ucomisd(xmm1, xmm3);
                    if (xmm1 >= 0x0) {
                            xmm3 = intrinsic_movaps(xmm3, *(int128_t *)value -0.00);
                            xmm3 = intrinsic_xorps(xmm3, xmm8);
                            xmm3 = intrinsic_cvtss2sd(xmm3, xmm3);
                            xmm3 = intrinsic_ucomisd(xmm3, xmm1);
                            if (xmm3 > 0x0) {
                                    *(int8_t *)(r15 + 0x732) = 0x0;
                            }
                    }
            }
    }
    else {
            xmm1 = intrinsic_ucomisd(xmm1, xmm3);
            if (xmm1 >= 0x0) {
                    xmm4 = intrinsic_cvtss2sd(xmm4, xmm7);
                    xmm4 = intrinsic_ucomisd(xmm4, xmm1);
                    if (xmm4 <= 0x0) {
                            xmm3 = intrinsic_ucomisd(xmm3, xmm1);
                            if (xmm3 >= 0x0) {
                                    xmm3 = intrinsic_cvtss2sd(0x0, xmm8);
                                    xmm1 = intrinsic_ucomisd(xmm1, xmm3);
                                    if (xmm1 > 0x0) {
                                            *(int8_t *)(r15 + 0x732) = 0x0;
                                    }
                            }
                    }
                    else {
                            *(int8_t *)(r15 + 0x732) = 0x0;
                    }
            }
            else {
                    xmm3 = intrinsic_ucomisd(xmm3, xmm1);
                    if (xmm3 >= 0x0) {
                            xmm3 = intrinsic_cvtss2sd(0x0, xmm8);
                            xmm1 = intrinsic_ucomisd(xmm1, xmm3);
                            if (xmm1 > 0x0) {
                                    *(int8_t *)(r15 + 0x732) = 0x0;
                            }
                    }
            }
    }
    if (rdi == 0x0) goto loc_100219921;

loc_1002198f4 :
    rax = *(int8_t *)(r15 + 0x732);
    if (rdx == 0x0) goto loc_1002199ab;

loc_100219903 :
    if (rax != 0x0) goto loc_1002199b3;

loc_10021990b :
    xmm2 = intrinsic_movss(xmm2, *(int32_t *)value -1.00);
    if (r8 == 0x0) {
            if (*(int8_t *)(r15 + 0x7d1) != 0x0) {
                    xmm0 = intrinsic_xorpd(xmm0, *(int128_t *)0x10050e430);
            }
            xmm0 = intrinsic_cvtsd2ss(xmm0, xmm0);
            xmm0 = intrinsic_addss(xmm0, xmm0);
            xmm0 = intrinsic_cvtss2sd(xmm0, xmm0);
            xmm0 = intrinsic_ucomisd(xmm0, xmm1);
    }
    else {
            xmm0 = intrinsic_addsd(xmm0, xmm0);
            xmm1 = intrinsic_ucomisd(xmm1, xmm0);
    }
    goto loc_100219a22;

loc_100219a22 :
    if ((COND_BYTE_SET(G)) != 0x0) {
            xmm0 = intrinsic_movss(xmm0, *(int32_t *)value 0.5);
    }
    else {
            xmm0 = intrinsic_movss(xmm0, *(int32_t *)value 0.4);
    }
    goto loc_100219ae9;

loc_100219ae9 :
    rax = 0x0;
    rax = r8 == 0x0 ? 0x1 : 0x0;
    xmm0 = intrinsic_cvtss2sd(0x0, intrinsic_divss(intrinsic_mulss(intrinsic_mulss(intrinsic_mulss(intrinsic_mulss(xmm5, delta), *(int32_t *)(0x10050d470 + rax * 0x4)), xmm2), xmm0), xmm6));
    xmm1 = intrinsic_subsd(xmm1, xmm0);
    *(r15 + 0x760) = intrinsic_movsd(*(r15 + 0x760), xmm1);
    if (rdx != 0x0) {
            *(int8_t *)(r15 + 0x7a0) = 0x0;
            if (*(int8_t *)(r15 + 0x732) == 0x0) {
                    if (*(int8_t *)(r15 + 0x773) == 0x0) {
                            if (r8 != 0x0) {
                                    xmm0 = intrinsic_movss(xmm0, *(int32_t *)value -8);
                                    xmm0 = intrinsic_divss(xmm0, xmm6);
                                    xmm0 = intrinsic_cvtss2sd(xmm0, xmm0);
                                    xmm0 = intrinsic_maxsd(xmm0, xmm1);
                                    xmm1 = intrinsic_movss(xmm1, *(int32_t *)0x100510ec0);
                                    xmm1 = intrinsic_divss(xmm1, xmm6);
                                    xmm1 = intrinsic_cvtss2sd(xmm1, xmm1);
                            }
                            else {
                                    xmm0 = intrinsic_cvtss2sd(0x0, xmm8);
                                    xmm0 = intrinsic_maxsd(xmm0, xmm1);
                                    xmm1 = intrinsic_cvtss2sd(0x0, xmm7);
                            }
                            *(r15 + 0x760) = intrinsic_movsd(*(r15 + 0x760), intrinsic_minsd(xmm1, xmm0));
                    }
            }
    }
    else {
            if (*(int8_t *)(r15 + 0x732) == 0x0) {
                    if (*(int8_t *)(r15 + 0x773) == 0x0) {
                            if (r8 != 0x0) {
                                    xmm0 = intrinsic_movss(xmm0, *(int32_t *)value -8);
                                    xmm0 = intrinsic_divss(xmm0, xmm6);
                                    xmm0 = intrinsic_cvtss2sd(xmm0, xmm0);
                                    xmm0 = intrinsic_maxsd(xmm0, xmm1);
                                    xmm1 = intrinsic_movss(xmm1, *(int32_t *)0x100510ec0);
                                    xmm1 = intrinsic_divss(xmm1, xmm6);
                                    xmm1 = intrinsic_cvtss2sd(xmm1, xmm1);
                            }
                            else {
                                    xmm0 = intrinsic_cvtss2sd(0x0, xmm8);
                                    xmm0 = intrinsic_maxsd(xmm0, xmm1);
                                    xmm1 = intrinsic_cvtss2sd(0x0, xmm7);
                            }
                            *(r15 + 0x760) = intrinsic_movsd(*(r15 + 0x760), intrinsic_minsd(xmm1, xmm0));
                    }
            }
    }
    goto loc_100219da5;

loc_100219da5 :
    rbx = stack[2044];
    r14 = stack[2045];
    r15 = stack[2046];
    rsp = rsp + 0x98;
    rbp = stack[2047];
    return rax;

loc_1002199b3 :
    xmm2 = 0x0;
    if (r8 == 0x0) goto loc_1002199c3;

loc_1002199bb :
    xmm2 = 0x0;
    xmm1 = intrinsic_ucomisd(xmm1, xmm2);
    if (xmm1 > 0x0) goto loc_1002199c9;

loc_1002199d7 :
    xmm2 = intrinsic_movss(xmm2, *(int32_t *)value 0.8);
    if (rdx == 0x0) goto loc_1002199f2;

loc_1002199e3 :
    if (r8 != 0x0) {
            xmm0 = intrinsic_addsd(xmm0, xmm0);
            xmm1 = intrinsic_ucomisd(xmm1, xmm0);
    }
    else {
            if (*(int8_t *)(r15 + 0x7d1) != 0x0) {
                    xmm0 = intrinsic_xorpd(xmm0, *(int128_t *)0x10050e430);
            }
            xmm0 = intrinsic_cvtsd2ss(xmm0, xmm0);
            xmm0 = intrinsic_addss(xmm0, xmm0);
            xmm0 = intrinsic_cvtss2sd(xmm0, xmm0);
            xmm0 = intrinsic_ucomisd(xmm0, xmm1);
    }
    goto loc_100219a22;

loc_1002199f2 :
    if (r8 == 0x0) {
            if (*(int8_t *)(r15 + 0x7d1) != 0x0) {
                    xmm0 = intrinsic_xorpd(xmm0, *(int128_t *)0x10050e430);
            }
            xmm0 = intrinsic_cvtsd2ss(xmm0, xmm0);
            xmm0 = intrinsic_addss(xmm0, xmm0);
            xmm0 = intrinsic_cvtss2sd(xmm0, xmm0);
            xmm0 = intrinsic_ucomisd(xmm0, xmm1);
    }
    else {
            xmm0 = intrinsic_addsd(xmm0, xmm0);
            xmm1 = intrinsic_ucomisd(xmm1, xmm0);
    }
    goto loc_100219ad2;

loc_100219ad2 :
    if ((COND_BYTE_SET(G)) == 0x0) {
            xmm2 = intrinsic_movss(xmm2, *(int32_t *)value 1.2);
    }
    xmm0 = intrinsic_movss(xmm0, *(int32_t *)value 0.4);
    goto loc_100219ae9;

loc_1002199c9 :
    xmm2 = intrinsic_movss(xmm2, *(int32_t *)value -1.00);
    if (rdx != 0x0) goto loc_1002199e3;
    goto loc_1002199f2;

loc_1002199c3 :
    xmm2 = intrinsic_ucomisd(xmm2, xmm1);
    if (xmm2 <= 0x0) goto loc_1002199d7;
    goto loc_1002199c9;

loc_1002199ab :
    if (rax == 0x0) goto loc_100219a99;
    goto loc_1002199b3;

loc_100219a99 :
    xmm2 = intrinsic_movss(xmm2, *(int32_t *)value 0.8);
    if (r8 != 0x0) {
            xmm0 = intrinsic_addsd(xmm0, xmm0);
            xmm1 = intrinsic_ucomisd(xmm1, xmm0);
    }
    else {
            if (*(int8_t *)(r15 + 0x7d1) != 0x0) {
                    xmm0 = intrinsic_xorpd(xmm0, *(int128_t *)0x10050e430);
            }
            xmm0 = intrinsic_cvtsd2ss(xmm0, xmm0);
            xmm0 = intrinsic_addss(xmm0, xmm0);
            xmm0 = intrinsic_cvtss2sd(xmm0, xmm0);
            xmm0 = intrinsic_ucomisd(xmm0, xmm1);
    }
    goto loc_100219ad2;

loc_100219921 :
    if (*(int8_t *)(r15 + 0x771) != 0x0) {
            if ((*(int8_t *)(r15 + 0x746) != 0x0) && (rdx != 0x0)) {
                    if (rsi == 0x0) {
                            xmm2 = intrinsic_movss(xmm2, *(int32_t *)0x10050ca5c);
                    }
                    r14 = r15 + 0x760;
                    rax = 0x0;
                    *(int8_t *)(r15 + 0x746) = 0x0;
                    xmm2 = intrinsic_mulss(xmm2, *(int32_t *)(0x10050d470 + (COND_BYTE_SET(E)) * 0x4));
                    xmm2 = intrinsic_mulss(xmm2, xmm6);
                    xmm0 = intrinsic_cvtss2sd(0x0, xmm2);
                    var_68 = intrinsic_movss(var_68, xmm5);
                    var_64 = intrinsic_movss(var_64, xmm6);
                    var_90 = intrinsic_movaps(var_90, xmm7);
                    var_80 = intrinsic_movaps(var_80, xmm8);
                    if (r8 != 0x0) {
                            xmm1 = intrinsic_ucomisd(xmm1, xmm0);
                            if (xmm1 > 0x0) {
                                    *(r15 + 0x760) = intrinsic_movsd(*(r15 + 0x760), xmm0);
                                    if ((*(int8_t *)(r15 + 0x769) != 0x0) || (*(int8_t *)(r15 + 0x768) != 0x0)) {
                                            xmm1 = intrinsic_movss(xmm1, *(int32_t *)(r15 + 0x76c));
                                            xmm3 = intrinsic_xorpd(xmm3, xmm3);
                                            xmm1 = intrinsic_ucomiss(xmm1, xmm3);
                                            if (xmm1 > 0x0) {
                                                    xmm2 = intrinsic_mulss(xmm2, *(int32_t *)value 1.4);
                                                    xmm1 = intrinsic_mulss(xmm1, *(int32_t *)value 0.5);
                                                    xmm1 = intrinsic_cvtss2sd(xmm1, xmm1);
                                                    xmm1 = intrinsic_addsd(xmm1, xmm0);
                                                    xmm0 = intrinsic_cvtss2sd(0x0, xmm2);
                                                    xmm0 = intrinsic_minsd(xmm0, xmm1);
                                                    *r14 = intrinsic_movsd(*r14, xmm0);
                                            }
                                    }
                            }
                    }
                    else {
                            xmm0 = intrinsic_ucomisd(xmm0, xmm1);
                            if (xmm0 > 0x0) {
                                    *(r15 + 0x760) = intrinsic_movsd(*(r15 + 0x760), xmm0);
                                    if ((*(int8_t *)(r15 + 0x769) != 0x0) || (*(int8_t *)(r15 + 0x768) != 0x0)) {
                                            xmm1 = intrinsic_movss(xmm1, *(int32_t *)(r15 + 0x76c));
                                            xmm3 = intrinsic_xorpd(xmm3, xmm3);
                                            xmm1 = intrinsic_ucomiss(xmm1, xmm3);
                                            if (xmm1 > 0x0) {
                                                    xmm2 = intrinsic_mulss(xmm2, *(int32_t *)value 1.4);
                                                    xmm1 = intrinsic_mulss(xmm1, *(int32_t *)value 0.5);
                                                    xmm1 = intrinsic_cvtss2sd(xmm1, xmm1);
                                                    xmm1 = intrinsic_addsd(xmm1, xmm0);
                                                    xmm0 = intrinsic_cvtss2sd(0x0, xmm2);
                                                    xmm0 = intrinsic_minsd(xmm0, xmm1);
                                                    *r14 = intrinsic_movsd(*r14, xmm0);
                                            }
                                    }
                            }
                    }
                    rax = sub_10021c780(r15);
                    xmm0 = intrinsic_movsd(xmm0, *(r15 + 0x618));
                    r8 = *(int8_t *)(r15 + 0x776);
                    xmm1 = intrinsic_movsd(xmm1, *r14);
                    xmm5 = intrinsic_movss(xmm5, var_68);
                    xmm6 = intrinsic_movss(xmm6, var_64);
                    xmm7 = intrinsic_movaps(xmm7, var_90);
                    xmm8 = intrinsic_movaps(xmm8, var_80);
            }
            if (r8 != 0x0) {
                    xmm0 = intrinsic_addsd(xmm0, xmm0);
                    xmm1 = intrinsic_ucomisd(xmm1, xmm0);
            }
            else {
                    if (*(int8_t *)(r15 + 0x7d1) != 0x0) {
                            xmm0 = intrinsic_xorpd(xmm0, *(int128_t *)0x10050e430);
                    }
                    xmm0 = intrinsic_cvtsd2ss(xmm0, xmm0);
                    xmm0 = intrinsic_addss(xmm0, xmm0);
                    xmm0 = intrinsic_cvtss2sd(xmm0, xmm0);
                    xmm0 = intrinsic_ucomisd(xmm0, xmm1);
            }
            rax = 0x0;
            rdx = r8 == 0x0 ? 0x1 : 0x0;
            if ((COND_BYTE_SET(G)) == 0x0) {
                    xmm0 = intrinsic_movss(xmm0, *(int32_t *)value 1.2);
            }
            else {
                    xmm0 = intrinsic_movss(xmm0, *(int32_t *)value 0.8);
            }
            rax = rdx;
            xmm1 = intrinsic_cvtss2sd(0x0, intrinsic_divss(intrinsic_mulss(intrinsic_mulss(intrinsic_mulss(intrinsic_mulss(xmm5, delta), *(int32_t *)(0x10050d470 + rax * 0x4)), xmm0), *(int32_t *)0x10050c978), xmm6));
            xmm1 = intrinsic_addsd(xmm1, *(r15 + 0x760));
            *(r15 + 0x760) = intrinsic_movsd(*(r15 + 0x760), xmm1);
            if (*(int8_t *)(r15 + 0x745) != 0x0) {
                    *(int8_t *)(r15 + 0x7a0) = 0x0;
            }
            if (*(int8_t *)(r15 + 0x732) == 0x0) {
                    if (*(int8_t *)(r15 + 0x773) == 0x0) {
                            if (r8 != 0x0) {
                                    xmm0 = intrinsic_movss(xmm0, *(int32_t *)value -8);
                                    xmm0 = intrinsic_divss(xmm0, xmm6);
                                    xmm0 = intrinsic_cvtss2sd(xmm0, xmm0);
                                    xmm0 = intrinsic_maxsd(xmm0, xmm1);
                                    xmm1 = intrinsic_movss(xmm1, *(int32_t *)0x100510ec0);
                                    xmm1 = intrinsic_divss(xmm1, xmm6);
                                    xmm1 = intrinsic_cvtss2sd(xmm1, xmm1);
                            }
                            else {
                                    xmm0 = intrinsic_cvtss2sd(0x0, xmm8);
                                    xmm0 = intrinsic_maxsd(xmm0, xmm1);
                                    xmm1 = intrinsic_cvtss2sd(0x0, xmm7);
                            }
                            *(r15 + 0x760) = intrinsic_movsd(*(r15 + 0x760), intrinsic_minsd(xmm1, xmm0));
                    }
            }
    }
    else {
            xmm0 = intrinsic_movsd(xmm0, *0x10050c8c8);
            xmm2 = intrinsic_movsd(xmm2, *0x10050c8d0);
            xmm3 = intrinsic_movapd(xmm3, xmm0);
            if (r8 != 0x0) {
                    xmm3 = intrinsic_movapd(xmm3, xmm2);
            }
            xmm1 = intrinsic_movss(xmm1, *(int32_t *)(r15 + 0x780));
            xmm1 = intrinsic_cvtss2sd(xmm1, xmm1);
            xmm1 = intrinsic_mulsd(xmm1, *(r15 + 0x608));
            xmm1 = intrinsic_mulsd(xmm1, xmm3);
            if (rdx == 0x0) {
                    xmm0 = intrinsic_movapd(xmm0, xmm2);
            }
            xmm1 = intrinsic_mulsd(xmm1, xmm0);
            *(r15 + 0x760) = intrinsic_movsd(*(r15 + 0x760), xmm1);
            if (*(int8_t *)(r15 + 0x732) == 0x0) {
                    if (*(int8_t *)(r15 + 0x773) == 0x0) {
                            if (r8 != 0x0) {
                                    xmm0 = intrinsic_movss(xmm0, *(int32_t *)value -8);
                                    xmm0 = intrinsic_divss(xmm0, xmm6);
                                    xmm0 = intrinsic_cvtss2sd(xmm0, xmm0);
                                    xmm0 = intrinsic_maxsd(xmm0, xmm1);
                                    xmm1 = intrinsic_movss(xmm1, *(int32_t *)0x100510ec0);
                                    xmm1 = intrinsic_divss(xmm1, xmm6);
                                    xmm1 = intrinsic_cvtss2sd(xmm1, xmm1);
                            }
                            else {
                                    xmm0 = intrinsic_cvtss2sd(0x0, xmm8);
                                    xmm0 = intrinsic_maxsd(xmm0, xmm1);
                                    xmm1 = intrinsic_cvtss2sd(0x0, xmm7);
                            }
                            *(r15 + 0x760) = intrinsic_movsd(*(r15 + 0x760), intrinsic_minsd(xmm1, xmm0));
                    }
            }
    }
    goto loc_100219da5;

loc_100219813 :
    xmm1 = zero_extend_32(*(int32_t *)(0x10050e370 + rsi * 0x4));
    if (*(int8_t *)(r15 + 0x771) == 0x0) goto loc_100219835;

loc_100219829 :
    rdi = 0x0;
    if (rsi == 0x0) {
            xmm6 = intrinsic_movss(xmm6, *(int32_t *)value 1.0);
    }
    else {
            xmm6 = intrinsic_movss(xmm6, *(int32_t *)0x10050d3dc);
    }
    goto loc_100219856;

loc_100219835 :
    if (*(int8_t *)(r15 + 0x773) == 0x0) goto loc_100219b45;

loc_100219843 :
    rdi = 0x0;
    if (rsi != 0x0) {
            xmm6 = intrinsic_movss(xmm6, *(int32_t *)0x10050d3dc);
    }
    else {
            xmm6 = intrinsic_movss(xmm6, *(int32_t *)value 1.0);
    }
    goto loc_100219856;

loc_100219b45 :
    if (r8 != 0x0) goto loc_100219b61;

loc_100219b4a :
    rcx = 0x0;
    rsi = r9 == 0x0 ? 0x1 : 0x0;
    if (*(int8_t *)(r15 + 0x775) == 0x0) goto loc_100219e2c;

loc_100219b61 :
    xmm2 = intrinsic_movss(xmm2, *(int32_t *)value 0.60);
    if (rax == 0x0) goto loc_100219b98;

loc_100219b6d :
    if (r10 == 0x0) goto loc_100219b98;

loc_100219b72 :
    if ((*(int8_t *)(r15 + 0x775) == 0x0) || (*(int8_t *)(r15 + 0x779) != 0x0)) goto loc_100219b8a;

loc_100219fc7 :
    rdi = r15;
    rbx = stack[2044];
    r14 = stack[2045];
    r15 = stack[2046];
    rsp = rsp + 0x98;
    rbp = stack[2047];
    rax = PlayerObject::spiderTestJump(rdi, 0x0);
    return rax;

loc_100219b8a :
    if (*(int8_t *)(r15 + 0x779) == 0x0) goto loc_100219ec9;

loc_100219b98 :
    if (*(int8_t *)(r15 + 0x7a1) == 0x0) goto loc_100219dfd;

loc_100219ba6 :
    if (((r9 == 0x0) || (rdx == 0x0)) || (*(int8_t *)(r15 + 0x758) != 0x0)) goto loc_100219db0;

loc_100219bc5 :
    xmm1 = intrinsic_movss(xmm1, *(int32_t *)(r15 + 0x674));
    xmm3 = intrinsic_movss(xmm3, *(int32_t *)value 1.5);
    xmm3 = intrinsic_ucomiss(xmm3, xmm1);
    if (xmm3 <= 0x0) goto loc_100219db0;

loc_100219bdf :
    *(int32_t *)(r15 + 0x674) = intrinsic_movss(*(int32_t *)(r15 + 0x674), intrinsic_addss(intrinsic_mulss(intrinsic_movss(xmm2, delta), *(int32_t *)value 0.10), xmm1));
    rax = *(int8_t *)(r15 + 0x776);
    xmm1 = intrinsic_movsd(xmm1, *(r15 + 0x760));
    if (rax != 0x0) goto loc_100219df1;

loc_100219e48 :
    if (*(int8_t *)(r15 + 0x7d1) != 0x0) {
            xmm0 = intrinsic_xorpd(xmm0, *(int128_t *)0x10050e430);
    }
    xmm0 = intrinsic_cvtsd2ss(xmm0, xmm0);
    xmm0 = intrinsic_addss(xmm0, xmm0);
    xmm0 = intrinsic_cvtss2sd(xmm0, xmm0);
    xmm0 = intrinsic_ucomisd(xmm0, xmm1);
    if (xmm0 <= 0x0) goto loc_100219da5;

loc_100219e70 :
    *(int8_t *)(r15 + 0x7a1) = 0x0;
    *(int8_t *)(r15 + 0x62a) = 0x1;
    *(int8_t *)(r15 + 0x7a0) = 0x0;
    if (r9 == 0x0) goto loc_10021a195;

loc_100219e91 :
    rbx = *(r15 + 0x6a8);
    rax = std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(var_58, ""fall_loop"", var_20);
    xmm0 = intrinsic_movss(xmm0, *(int32_t *)value 0.10);
    rax = CCAnimatedSprite::tweenToAnimation(rbx, var_58);
    rax = var_58;
    goto loc_10021a382;

loc_10021a382 :
    if (rax + 0xffffffffffffffe8 != std::string::_Rep::_S_empty_rep_storage) {
            *(int32_t *)(rax + 0xfffffffffffffff8) = lock intrinsic_xadd(*(int32_t *)(rax + 0xfffffffffffffff8), 0xffffffff);
            if (0xffffffff <= 0x0) {
                    rsi = var_38;
                    rax = std::string::_Rep::_M_destroy();
            }
    }
    goto loc_100219da5;

loc_10021a195 :
    if (*(int8_t *)(r15 + 0x775) == 0x0) goto loc_100219da5;

loc_10021a1a3 :
    rbx = *(r15 + 0x6b0);
    rax = std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(var_50, ""fall_loop"", var_20);
    xmm0 = intrinsic_movss(xmm0, *(int32_t *)value 0.10);
    rax = CCAnimatedSprite::tweenToAnimation(rbx, var_50);
    rax = var_50;
    goto loc_10021a382;

loc_100219df1 :
    xmm0 = intrinsic_addsd(xmm0, xmm0);
    xmm1 = intrinsic_ucomisd(xmm1, xmm0);
    if (xmm1 <= 0x0) goto loc_100219da5;
    goto loc_100219e70;

loc_100219db0 :
    xmm5 = intrinsic_mulss(xmm5, delta);
    rax = *(int8_t *)(r15 + 0x776);
    rcx = 0x0;
    xmm2 = intrinsic_mulss(xmm2, intrinsic_mulss(xmm5, *(int32_t *)(0x10050d470 + (rax == 0x0 ? 0x1 : 0x0) * 0x4)));
    xmm2 = intrinsic_cvtss2sd(xmm2, xmm2);
    xmm1 = intrinsic_movsd(xmm1, *(r15 + 0x760));
    xmm1 = intrinsic_subsd(xmm1, xmm2);
    *(r15 + 0x760) = intrinsic_movsd(*(r15 + 0x760), xmm1);
    if (rax == 0x0) goto loc_100219e48;
    goto loc_100219df1;

loc_100219dfd :
    rax = *(int8_t *)(r15 + 0x776);
    xmm1 = intrinsic_movsd(xmm1, *(r15 + 0x760));
    if (rax != 0x0) {
            xmm3 = intrinsic_movapd(xmm3, xmm0);
            xmm3 = intrinsic_addsd(xmm3, xmm3);
            xmm1 = intrinsic_ucomisd(xmm1, xmm3);
            if (xmm1 > 0x0) {
                    *(int8_t *)(r15 + 0x778) = 0x0;
            }
    }
    else {
            COND = *(int8_t *)(r15 + 0x7d1) == 0x0;
            xmm3 = intrinsic_movapd(xmm3, xmm0);
            if (!COND) {
                    xmm3 = intrinsic_movapd(xmm3, *(int128_t *)0x10050e430);
                    xmm3 = intrinsic_xorpd(xmm3, xmm0);
            }
            xmm3 = intrinsic_cvtsd2ss(xmm3, xmm3);
            xmm3 = intrinsic_addss(xmm3, xmm3);
            xmm3 = intrinsic_cvtss2sd(xmm3, xmm3);
            xmm3 = intrinsic_ucomisd(xmm3, xmm1);
            if (xmm3 > 0x0) {
                    *(int8_t *)(r15 + 0x778) = 0x0;
            }
    }
    rcx = 0x0;
    rax = 0x10050d470;
    xmm2 = intrinsic_mulss(xmm2, intrinsic_mulss(intrinsic_mulss(xmm5, delta), *(int32_t *)(rax + (COND_BYTE_SET(E)) * 0x4)));
    xmm2 = intrinsic_cvtss2sd(xmm2, xmm2);
    xmm1 = intrinsic_subsd(xmm1, xmm2);
    if (0x10050d470 != 0x0) {
            xmm2 = intrinsic_movsd(xmm2, *0x100511098);
            xmm2 = intrinsic_minsd(xmm2, xmm1);
            *(r15 + 0x760) = intrinsic_movsd(*(r15 + 0x760), xmm2);
            if (!CPU_FLAGS & NE) {
                    if (*(int8_t *)(r15 + 0x7d1) != 0x0) {
                            xmm0 = intrinsic_xorpd(xmm0, *(int128_t *)0x10050e430);
                    }
                    xmm0 = intrinsic_cvtsd2ss(xmm0, xmm0);
                    xmm0 = intrinsic_addss(xmm0, xmm0);
                    xmm0 = intrinsic_cvtss2sd(xmm0, xmm0);
                    xmm0 = intrinsic_ucomisd(xmm0, xmm2);
                    if (xmm0 > 0x0) {
                            if (r8 == 0x0) {
                                    rax = r9 != 0x0 ? 0x1 : 0x0;
                                    if (((((*(int8_t *)(r15 + 0x775) == 0x0) && (rax == 0x0)) && (PlayerObject::fadeOutStreak2(r15, 0x0) == 0x0)) && (*(int8_t *)(r15 + 0x768) == 0x0)) && (*(int8_t *)(r15 + 0x554) == 0x0)) {
                                            rax = PlayerObject::runRotateAction(r15, 0x1, rdx);
                                    }
                            }
                            xmm0 = intrinsic_movsd(xmm0, *(r15 + 0x760));
                            xmm0 = intrinsic_ucomisd(xmm0, *0x100510160);
                            rax = xmm0 > 0x0 ? 0x1 : 0x0;
                            xmm1 = intrinsic_movsd(xmm1, *0x1005110a0);
                            xmm1 = intrinsic_ucomisd(xmm1, xmm0);
                            rcx = xmm1 > 0x0 ? 0x1 : 0x0;
                            if (*(int8_t *)(r15 + 0x776) != 0x0) {
                                    rcx = rax;
                            }
                            if (rcx == 0x1) {
                                    if (((*(int8_t *)(r15 + 0x774) != 0x0) && (*(int8_t *)(r15 + 0x7a0) != 0x0)) && (*(int8_t *)(r15 + 0x6b8) == 0x0)) {
                                            r14 = *(r15 + 0x6a8);
                                            rax = std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(var_48, ""fall_loop"", var_20);
                                            xmm0 = intrinsic_movss(xmm0, *(int32_t *)value 0.10);
                                            rax = CCAnimatedSprite::tweenToAnimation(r14, var_48);
                                            rax = var_48;
                                            if (rax + 0xffffffffffffffe8 != std::string::_Rep::_S_empty_rep_storage) {
                                                    *(int32_t *)(rax + 0xfffffffffffffff8) = lock intrinsic_xadd(*(int32_t *)(rax + 0xfffffffffffffff8), 0xffffffff);
                                                    if (0xffffffff <= 0x0) {
                                                            rsi = var_38;
                                                            rax = std::string::_Rep::_M_destroy();
                                                    }
                                            }
                                            r14 = r15 + 0x7a0;
                                            *(int8_t *)r14 = 0x0;
                                    }
                                    else {
                                            r14 = r15 + 0x7a0;
                                            if (((*(int8_t *)(r15 + 0x775) != 0x0) && (*(int8_t *)r14 != 0x0)) && (*(int8_t *)(r15 + 0x6b8) == 0x0)) {
                                                    rbx = *(r15 + 0x6b0);
                                                    rax = std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(var_40, ""fall_loop"", var_20);
                                                    xmm0 = intrinsic_movss(xmm0, *(int32_t *)value 0.10);
                                                    rax = CCAnimatedSprite::tweenToAnimation(rbx, var_40);
                                                    rax = var_40;
                                                    if (rax + 0xffffffffffffffe8 != std::string::_Rep::_S_empty_rep_storage) {
                                                            *(int32_t *)(rax + 0xfffffffffffffff8) = lock intrinsic_xadd(*(int32_t *)(rax + 0xfffffffffffffff8), 0xffffffff);
                                                            if (0xffffffff <= 0x0) {
                                                                    rsi = var_38;
                                                                    rax = std::string::_Rep::_M_destroy();
                                                                    *(int8_t *)r14 = 0x0;
                                                            }
                                                            else {
                                                                    *(int8_t *)r14 = 0x0;
                                                            }
                                                    }
                                                    else {
                                                            *(int8_t *)r14 = 0x0;
                                                    }
                                            }
                                            else {
                                                    *(int8_t *)r14 = 0x0;
                                            }
                                    }
                            }
                    }
            }
            else {
                    xmm0 = intrinsic_addsd(xmm0, xmm0);
                    xmm2 = intrinsic_ucomisd(xmm2, xmm0);
                    if (xmm2 > 0x0) {
                            if (r8 == 0x0) {
                                    rax = r9 != 0x0 ? 0x1 : 0x0;
                                    if (((((*(int8_t *)(r15 + 0x775) == 0x0) && (rax == 0x0)) && (PlayerObject::fadeOutStreak2(r15, 0x0) == 0x0)) && (*(int8_t *)(r15 + 0x768) == 0x0)) && (*(int8_t *)(r15 + 0x554) == 0x0)) {
                                            rax = PlayerObject::runRotateAction(r15, 0x1, rdx);
                                    }
                            }
                            xmm0 = intrinsic_movsd(xmm0, *(r15 + 0x760));
                            xmm0 = intrinsic_ucomisd(xmm0, *0x100510160);
                            rax = xmm0 > 0x0 ? 0x1 : 0x0;
                            xmm1 = intrinsic_movsd(xmm1, *0x1005110a0);
                            xmm1 = intrinsic_ucomisd(xmm1, xmm0);
                            rcx = xmm1 > 0x0 ? 0x1 : 0x0;
                            if (*(int8_t *)(r15 + 0x776) != 0x0) {
                                    rcx = rax;
                            }
                            if (rcx == 0x1) {
                                    if (((*(int8_t *)(r15 + 0x774) != 0x0) && (*(int8_t *)(r15 + 0x7a0) != 0x0)) && (*(int8_t *)(r15 + 0x6b8) == 0x0)) {
                                            r14 = *(r15 + 0x6a8);
                                            rax = std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(var_48, ""fall_loop"", var_20);
                                            xmm0 = intrinsic_movss(xmm0, *(int32_t *)value 0.10);
                                            rax = CCAnimatedSprite::tweenToAnimation(r14, var_48);
                                            rax = var_48;
                                            if (rax + 0xffffffffffffffe8 != std::string::_Rep::_S_empty_rep_storage) {
                                                    *(int32_t *)(rax + 0xfffffffffffffff8) = lock intrinsic_xadd(*(int32_t *)(rax + 0xfffffffffffffff8), 0xffffffff);
                                                    if (0xffffffff <= 0x0) {
                                                            rsi = var_38;
                                                            rax = std::string::_Rep::_M_destroy();
                                                    }
                                            }
                                            r14 = r15 + 0x7a0;
                                            *(int8_t *)r14 = 0x0;
                                    }
                                    else {
                                            r14 = r15 + 0x7a0;
                                            if (((*(int8_t *)(r15 + 0x775) != 0x0) && (*(int8_t *)r14 != 0x0)) && (*(int8_t *)(r15 + 0x6b8) == 0x0)) {
                                                    rbx = *(r15 + 0x6b0);
                                                    rax = std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(var_40, ""fall_loop"", var_20);
                                                    xmm0 = intrinsic_movss(xmm0, *(int32_t *)value 0.10);
                                                    rax = CCAnimatedSprite::tweenToAnimation(rbx, var_40);
                                                    rax = var_40;
                                                    if (rax + 0xffffffffffffffe8 != std::string::_Rep::_S_empty_rep_storage) {
                                                            *(int32_t *)(rax + 0xfffffffffffffff8) = lock intrinsic_xadd(*(int32_t *)(rax + 0xfffffffffffffff8), 0xffffffff);
                                                            if (0xffffffff <= 0x0) {
                                                                    rsi = var_38;
                                                                    rax = std::string::_Rep::_M_destroy();
                                                                    *(int8_t *)r14 = 0x0;
                                                            }
                                                            else {
                                                                    *(int8_t *)r14 = 0x0;
                                                            }
                                                    }
                                                    else {
                                                            *(int8_t *)r14 = 0x0;
                                                    }
                                            }
                                            else {
                                                    *(int8_t *)r14 = 0x0;
                                            }
                                    }
                            }
                    }
            }
    }
    else {
            xmm2 = intrinsic_movsd(xmm2, *0x100511090);
            xmm2 = intrinsic_maxsd(xmm2, xmm1);
            *(r15 + 0x760) = intrinsic_movsd(*(r15 + 0x760), xmm2);
            if (!CPU_FLAGS & E) {
                    xmm0 = intrinsic_addsd(xmm0, xmm0);
                    xmm2 = intrinsic_ucomisd(xmm2, xmm0);
                    if (xmm2 > 0x0) {
                            if (r8 == 0x0) {
                                    rax = r9 != 0x0 ? 0x1 : 0x0;
                                    if (((((*(int8_t *)(r15 + 0x775) == 0x0) && (rax == 0x0)) && (PlayerObject::fadeOutStreak2(r15, 0x0) == 0x0)) && (*(int8_t *)(r15 + 0x768) == 0x0)) && (*(int8_t *)(r15 + 0x554) == 0x0)) {
                                            rax = PlayerObject::runRotateAction(r15, 0x1, rdx);
                                    }
                            }
                            xmm0 = intrinsic_movsd(xmm0, *(r15 + 0x760));
                            xmm0 = intrinsic_ucomisd(xmm0, *0x100510160);
                            rax = xmm0 > 0x0 ? 0x1 : 0x0;
                            xmm1 = intrinsic_movsd(xmm1, *0x1005110a0);
                            xmm1 = intrinsic_ucomisd(xmm1, xmm0);
                            rcx = xmm1 > 0x0 ? 0x1 : 0x0;
                            if (*(int8_t *)(r15 + 0x776) != 0x0) {
                                    rcx = rax;
                            }
                            if (rcx == 0x1) {
                                    if (((*(int8_t *)(r15 + 0x774) != 0x0) && (*(int8_t *)(r15 + 0x7a0) != 0x0)) && (*(int8_t *)(r15 + 0x6b8) == 0x0)) {
                                            r14 = *(r15 + 0x6a8);
                                            rax = std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(var_48, ""fall_loop"", var_20);
                                            xmm0 = intrinsic_movss(xmm0, *(int32_t *)value 0.10);
                                            rax = CCAnimatedSprite::tweenToAnimation(r14, var_48);
                                            rax = var_48;
                                            if (rax + 0xffffffffffffffe8 != std::string::_Rep::_S_empty_rep_storage) {
                                                    *(int32_t *)(rax + 0xfffffffffffffff8) = lock intrinsic_xadd(*(int32_t *)(rax + 0xfffffffffffffff8), 0xffffffff);
                                                    if (0xffffffff <= 0x0) {
                                                            rsi = var_38;
                                                            rax = std::string::_Rep::_M_destroy();
                                                    }
                                            }
                                            r14 = r15 + 0x7a0;
                                            *(int8_t *)r14 = 0x0;
                                    }
                                    else {
                                            r14 = r15 + 0x7a0;
                                            if (((*(int8_t *)(r15 + 0x775) != 0x0) && (*(int8_t *)r14 != 0x0)) && (*(int8_t *)(r15 + 0x6b8) == 0x0)) {
                                                    rbx = *(r15 + 0x6b0);
                                                    rax = std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(var_40, ""fall_loop"", var_20);
                                                    xmm0 = intrinsic_movss(xmm0, *(int32_t *)value 0.10);
                                                    rax = CCAnimatedSprite::tweenToAnimation(rbx, var_40);
                                                    rax = var_40;
                                                    if (rax + 0xffffffffffffffe8 != std::string::_Rep::_S_empty_rep_storage) {
                                                            *(int32_t *)(rax + 0xfffffffffffffff8) = lock intrinsic_xadd(*(int32_t *)(rax + 0xfffffffffffffff8), 0xffffffff);
                                                            if (0xffffffff <= 0x0) {
                                                                    rsi = var_38;
                                                                    rax = std::string::_Rep::_M_destroy();
                                                                    *(int8_t *)r14 = 0x0;
                                                            }
                                                            else {
                                                                    *(int8_t *)r14 = 0x0;
                                                            }
                                                    }
                                                    else {
                                                            *(int8_t *)r14 = 0x0;
                                                    }
                                            }
                                            else {
                                                    *(int8_t *)r14 = 0x0;
                                            }
                                    }
                            }
                    }
            }
            else {
                    if (*(int8_t *)(r15 + 0x7d1) != 0x0) {
                            xmm0 = intrinsic_xorpd(xmm0, *(int128_t *)0x10050e430);
                    }
                    xmm0 = intrinsic_cvtsd2ss(xmm0, xmm0);
                    xmm0 = intrinsic_addss(xmm0, xmm0);
                    xmm0 = intrinsic_cvtss2sd(xmm0, xmm0);
                    xmm0 = intrinsic_ucomisd(xmm0, xmm2);
                    if (xmm0 > 0x0) {
                            if (r8 == 0x0) {
                                    rax = r9 != 0x0 ? 0x1 : 0x0;
                                    if (((((*(int8_t *)(r15 + 0x775) == 0x0) && (rax == 0x0)) && (PlayerObject::fadeOutStreak2(r15, 0x0) == 0x0)) && (*(int8_t *)(r15 + 0x768) == 0x0)) && (*(int8_t *)(r15 + 0x554) == 0x0)) {
                                            rax = PlayerObject::runRotateAction(r15, 0x1, rdx);
                                    }
                            }
                            xmm0 = intrinsic_movsd(xmm0, *(r15 + 0x760));
                            xmm0 = intrinsic_ucomisd(xmm0, *0x100510160);
                            rax = xmm0 > 0x0 ? 0x1 : 0x0;
                            xmm1 = intrinsic_movsd(xmm1, *0x1005110a0);
                            xmm1 = intrinsic_ucomisd(xmm1, xmm0);
                            rcx = xmm1 > 0x0 ? 0x1 : 0x0;
                            if (*(int8_t *)(r15 + 0x776) != 0x0) {
                                    rcx = rax;
                            }
                            if (rcx == 0x1) {
                                    if (((*(int8_t *)(r15 + 0x774) != 0x0) && (*(int8_t *)(r15 + 0x7a0) != 0x0)) && (*(int8_t *)(r15 + 0x6b8) == 0x0)) {
                                            r14 = *(r15 + 0x6a8);
                                            rax = std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(var_48, ""fall_loop"", var_20);
                                            xmm0 = intrinsic_movss(xmm0, *(int32_t *)value 0.10);
                                            rax = CCAnimatedSprite::tweenToAnimation(r14, var_48);
                                            rax = var_48;
                                            if (rax + 0xffffffffffffffe8 != std::string::_Rep::_S_empty_rep_storage) {
                                                    *(int32_t *)(rax + 0xfffffffffffffff8) = lock intrinsic_xadd(*(int32_t *)(rax + 0xfffffffffffffff8), 0xffffffff);
                                                    if (0xffffffff <= 0x0) {
                                                            rsi = var_38;
                                                            rax = std::string::_Rep::_M_destroy();
                                                    }
                                            }
                                            r14 = r15 + 0x7a0;
                                            *(int8_t *)r14 = 0x0;
                                    }
                                    else {
                                            r14 = r15 + 0x7a0;
                                            if (((*(int8_t *)(r15 + 0x775) != 0x0) && (*(int8_t *)r14 != 0x0)) && (*(int8_t *)(r15 + 0x6b8) == 0x0)) {
                                                    rbx = *(r15 + 0x6b0);
                                                    rax = std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(var_40, ""fall_loop"", var_20);
                                                    xmm0 = intrinsic_movss(xmm0, *(int32_t *)value 0.10);
                                                    rax = CCAnimatedSprite::tweenToAnimation(rbx, var_40);
                                                    rax = var_40;
                                                    if (rax + 0xffffffffffffffe8 != std::string::_Rep::_S_empty_rep_storage) {
                                                            *(int32_t *)(rax + 0xfffffffffffffff8) = lock intrinsic_xadd(*(int32_t *)(rax + 0xfffffffffffffff8), 0xffffffff);
                                                            if (0xffffffff <= 0x0) {
                                                                    rsi = var_38;
                                                                    rax = std::string::_Rep::_M_destroy();
                                                                    *(int8_t *)r14 = 0x0;
                                                            }
                                                            else {
                                                                    *(int8_t *)r14 = 0x0;
                                                            }
                                                    }
                                                    else {
                                                            *(int8_t *)r14 = 0x0;
                                                    }
                                            }
                                            else {
                                                    *(int8_t *)r14 = 0x0;
                                            }
                                    }
                            }
                    }
            }
    }
    goto loc_100219da5;

loc_100219ec9 :
    *(int8_t *)(r15 + 0x7a1) = 0x1;
    *(int8_t *)(r15 + 0x7a0) = 0x0;
    *(int8_t *)(r15 + 0x778) = 0x0;
    *(int8_t *)(r15 + 0x746) = 0x0;
    *(int8_t *)(r15 + 0x758) = 0x0;
    *(int32_t *)(r15 + 0x674) = 0x0;
    xmm0 = intrinsic_movsd(xmm0, *(r15 + 0x610));
    xmm0 = intrinsic_cvtsd2ss(xmm0, xmm0);
    if (r9 != 0x0) {
            xmm0 = intrinsic_mulss(xmm0, *(int32_t *)value 0.5);
    }
    if (r14 == 0x0) {
            *(int8_t *)(r15 + 0x732) = 0x1;
            xmm0 = intrinsic_movss(xmm0, *(int32_t *)value 1/32);
    }
    rax = *(int8_t *)(r15 + 0x776);
    rcx = 0x0;
    xmm3 = intrinsic_movss(xmm3, *(int32_t *)(0x10050d470 + (rax == 0x0 ? 0x1 : 0x0) * 0x4));
    xmm1 = intrinsic_mulss(xmm1, intrinsic_mulss(xmm0, xmm3));
    xmm0 = intrinsic_cvtss2sd(0x0, xmm1);
    *(r15 + 0x760) = intrinsic_movsd(*(r15 + 0x760), xmm0);
    if ((*(int8_t *)(r15 + 0x769) != 0x0) || (*(int8_t *)(r15 + 0x768) != 0x0)) {
            xmm2 = intrinsic_movss(xmm2, *(int32_t *)(r15 + 0x76c));
            xmm3 = intrinsic_mulss(xmm3, xmm2);
            xmm4 = 0x0;
            xmm3 = intrinsic_ucomiss(xmm3, xmm4);
            if (xmm3 > 0x0) {
                    xmm3 = intrinsic_movsd(xmm3, *(r15 + 0x7d8));
                    xmm3 = intrinsic_subsd(xmm3, *(r15 + 0x500));
                    xmm4 = intrinsic_movsd(xmm4, *0x100511070);
                    xmm4 = intrinsic_ucomisd(xmm4, xmm3);
                    if (xmm4 > 0x0) {
                            xmm3 = intrinsic_mulsd(xmm3, *0x100511078);
                            xmm3 = intrinsic_maxsd(xmm3, *0x100511080);
                    }
                    else {
                            xmm3 = intrinsic_movsd(xmm3, *0x10050c8c8);
                    }
                    xmm1 = intrinsic_mulss(xmm1, *(int32_t *)value 1.4);
                    if (r8 == 0x0) {
                            xmm2 = intrinsic_cvtsd2ss(0x0, intrinsic_mulsd(xmm3, intrinsic_cvtss2sd(xmm2, xmm2)));
                    }
                    xmm2 = intrinsic_mulss(xmm2, *(int32_t *)0x10050cee4);
                    xmm0 = intrinsic_addsd(xmm0, intrinsic_cvtss2sd(xmm2, xmm2));
                    xmm1 = intrinsic_cvtss2sd(xmm1, xmm1);
                    if (rax != 0x0) {
                            xmm1 = intrinsic_maxsd(xmm1, xmm0);
                    }
                    else {
                            xmm1 = intrinsic_minsd(xmm1, xmm0);
                    }
                    *(r15 + 0x760) = intrinsic_movsd(*(r15 + 0x760), xmm1);
            }
    }
    *(int8_t *)(r15 + 0x62b) = 0x1;
    rax = ftime(var_38);
    rax = (0xfffff & var_38) * 0x3e8;
    xmm0 = intrinsic_cvtsi2sd(0x0, (var_30 & 0xffff) + rax);
    xmm0 = intrinsic_divsd(xmm0, *0x10050c940);
    *(r15 + 0x640) = intrinsic_movsd(*(r15 + 0x640), xmm0);
    if (*(int8_t *)(r15 + 0x62c) != 0x0) {
            rax = PlayLayer::incrementJumps(*(GameManager::sharedState() + 0x180));
            *(int8_t *)(r15 + 0x7c0) = 0x1;
    }
    if (*(int8_t *)(r15 + 0x772) == 0x0) goto loc_10021a345;

loc_10021a2f1 :
    rsi = 0x0;
    rax = PlayerObject::flipGravity(r15, *(int8_t *)(r15 + 0x776) == 0x0 ? 0x1 : 0x0, 0x1);
    xmm0 = intrinsic_movsd(xmm0, *(r15 + 0x760));
    xmm0 = intrinsic_mulsd(xmm0, *0x100511088);
    *(r15 + 0x760) = intrinsic_movsd(*(r15 + 0x760), xmm0);
    *(int8_t *)(r15 + 0x62f) = 0x0;
    *(int8_t *)(r15 + 0x745) = 0x0;
    goto loc_10021a336;

loc_10021a336 :
    if (*(int8_t *)(r15 + 0x774) != 0x0) goto loc_10021a34f;
    goto loc_100219da5;

loc_10021a34f :
    rbx = *(r15 + 0x6a8);
    rax = std::basic_string<char, std::char_traits<char>, std::allocator<char> >::basic_string(var_60, ""jump_loop"", var_20);
    xmm0 = intrinsic_movss(xmm0, *(int32_t *)value 0.10);
    rax = CCAnimatedSprite::tweenToAnimation(rbx, var_60);
    rax = var_60;
    goto loc_10021a382;

loc_10021a345 :
    if (*(int8_t *)(r15 + 0x774) == 0x0) goto loc_10021a3b3;
    goto loc_10021a34f;

loc_10021a3b3 :
    if (*(int8_t *)(r15 + 0x775) != 0x0) goto loc_10021a336;

loc_10021a3c1 :
    rax = PlayerObject::runRotateAction(r15, 0x1, 0x10050d470);
    if (*(int8_t *)(r15 + 0x774) != 0x0) goto loc_10021a34f;
    goto loc_100219da5;

loc_100219e2c :
    xmm2 = intrinsic_movss(xmm2, *(int32_t *)(0x100511068 + rsi * 0x4));
    if (rax != 0x0) goto loc_100219b6d;
    goto loc_100219b98;

loc_10021976c :
    if (rcx == 0x0) goto loc_10021979f;

loc_100219770 :
    xmm1 = intrinsic_movss(xmm1, *(int32_t *)(r15 + 0x77c));
    asm{ cmpneqss   xmm1, dword [value 1.0] };
    rsi = zero_extend_32(xmm1) & 0x1;
    rdi = 0x1;
    xmm5 = intrinsic_movss(xmm5, *(int32_t *)0x100510eb8);
    if (rsi == 0x0) {
            xmm6 = intrinsic_movss(xmm6, *(int32_t *)value 1.0);
    }
    else {
            xmm6 = intrinsic_movss(xmm6, *(int32_t *)0x10050d3dc);
    }
    goto loc_100219856;

loc_10021979f :
    if (((*(int8_t *)(r15 + 0x771) != 0x0) || (*(int8_t *)(r15 + 0x773) != 0x0)) || (*(int8_t *)(r15 + 0x775) != 0x0)) goto loc_1002197bd;

loc_1002197f6 :
    xmm5 = intrinsic_cvtsd2ss(xmm5, xmm0);
    xmm1 = intrinsic_movss(xmm1, *(int32_t *)(r15 + 0x77c));
    asm{ cmpneqss   xmm1, dword [value 1.0] };
    rsi = zero_extend_32(xmm1) & 0x1;
    goto loc_100219813;

loc_1002197bd :
    xmm1 = intrinsic_movss(xmm1, *(int32_t *)(r15 + 0x77c));
    asm{ cmpneqss   xmm1, dword [value 1.0] };
    rsi = zero_extend_32(xmm1) & 0x1;
    xmm1 = zero_extend_32(*(int32_t *)(0x10050e370 + rsi * 0x4));
    xmm5 = intrinsic_movss(xmm5, *(int32_t *)0x100510eb8);
    if (*(int8_t *)(r15 + 0x771) != 0x0) goto loc_100219829;
}",16180,True,4233.218540470246,median
"// Copyright 2012 the V8 project 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 ""src/compiler.h""

#include <algorithm>
#include <memory>

#include ""src/asmjs/asm-js.h""
#include ""src/asmjs/asm-typer.h""
#include ""src/ast/ast-numbering.h""
#include ""src/ast/prettyprinter.h""
#include ""src/ast/scopes.h""
#include ""src/bootstrapper.h""
#include ""src/codegen.h""
#include ""src/compilation-cache.h""
#include ""src/compiler-dispatcher/optimizing-compile-dispatcher.h""
#include ""src/compiler/pipeline.h""
#include ""src/crankshaft/hydrogen.h""
#include ""src/debug/debug.h""
#include ""src/debug/liveedit.h""
#include ""src/deoptimizer.h""
#include ""src/frames-inl.h""
#include ""src/full-codegen/full-codegen.h""
#include ""src/globals.h""
#include ""src/heap/heap.h""
#include ""src/interpreter/interpreter.h""
#include ""src/isolate-inl.h""
#include ""src/log-inl.h""
#include ""src/messages.h""
#include ""src/parsing/parser.h""
#include ""src/parsing/rewriter.h""
#include ""src/parsing/scanner-character-streams.h""
#include ""src/runtime-profiler.h""
#include ""src/snapshot/code-serializer.h""
#include ""src/vm-state-inl.h""

namespace v8 {
namespace internal {



// A wrapper around a CompilationInfo that detaches the Handles from
// the underlying DeferredHandleScope and stores them in info_ on
// destruction.
class CompilationHandleScope final {
 public:
  explicit CompilationHandleScope(CompilationInfo* info)
      : deferred_(info->isolate()), info_(info) {}
  ~CompilationHandleScope() { info_->set_deferred_handles(deferred_.Detach()); }

 private:
  DeferredHandleScope deferred_;
  CompilationInfo* info_;
};

// Helper that times a scoped region and records the elapsed time.
struct ScopedTimer {
  explicit ScopedTimer(base::TimeDelta* location) : location_(location) {
    DCHECK(location_ != NULL);
    timer_.Start();
  }

  ~ScopedTimer() { *location_ += timer_.Elapsed(); }

  base::ElapsedTimer timer_;
  base::TimeDelta* location_;
};

// ----------------------------------------------------------------------------
// Implementation of CompilationJob

CompilationJob::Status CompilationJob::PrepareJob() {
  DCHECK(ThreadId::Current().Equals(info()->isolate()->thread_id()));
  DisallowJavascriptExecution no_js(isolate());

  if (FLAG_trace_opt && info()->IsOptimizing()) {
    OFStream os(stdout);
    os << ""[compiling method "" << Brief(*info()->closure()) << "" using ""
       << compiler_name_;
    if (info()->is_osr()) os << "" OSR"";
    os << ""]"" << std::endl;
  }

  // Delegate to the underlying implementation.
  DCHECK(state() == State::kReadyToPrepare);
  ScopedTimer t(&time_taken_to_prepare_);
  return UpdateState(PrepareJobImpl(), State::kReadyToExecute);
}

CompilationJob::Status CompilationJob::ExecuteJob() {
  std::unique_ptr<DisallowHeapAllocation> no_allocation;
  std::unique_ptr<DisallowHandleAllocation> no_handles;
  std::unique_ptr<DisallowHandleDereference> no_deref;
  std::unique_ptr<DisallowCodeDependencyChange> no_dependency_change;
  if (can_execute_on_background_thread()) {
    no_allocation.reset(new DisallowHeapAllocation());
    no_handles.reset(new DisallowHandleAllocation());
    no_deref.reset(new DisallowHandleDereference());
    no_dependency_change.reset(new DisallowCodeDependencyChange());
  } else {
    DCHECK(ThreadId::Current().Equals(info()->isolate()->thread_id()));
  }

  // Delegate to the underlying implementation.
  DCHECK(state() == State::kReadyToExecute);
  ScopedTimer t(&time_taken_to_execute_);
  return UpdateState(ExecuteJobImpl(), State::kReadyToFinalize);
}

CompilationJob::Status CompilationJob::FinalizeJob() {
  DCHECK(ThreadId::Current().Equals(info()->isolate()->thread_id()));
  DisallowCodeDependencyChange no_dependency_change;
  DisallowJavascriptExecution no_js(isolate());
  DCHECK(!info()->dependencies()->HasAborted());

  // Delegate to the underlying implementation.
  DCHECK(state() == State::kReadyToFinalize);
  ScopedTimer t(&time_taken_to_finalize_);
  return UpdateState(FinalizeJobImpl(), State::kSucceeded);
}

CompilationJob::Status CompilationJob::RetryOptimization(BailoutReason reason) {
  DCHECK(info_->IsOptimizing());
  info_->RetryOptimization(reason);
  state_ = State::kFailed;
  return FAILED;
}

CompilationJob::Status CompilationJob::AbortOptimization(BailoutReason reason) {
  DCHECK(info_->IsOptimizing());
  info_->AbortOptimization(reason);
  state_ = State::kFailed;
  return FAILED;
}

void CompilationJob::RecordUnoptimizedCompilationStats() const {
  int code_size;
  if (info()->has_bytecode_array()) {
    code_size = info()->bytecode_array()->SizeIncludingMetadata();
  } else {
    code_size = info()->code()->SizeIncludingMetadata();
  }

  Counters* counters = isolate()->counters();
  // TODO(4280): Rename counters from ""baseline"" to ""unoptimized"" eventually.
  counters->total_baseline_code_size()->Increment(code_size);
  counters->total_baseline_compile_count()->Increment(1);

  // TODO(5203): Add timers for each phase of compilation.
}

void CompilationJob::RecordOptimizedCompilationStats() const {
  DCHECK(info()->IsOptimizing());
  Handle<JSFunction> function = info()->closure();
  if (!function->IsOptimized()) {
    // Concurrent recompilation and OSR may race.  Increment only once.
    int opt_count = function->shared()->opt_count();
    function->shared()->set_opt_count(opt_count + 1);
  }
  double ms_creategraph = time_taken_to_prepare_.InMillisecondsF();
  double ms_optimize = time_taken_to_execute_.InMillisecondsF();
  double ms_codegen = time_taken_to_finalize_.InMillisecondsF();
  if (FLAG_trace_opt) {
    PrintF(""[optimizing "");
    function->ShortPrint();
    PrintF("" - took %0.3f, %0.3f, %0.3f ms]\\n"", ms_creategraph, ms_optimize,
           ms_codegen);
  }
  if (FLAG_trace_opt_stats) {
    static double compilation_time = 0.0;
    static int compiled_functions = 0;
    static int code_size = 0;

    compilation_time += (ms_creategraph + ms_optimize + ms_codegen);
    compiled_functions++;
    code_size += function->shared()->SourceSize();
    PrintF(""Compiled: %d functions with %d byte source size in %fms.\\n"",
           compiled_functions, code_size, compilation_time);
  }
  if (FLAG_hydrogen_stats) {
    isolate()->GetHStatistics()->IncrementSubtotals(time_taken_to_prepare_,
                                                    time_taken_to_execute_,
                                                    time_taken_to_finalize_);
  }
}

Isolate* CompilationJob::isolate() const { return info()->isolate(); }

namespace {

void AddWeakObjectToCodeDependency(Isolate* isolate, Handle<HeapObject> object,
                                   Handle<Code> code) {
  Handle<WeakCell> cell = Code::WeakCellFor(code);
  Heap* heap = isolate->heap();
  if (heap->InNewSpace(*object)) {
    heap->AddWeakNewSpaceObjectToCodeDependency(object, cell);
  } else {
    Handle<DependentCode> dep(heap->LookupWeakObjectToCodeDependency(object));
    dep =
        DependentCode::InsertWeakCode(dep, DependentCode::kWeakCodeGroup, cell);
    heap->AddWeakObjectToCodeDependency(object, dep);
  }
}

}  // namespace

void CompilationJob::RegisterWeakObjectsInOptimizedCode(Handle<Code> code) {
  // TODO(turbofan): Move this to pipeline.cc once Crankshaft dies.
  Isolate* const isolate = code->GetIsolate();
  DCHECK(code->is_optimized_code());
  std::vector<Handle<Map>> maps;
  std::vector<Handle<HeapObject>> objects;
  {
    DisallowHeapAllocation no_gc;
    int const mode_mask = RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT) |
                          RelocInfo::ModeMask(RelocInfo::CELL);
    for (RelocIterator it(*code, mode_mask); !it.done(); it.next()) {
      RelocInfo::Mode mode = it.rinfo()->rmode();
      if (mode == RelocInfo::CELL &&
          code->IsWeakObjectInOptimizedCode(it.rinfo()->target_cell())) {
        objects.push_back(handle(it.rinfo()->target_cell(), isolate));
      } else if (mode == RelocInfo::EMBEDDED_OBJECT &&
                 code->IsWeakObjectInOptimizedCode(
                     it.rinfo()->target_object())) {
        Handle<HeapObject> object(HeapObject::cast(it.rinfo()->target_object()),
                                  isolate);
        if (object->IsMap()) {
          maps.push_back(Handle<Map>::cast(object));
        } else {
          objects.push_back(object);
        }
      }
    }
  }
  for (Handle<Map> map : maps) {
    if (map->dependent_code()->IsEmpty(DependentCode::kWeakCodeGroup)) {
      isolate->heap()->AddRetainedMap(map);
    }
    Map::AddDependentCode(map, DependentCode::kWeakCodeGroup, code);
  }
  for (Handle<HeapObject> object : objects) {
    AddWeakObjectToCodeDependency(isolate, object, code);
  }
  code->set_can_have_weak_objects(true);
}

// ----------------------------------------------------------------------------
// Local helper methods that make up the compilation pipeline.

namespace {

bool Parse(ParseInfo* info) {
  // Create a canonical handle scope if compiling ignition bytecode. This is
  // required by the constant array builder to de-duplicate objects without
  // dereferencing handles.
  std::unique_ptr<CanonicalHandleScope> canonical;
  if (FLAG_ignition) canonical.reset(new CanonicalHandleScope(info->isolate()));

  return Parser::ParseStatic(info);
}

void RecordFunctionCompilation(CodeEventListener::LogEventsAndTags tag,
                               CompilationInfo* info) {
  // Log the code generation. If source information is available include
  // script name and line number. Check explicitly whether logging is
  // enabled as finding the line number is not free.
  if (info->isolate()->logger()->is_logging_code_events() ||
      info->isolate()->is_profiling()) {
    Handle<SharedFunctionInfo> shared = info->shared_info();
    Handle<Script> script = info->parse_info()->script();
    Handle<AbstractCode> abstract_code =
        info->has_bytecode_array()
            ? Handle<AbstractCode>::cast(info->bytecode_array())
            : Handle<AbstractCode>::cast(info->code());
    if (abstract_code.is_identical_to(
            info->isolate()->builtins()->CompileLazy())) {
      return;
    }
    int line_num = Script::GetLineNumber(script, shared->start_position()) + 1;
    int column_num =
        Script::GetColumnNumber(script, shared->start_position()) + 1;
    String* script_name = script->name()->IsString()
                              ? String::cast(script->name())
                              : info->isolate()->heap()->empty_string();
    CodeEventListener::LogEventsAndTags log_tag =
        Logger::ToNativeByScript(tag, *script);
    PROFILE(info->isolate(),
            CodeCreateEvent(log_tag, *abstract_code, *shared, script_name,
                            line_num, column_num));
  }
}

void EnsureFeedbackMetadata(CompilationInfo* info) {
  DCHECK(info->has_shared_info());

  // If no type feedback metadata exists, we create it now. At this point the
  // AstNumbering pass has already run. Note the snapshot can contain outdated
  // vectors for a different configuration, hence we also recreate a new vector
  // when the function is not compiled (i.e. no code was serialized).

  // TODO(mvstanton): reintroduce is_empty() predicate to feedback_metadata().
  if (info->shared_info()->feedback_metadata()->length() == 0 ||
      !info->shared_info()->is_compiled()) {
    Handle<TypeFeedbackMetadata> feedback_metadata = TypeFeedbackMetadata::New(
        info->isolate(), info->literal()->feedback_vector_spec());
    info->shared_info()->set_feedback_metadata(*feedback_metadata);
  }

  // It's very important that recompiles do not alter the structure of the type
  // feedback vector. Verify that the structure fits the function literal.
  CHECK(!info->shared_info()->feedback_metadata()->SpecDiffersFrom(
      info->literal()->feedback_vector_spec()));
}

bool ShouldUseIgnition(CompilationInfo* info) {
  if (!FLAG_ignition) return false;

  DCHECK(info->has_shared_info());

  // When requesting debug code as a replacement for existing code, we provide
  // the same kind as the existing code (to prevent implicit tier-change).
  if (info->is_debug() && info->shared_info()->is_compiled()) {
    return !info->shared_info()->HasBaselineCode();
  }

  // Since we can't OSR from Ignition, skip Ignition for asm.js functions.
  if (info->shared_info()->asm_function()) {
    return false;
  }

  // Checks whether top level functions should be passed by the filter.
  if (info->shared_info()->is_toplevel()) {
    Vector<const char> filter = CStrVector(FLAG_ignition_filter);
    return (filter.length() == 0) || (filter.length() == 1 && filter[0] == '*');
  }

  // Finally respect the filter.
  return info->shared_info()->PassesFilter(FLAG_ignition_filter);
}

CompilationJob* GetUnoptimizedCompilationJob(CompilationInfo* info) {
  // Function should have been parsed and analyzed before creating a compilation
  // job.
  DCHECK_NOT_NULL(info->literal());
  DCHECK_NOT_NULL(info->scope());

  EnsureFeedbackMetadata(info);
  if (ShouldUseIgnition(info)) {
    return interpreter::Interpreter::NewCompilationJob(info);
  } else {
    return FullCodeGenerator::NewCompilationJob(info);
  }
}

void InstallSharedScopeInfo(CompilationInfo* info,
                            Handle<SharedFunctionInfo> shared) {
  Handle<ScopeInfo> scope_info = info->scope()->scope_info();
  shared->set_scope_info(*scope_info);
  Scope* outer_scope = info->scope()->GetOuterScopeWithContext();
  if (outer_scope) {
    shared->set_outer_scope_info(*outer_scope->scope_info());
  }
}

void InstallSharedCompilationResult(CompilationInfo* info,
                                    Handle<SharedFunctionInfo> shared) {
  // TODO(mstarzinger): Compiling for debug code might be used to reveal inner
  // functions via {FindSharedFunctionInfoInScript}, in which case we end up
  // regenerating existing bytecode. Fix this!
  if (info->is_debug() && info->has_bytecode_array()) {
    shared->ClearBytecodeArray();
  }
  DCHECK(!info->code().is_null());
  shared->ReplaceCode(*info->code());
  if (info->has_bytecode_array()) {
    DCHECK(!shared->HasBytecodeArray());  // Only compiled once.
    shared->set_bytecode_array(*info->bytecode_array());
  }
}

void InstallUnoptimizedCode(CompilationInfo* info) {
  Handle<SharedFunctionInfo> shared = info->shared_info();

  // Update the shared function info with the scope info.
  InstallSharedScopeInfo(info, shared);

  // Install compilation result on the shared function info
  InstallSharedCompilationResult(info, shared);
}

CompilationJob::Status FinalizeUnoptimizedCompilationJob(CompilationJob* job) {
  CompilationJob::Status status = job->FinalizeJob();
  if (status == CompilationJob::SUCCEEDED) {
    InstallUnoptimizedCode(job->info());
    job->RecordUnoptimizedCompilationStats();
  }
  return status;
}

bool GenerateUnoptimizedCode(CompilationInfo* info) {
  if (FLAG_validate_asm && info->scope()->asm_module() &&
      !info->shared_info()->is_asm_wasm_broken()) {
    EnsureFeedbackMetadata(info);
    MaybeHandle<FixedArray> wasm_data;
    wasm_data = AsmJs::ConvertAsmToWasm(info->parse_info());
    if (!wasm_data.is_null()) {
      info->shared_info()->set_asm_wasm_data(*wasm_data.ToHandleChecked());
      info->SetCode(info->isolate()->builtins()->InstantiateAsmJs());
      InstallUnoptimizedCode(info);
      return true;
    }
  }

  std::unique_ptr<CompilationJob> job(GetUnoptimizedCompilationJob(info));
  if (job->PrepareJob() != CompilationJob::SUCCEEDED) return false;
  if (job->ExecuteJob() != CompilationJob::SUCCEEDED) return false;
  if (FinalizeUnoptimizedCompilationJob(job.get()) !=
      CompilationJob::SUCCEEDED) {
    return false;
  }
  return true;
}

bool CompileUnoptimizedCode(CompilationInfo* info) {
  DCHECK(AllowCompilation::IsAllowed(info->isolate()));
  if (!Compiler::Analyze(info->parse_info()) ||
      !GenerateUnoptimizedCode(info)) {
    Isolate* isolate = info->isolate();
    if (!isolate->has_pending_exception()) isolate->StackOverflow();
    return false;
  }
  return true;
}

MUST_USE_RESULT MaybeHandle<Code> GetUnoptimizedCode(CompilationInfo* info) {
  VMState<COMPILER> state(info->isolate());
  PostponeInterruptsScope postpone(info->isolate());

  // Parse and update CompilationInfo with the results.
  if (!Parse(info->parse_info())) return MaybeHandle<Code>();
  DCHECK_EQ(info->shared_info()->language_mode(),
            info->literal()->language_mode());

  // Compile either unoptimized code or bytecode for the interpreter.
  if (!CompileUnoptimizedCode(info)) return MaybeHandle<Code>();

  // Record the function compilation event.
  RecordFunctionCompilation(CodeEventListener::LAZY_COMPILE_TAG, info);

  return info->code();
}

MUST_USE_RESULT MaybeHandle<Code> GetCodeFromOptimizedCodeMap(
    Handle<JSFunction> function, BailoutId osr_ast_id) {
  Handle<SharedFunctionInfo> shared(function->shared());
  DisallowHeapAllocation no_gc;
  CodeAndLiterals cached = shared->SearchOptimizedCodeMap(
      function->context()->native_context(), osr_ast_id);
  if (cached.code != nullptr) {
    // Caching of optimized code enabled and optimized code found.
    if (cached.literals != nullptr) function->set_literals(cached.literals);
    DCHECK(!cached.code->marked_for_deoptimization());
    DCHECK(function->shared()->is_compiled());
    return Handle<Code>(cached.code);
  }
  return MaybeHandle<Code>();
}

void InsertCodeIntoOptimizedCodeMap(CompilationInfo* info) {
  Handle<Code> code = info->code();
  if (code->kind() != Code::OPTIMIZED_FUNCTION) return;  // Nothing to do.

  // Function context specialization folds-in the function context,
  // so no sharing can occur.
  if (info->is_function_context_specializing()) return;
  // Frame specialization implies function context specialization.
  DCHECK(!info->is_frame_specializing());

  // TODO(4764): When compiling for OSR from bytecode, BailoutId might derive
  // from bytecode offset and overlap with actual BailoutId. No caching!
  if (info->is_osr() && info->is_optimizing_from_bytecode()) return;

  // Cache optimized context-specific code.
  Handle<JSFunction> function = info->closure();
  Handle<SharedFunctionInfo> shared(function->shared());
  Handle<LiteralsArray> literals(function->literals());
  Handle<Context> native_context(function->context()->native_context());
  SharedFunctionInfo::AddToOptimizedCodeMap(shared, native_context, code,
                                            literals, info->osr_ast_id());
}

bool Renumber(ParseInfo* parse_info) {
  // Create a canonical handle scope if compiling ignition bytecode. This is
  // required by the constant array builder to de-duplicate objects without
  // dereferencing handles.
  std::unique_ptr<CanonicalHandleScope> canonical;
  if (FLAG_ignition) {
    canonical.reset(new CanonicalHandleScope(parse_info->isolate()));
  }

  if (!AstNumbering::Renumber(parse_info->isolate(), parse_info->zone(),
                              parse_info->literal())) {
    return false;
  }
  Handle<SharedFunctionInfo> shared_info = parse_info->shared_info();
  if (!shared_info.is_null()) {
    FunctionLiteral* lit = parse_info->literal();
    shared_info->set_ast_node_count(lit->ast_node_count());
    if (lit->dont_optimize_reason() != kNoReason) {
      shared_info->DisableOptimization(lit->dont_optimize_reason());
    }
    if (lit->flags() & AstProperties::kDontCrankshaft) {
      shared_info->set_dont_crankshaft(true);
    }
  }
  return true;
}

bool UseTurboFan(Handle<SharedFunctionInfo> shared) {
  bool optimization_disabled = shared->optimization_disabled();
  bool dont_crankshaft = shared->dont_crankshaft();

  // Check the enabling conditions for Turbofan.
  // 1. ""use asm"" code.
  bool is_turbofanable_asm =
      FLAG_turbo_asm && shared->asm_function() && !optimization_disabled;

  // 2. Fallback for features unsupported by Crankshaft.
  bool is_unsupported_by_crankshaft_but_turbofanable =
      dont_crankshaft && strcmp(FLAG_turbo_filter, ""~~"") == 0 &&
      !optimization_disabled;

  // 3. Explicitly enabled by the command-line filter.
  bool passes_turbo_filter = shared->PassesFilter(FLAG_turbo_filter);

  return is_turbofanable_asm || is_unsupported_by_crankshaft_but_turbofanable ||
         passes_turbo_filter;
}

bool GetOptimizedCodeNow(CompilationJob* job) {
  CompilationInfo* info = job->info();
  Isolate* isolate = info->isolate();

  // Parsing is not required when optimizing from existing bytecode.
  if (!info->is_optimizing_from_bytecode()) {
    if (!Compiler::ParseAndAnalyze(info->parse_info())) return false;
    EnsureFeedbackMetadata(info);
  }

  JSFunction::EnsureLiterals(info->closure());

  TimerEventScope<TimerEventRecompileSynchronous> timer(isolate);
  RuntimeCallTimerScope runtimeTimer(isolate,
                                     &RuntimeCallStats::RecompileSynchronous);
  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT(""v8.compile""),
               ""V8.RecompileSynchronous"");

  if (job->PrepareJob() != CompilationJob::SUCCEEDED ||
      job->ExecuteJob() != CompilationJob::SUCCEEDED ||
      job->FinalizeJob() != CompilationJob::SUCCEEDED) {
    if (FLAG_trace_opt) {
      PrintF(""[aborted optimizing "");
      info->closure()->ShortPrint();
      PrintF("" because: %s]\\n"", GetBailoutReason(info->bailout_reason()));
    }
    return false;
  }

  // Success!
  job->RecordOptimizedCompilationStats();
  DCHECK(!isolate->has_pending_exception());
  InsertCodeIntoOptimizedCodeMap(info);
  RecordFunctionCompilation(CodeEventListener::LAZY_COMPILE_TAG, info);
  return true;
}

bool GetOptimizedCodeLater(CompilationJob* job) {
  CompilationInfo* info = job->info();
  Isolate* isolate = info->isolate();

  if (!isolate->optimizing_compile_dispatcher()->IsQueueAvailable()) {
    if (FLAG_trace_concurrent_recompilation) {
      PrintF(""  ** Compilation queue full, will retry optimizing "");
      info->closure()->ShortPrint();
      PrintF("" later.\\n"");
    }
    return false;
  }

  if (isolate->heap()->HighMemoryPressure()) {
    if (FLAG_trace_concurrent_recompilation) {
      PrintF(""  ** High memory pressure, will retry optimizing "");
      info->closure()->ShortPrint();
      PrintF("" later.\\n"");
    }
    return false;
  }

  // Parsing is not required when optimizing from existing bytecode.
  if (!info->is_optimizing_from_bytecode()) {
    if (!Compiler::ParseAndAnalyze(info->parse_info())) return false;
    EnsureFeedbackMetadata(info);
  }

  JSFunction::EnsureLiterals(info->closure());

  TimerEventScope<TimerEventRecompileSynchronous> timer(info->isolate());
  RuntimeCallTimerScope runtimeTimer(info->isolate(),
                                     &RuntimeCallStats::RecompileSynchronous);
  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT(""v8.compile""),
               ""V8.RecompileSynchronous"");

  if (job->PrepareJob() != CompilationJob::SUCCEEDED) return false;
  isolate->optimizing_compile_dispatcher()->QueueForOptimization(job);

  if (FLAG_trace_concurrent_recompilation) {
    PrintF(""  ** Queued "");
    info->closure()->ShortPrint();
    PrintF("" for concurrent optimization.\\n"");
  }
  return true;
}

MaybeHandle<Code> GetOptimizedCode(Handle<JSFunction> function,
                                   Compiler::ConcurrencyMode mode,
                                   BailoutId osr_ast_id = BailoutId::None(),
                                   JavaScriptFrame* osr_frame = nullptr) {
  Isolate* isolate = function->GetIsolate();
  Handle<SharedFunctionInfo> shared(function->shared(), isolate);

  bool ignition_osr = osr_frame && osr_frame->is_interpreted();
  DCHECK_IMPLIES(ignition_osr, !osr_ast_id.IsNone());
  DCHECK_IMPLIES(ignition_osr, FLAG_ignition_osr);

  // Flag combination --ignition-osr --no-turbo-from-bytecode is unsupported.
  if (ignition_osr && !FLAG_turbo_from_bytecode) return MaybeHandle<Code>();

  Handle<Code> cached_code;
  // TODO(4764): When compiling for OSR from bytecode, BailoutId might derive
  // from bytecode offset and overlap with actual BailoutId. No lookup!
  if (!ignition_osr &&
      GetCodeFromOptimizedCodeMap(function, osr_ast_id)
          .ToHandle(&cached_code)) {
    if (FLAG_trace_opt) {
      PrintF(""[found optimized code for "");
      function->ShortPrint();
      if (!osr_ast_id.IsNone()) {
        PrintF("" at OSR AST id %d"", osr_ast_id.ToInt());
      }
      PrintF(""]\\n"");
    }
    return cached_code;
  }

  // Reset profiler ticks, function is no longer considered hot.
  if (shared->is_compiled()) {
    shared->code()->set_profiler_ticks(0);
  }

  VMState<COMPILER> state(isolate);
  DCHECK(!isolate->has_pending_exception());
  PostponeInterruptsScope postpone(isolate);
  bool use_turbofan = UseTurboFan(shared) || ignition_osr;
  std::unique_ptr<CompilationJob> job(
      use_turbofan ? compiler::Pipeline::NewCompilationJob(function)
                   : new HCompilationJob(function));
  CompilationInfo* info = job->info();
  ParseInfo* parse_info = info->parse_info();

  info->SetOptimizingForOsr(osr_ast_id, osr_frame);

  // Do not use Crankshaft/TurboFan if we need to be able to set break points.
  if (info->shared_info()->HasDebugInfo()) {
    info->AbortOptimization(kFunctionBeingDebugged);
    return MaybeHandle<Code>();
  }

  // Limit the number of times we try to optimize functions.
  const int kMaxOptCount =
      FLAG_deopt_every_n_times == 0 ? FLAG_max_opt_count : 1000;
  if (info->shared_info()->opt_count() > kMaxOptCount) {
    info->AbortOptimization(kOptimizedTooManyTimes);
    return MaybeHandle<Code>();
  }

  TimerEventScope<TimerEventOptimizeCode> optimize_code_timer(isolate);
  RuntimeCallTimerScope runtimeTimer(isolate, &RuntimeCallStats::OptimizeCode);
  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT(""v8.compile""), ""V8.OptimizeCode"");

  // TurboFan can optimize directly from existing bytecode.
  if (FLAG_turbo_from_bytecode && use_turbofan && ShouldUseIgnition(info)) {
    if (info->is_osr() && !ignition_osr) return MaybeHandle<Code>();
    if (!Compiler::EnsureBytecode(info)) {
      if (isolate->has_pending_exception()) isolate->clear_pending_exception();
      return MaybeHandle<Code>();
    }
    info->MarkAsOptimizeFromBytecode();
  }

  // Verify that OSR compilations are delegated to the correct graph builder.
  // Depending on the underlying frame the semantics of the {BailoutId} differ
  // and the various graph builders hard-code a certain semantic:
  //  - Interpreter : The BailoutId represents a bytecode offset.
  //  - FullCodegen : The BailoutId represents the id of an AST node.
  DCHECK_IMPLIES(info->is_osr() && ignition_osr,
                 info->is_optimizing_from_bytecode());
  DCHECK_IMPLIES(info->is_osr() && !ignition_osr,
                 !info->is_optimizing_from_bytecode());

  // In case of concurrent recompilation, all handles below this point will be
  // allocated in a deferred handle scope that is detached and handed off to
  // the background thread when we return.
  std::unique_ptr<CompilationHandleScope> compilation;
  if (mode == Compiler::CONCURRENT) {
    compilation.reset(new CompilationHandleScope(info));
  }

  // In case of TurboFan, all handles below will be canonicalized.
  std::unique_ptr<CanonicalHandleScope> canonical;
  if (use_turbofan) canonical.reset(new CanonicalHandleScope(info->isolate()));

  // Reopen handles in the new CompilationHandleScope.
  info->ReopenHandlesInNewHandleScope();
  parse_info->ReopenHandlesInNewHandleScope();

  if (mode == Compiler::CONCURRENT) {
    if (GetOptimizedCodeLater(job.get())) {
      job.release();  // The background recompile job owns this now.
      return isolate->builtins()->InOptimizationQueue();
    }
  } else {
    if (GetOptimizedCodeNow(job.get())) return info->code();
  }

  if (isolate->has_pending_exception()) isolate->clear_pending_exception();
  return MaybeHandle<Code>();
}

CompilationJob::Status FinalizeOptimizedCompilationJob(CompilationJob* job) {
  CompilationInfo* info = job->info();
  Isolate* isolate = info->isolate();

  TimerEventScope<TimerEventRecompileSynchronous> timer(info->isolate());
  RuntimeCallTimerScope runtimeTimer(isolate,
                                     &RuntimeCallStats::RecompileSynchronous);
  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT(""v8.compile""),
               ""V8.RecompileSynchronous"");

  Handle<SharedFunctionInfo> shared = info->shared_info();
  shared->code()->set_profiler_ticks(0);

  DCHECK(!shared->HasDebugInfo());

  // 1) Optimization on the concurrent thread may have failed.
  // 2) The function may have already been optimized by OSR.  Simply continue.
  //    Except when OSR already disabled optimization for some reason.
  // 3) The code may have already been invalidated due to dependency change.
  // 4) Code generation may have failed.
  if (job->state() == CompilationJob::State::kReadyToFinalize) {
    if (shared->optimization_disabled()) {
      job->RetryOptimization(kOptimizationDisabled);
    } else if (info->dependencies()->HasAborted()) {
      job->RetryOptimization(kBailedOutDueToDependencyChange);
    } else if (job->FinalizeJob() == CompilationJob::SUCCEEDED) {
      job->RecordOptimizedCompilationStats();
      RecordFunctionCompilation(CodeEventListener::LAZY_COMPILE_TAG, info);
      if (shared
              ->SearchOptimizedCodeMap(info->context()->native_context(),
                                       info->osr_ast_id())
              .code == nullptr) {
        InsertCodeIntoOptimizedCodeMap(info);
      }
      if (FLAG_trace_opt) {
        PrintF(""[completed optimizing "");
        info->closure()->ShortPrint();
        PrintF(""]\\n"");
      }
      info->closure()->ReplaceCode(*info->code());
      return CompilationJob::SUCCEEDED;
    }
  }

  DCHECK(job->state() == CompilationJob::State::kFailed);
  if (FLAG_trace_opt) {
    PrintF(""[aborted optimizing "");
    info->closure()->ShortPrint();
    PrintF("" because: %s]\\n"", GetBailoutReason(info->bailout_reason()));
  }
  info->closure()->ReplaceCode(shared->code());
  return CompilationJob::FAILED;
}

class InterpreterActivationsFinder : public ThreadVisitor,
                                     public OptimizedFunctionVisitor {
 public:
  explicit InterpreterActivationsFinder(SharedFunctionInfo* shared)
      : shared_(shared), has_activations_(false) {}

  void VisitThread(Isolate* isolate, ThreadLocalTop* top) {
    Address* activation_pc_address = nullptr;
    JavaScriptFrameIterator it(isolate, top);
    for (; !it.done(); it.Advance()) {
      JavaScriptFrame* frame = it.frame();
      if (FLAG_turbo_from_bytecode && FLAG_ignition_osr &&
          frame->is_optimized() && frame->function()->shared() == shared_) {
        // If we are able to optimize functions directly from bytecode, then
        // there might be optimized OSR code active on the stack that is not
        // reachable through a function. We count this as an activation.
        has_activations_ = true;
      }
      if (frame->is_interpreted() && frame->function()->shared() == shared_) {
        has_activations_ = true;
        activation_pc_address = frame->pc_address();
      }
    }

    if (activation_pc_address) {
      activation_pc_addresses_.push_back(activation_pc_address);
    }
  }

  void VisitFunction(JSFunction* function) {
    if (function->Inlines(shared_)) has_activations_ = true;
  }

  void EnterContext(Context* context) {}
  void LeaveContext(Context* context) {}

  bool MarkActivationsForBaselineOnReturn(Isolate* isolate) {
    if (activation_pc_addresses_.empty()) return false;

    for (Address* activation_pc_address : activation_pc_addresses_) {
      DCHECK(isolate->inner_pointer_to_code_cache()
                 ->GetCacheEntry(*activation_pc_address)
                 ->code->is_interpreter_trampoline_builtin());
      *activation_pc_address =
          isolate->builtins()->InterpreterMarkBaselineOnReturn()->entry();
    }
    return true;
  }

  bool has_activations() { return has_activations_; }

 private:
  SharedFunctionInfo* shared_;
  bool has_activations_;
  std::vector<Address*> activation_pc_addresses_;
};

bool HasInterpreterActivations(
    Isolate* isolate, InterpreterActivationsFinder* activations_finder) {
  activations_finder->VisitThread(isolate, isolate->thread_local_top());
  isolate->thread_manager()->IterateArchivedThreads(activations_finder);
  if (FLAG_turbo_from_bytecode) {
    // If we are able to optimize functions directly from bytecode, then there
    // might be optimized functions that rely on bytecode being around. We need
    // to prevent switching the given function to baseline code in those cases.
    Deoptimizer::VisitAllOptimizedFunctions(isolate, activations_finder);
  }
  return activations_finder->has_activations();
}

MaybeHandle<Code> GetBaselineCode(Handle<JSFunction> function) {
  Isolate* isolate = function->GetIsolate();
  VMState<COMPILER> state(isolate);
  PostponeInterruptsScope postpone(isolate);
  Zone zone(isolate->allocator(), ZONE_NAME);
  ParseInfo parse_info(&zone, handle(function->shared()));
  CompilationInfo info(&parse_info, function);

  // Reset profiler ticks, function is no longer considered hot.
  if (function->shared()->HasBytecodeArray()) {
    function->shared()->set_profiler_ticks(0);
  }

  // Nothing left to do if the function already has baseline code.
  if (function->shared()->code()->kind() == Code::FUNCTION) {
    return Handle<Code>(function->shared()->code());
  }

  // We do not switch to baseline code when the debugger might have created a
  // copy of the bytecode with break slots to be able to set break points.
  if (function->shared()->HasDebugInfo()) {
    return MaybeHandle<Code>();
  }

  // TODO(4280): For now we do not switch generators or async functions to
  // baseline code because there might be suspended activations stored in
  // generator objects on the heap. We could eventually go directly to
  // TurboFan in this case.
  if (IsResumableFunction(function->shared()->kind())) {
    return MaybeHandle<Code>();
  }

  // TODO(4280): For now we disable switching to baseline code in the presence
  // of interpreter activations of the given function. The reasons is that the
  // underlying bytecode is cleared below. Note that this only applies in case
  // the --ignition-preserve-bytecode flag is not passed.
  if (!FLAG_ignition_preserve_bytecode) {
    InterpreterActivationsFinder activations_finder(function->shared());
    if (HasInterpreterActivations(isolate, &activations_finder)) {
      if (FLAG_trace_opt) {
        OFStream os(stdout);
        os << ""[unable to switch "" << Brief(*function) << "" due to activations]""
           << std::endl;
      }

      if (activations_finder.MarkActivationsForBaselineOnReturn(isolate)) {
        if (FLAG_trace_opt) {
          OFStream os(stdout);
          os << ""[marking "" << Brief(function->shared())
             << "" for baseline recompilation on return]"" << std::endl;
        }
      }

      return MaybeHandle<Code>();
    }
  }

  if (FLAG_trace_opt) {
    OFStream os(stdout);
    os << ""[switching method "" << Brief(*function) << "" to baseline code]""
       << std::endl;
  }

  // Parse and update CompilationInfo with the results.
  if (!Parse(info.parse_info())) return MaybeHandle<Code>();
  Handle<SharedFunctionInfo> shared = info.shared_info();
  DCHECK_EQ(shared->language_mode(), info.literal()->language_mode());

  // Compile baseline code using the full code generator.
  if (!Compiler::Analyze(info.parse_info()) ||
      !FullCodeGenerator::MakeCode(&info)) {
    if (!isolate->has_pending_exception()) isolate->StackOverflow();
    return MaybeHandle<Code>();
  }

  // TODO(4280): For now we play it safe and remove the bytecode array when we
  // switch to baseline code. We might consider keeping around the bytecode so
  // that it can be used as the ""source of truth"" eventually. Note that this
  // only applies in case the --ignition-preserve-bytecode flag is not passed.
  if (!FLAG_ignition_preserve_bytecode) shared->ClearBytecodeArray();

  // Update the shared function info with the scope info.
  InstallSharedScopeInfo(&info, shared);

  // Install compilation result on the shared function info
  InstallSharedCompilationResult(&info, shared);

  // Record the function compilation event.
  RecordFunctionCompilation(CodeEventListener::LAZY_COMPILE_TAG, &info);

  return info.code();
}

MaybeHandle<Code> GetLazyCode(Handle<JSFunction> function) {
  Isolate* isolate = function->GetIsolate();
  DCHECK(!isolate->has_pending_exception());
  DCHECK(!function->is_compiled());
  TimerEventScope<TimerEventCompileCode> compile_timer(isolate);
  RuntimeCallTimerScope runtimeTimer(isolate,
                                     &RuntimeCallStats::CompileCodeLazy);
  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT(""v8.compile""), ""V8.CompileCode"");
  AggregatedHistogramTimerScope timer(isolate->counters()->compile_lazy());

  Handle<Code> cached_code;
  if (GetCodeFromOptimizedCodeMap(function, BailoutId::None())
          .ToHandle(&cached_code)) {
    if (FLAG_trace_opt) {
      PrintF(""[found optimized code for "");
      function->ShortPrint();
      PrintF("" during unoptimized compile]\\n"");
    }
    DCHECK(function->shared()->is_compiled());
    return cached_code;
  }

  if (function->shared()->was_marked_for_optimization()) {
    DCHECK(FLAG_optimize_shared_functions);

    function->shared()->set_was_marked_for_optimization(false);

    if (FLAG_trace_opt) {
      PrintF(""[optimizing function "");
      function->PrintName();
      PrintF("" eagerly because shared function was previously marked]\\n"");
    }

    Handle<Code> opt_code;
    if (GetOptimizedCode(function, Compiler::NOT_CONCURRENT)
            .ToHandle(&opt_code)) {
      return opt_code;
    }
  }

  if (function->shared()->is_compiled()) {
    return Handle<Code>(function->shared()->code());
  }

  if (function->shared()->HasBytecodeArray()) {
    Handle<Code> entry = isolate->builtins()->InterpreterEntryTrampoline();
    function->shared()->ReplaceCode(*entry);
    return entry;
  }

  Zone zone(isolate->allocator(), ZONE_NAME);
  ParseInfo parse_info(&zone, handle(function->shared()));
  CompilationInfo info(&parse_info, function);
  Handle<Code> result;
  ASSIGN_RETURN_ON_EXCEPTION(isolate, result, GetUnoptimizedCode(&info), Code);

  if (FLAG_always_opt) {
    Handle<Code> opt_code;
    if (GetOptimizedCode(function, Compiler::NOT_CONCURRENT)
            .ToHandle(&opt_code)) {
      result = opt_code;
    }
  }

  return result;
}


Handle<SharedFunctionInfo> NewSharedFunctionInfoForLiteral(
    Isolate* isolate, FunctionLiteral* literal, Handle<Script> script) {
  Handle<Code> code = isolate->builtins()->CompileLazy();
  Handle<ScopeInfo> scope_info = handle(ScopeInfo::Empty(isolate));
  Handle<SharedFunctionInfo> result = isolate->factory()->NewSharedFunctionInfo(
      literal->name(), literal->materialized_literal_count(), literal->kind(),
      code, scope_info);
  SharedFunctionInfo::InitFromFunctionLiteral(result, literal);
  SharedFunctionInfo::SetScript(result, script);
  return result;
}

Handle<SharedFunctionInfo> CompileToplevel(CompilationInfo* info) {
  Isolate* isolate = info->isolate();
  TimerEventScope<TimerEventCompileCode> timer(isolate);
  RuntimeCallTimerScope runtimeTimer(isolate, &RuntimeCallStats::CompileCode);
  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT(""v8.compile""), ""V8.CompileCode"");
  PostponeInterruptsScope postpone(isolate);
  DCHECK(!isolate->native_context().is_null());
  ParseInfo* parse_info = info->parse_info();
  Handle<Script> script = parse_info->script();

  // TODO(svenpanne) Obscure place for this, perhaps move to OnBeforeCompile?
  FixedArray* array = isolate->native_context()->embedder_data();
  script->set_context_data(array->get(v8::Context::kDebugIdIndex));

  isolate->debug()->OnBeforeCompile(script);

  Handle<SharedFunctionInfo> result;

  { VMState<COMPILER> state(info->isolate());
    if (parse_info->literal() == nullptr && !Parse(parse_info)) {
      return Handle<SharedFunctionInfo>::null();
    }

    FunctionLiteral* lit = parse_info->literal();

    // Measure how long it takes to do the compilation; only take the
    // rest of the function into account to avoid overlap with the
    // parsing statistics.
    RuntimeCallTimerScope runtimeTimer(
        isolate, parse_info->is_eval() ? &RuntimeCallStats::CompileEval
                                       : &RuntimeCallStats::Compile);
    HistogramTimer* rate = parse_info->is_eval()
                               ? info->isolate()->counters()->compile_eval()
                               : info->isolate()->counters()->compile();
    HistogramTimerScope timer(rate);
    TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT(""v8.compile""),
                 parse_info->is_eval() ? ""V8.CompileEval"" : ""V8.Compile"");

    // Allocate a shared function info object.
    DCHECK_EQ(kNoSourcePosition, lit->function_token_position());
    result = NewSharedFunctionInfoForLiteral(isolate, lit, script);
    result->set_is_toplevel(true);
    parse_info->set_shared_info(result);

    // Compile the code.
    if (!CompileUnoptimizedCode(info)) {
      return Handle<SharedFunctionInfo>::null();
    }

    Handle<String> script_name =
        script->name()->IsString()
            ? Handle<String>(String::cast(script->name()))
            : isolate->factory()->empty_string();
    CodeEventListener::LogEventsAndTags log_tag =
        parse_info->is_eval()
            ? CodeEventListener::EVAL_TAG
            : Logger::ToNativeByScript(CodeEventListener::SCRIPT_TAG, *script);

    PROFILE(isolate, CodeCreateEvent(log_tag, result->abstract_code(), *result,
                                     *script_name));

    if (!script.is_null())
      script->set_compilation_state(Script::COMPILATION_STATE_COMPILED);
  }

  return result;
}

}  // namespace

// ----------------------------------------------------------------------------
// Implementation of Compiler

bool Compiler::Analyze(ParseInfo* info) {
  DCHECK_NOT_NULL(info->literal());
  if (!Rewriter::Rewrite(info)) return false;
  DeclarationScope::Analyze(info, AnalyzeMode::kRegular);
  if (!Renumber(info)) return false;
  DCHECK_NOT_NULL(info->scope());
  return true;
}

bool Compiler::ParseAndAnalyze(ParseInfo* info) {
  if (!Parse(info)) return false;
  if (!Compiler::Analyze(info)) return false;
  DCHECK_NOT_NULL(info->literal());
  DCHECK_NOT_NULL(info->scope());
  return true;
}

bool Compiler::Compile(Handle<JSFunction> function, ClearExceptionFlag flag) {
  if (function->is_compiled()) return true;
  Isolate* isolate = function->GetIsolate();
  DCHECK(AllowCompilation::IsAllowed(isolate));

  // Start a compilation.
  Handle<Code> code;
  if (!GetLazyCode(function).ToHandle(&code)) {
    if (flag == CLEAR_EXCEPTION) {
      isolate->clear_pending_exception();
    }
    return false;
  }

  // Install code on closure.
  function->ReplaceCode(*code);
  JSFunction::EnsureLiterals(function);

  // Check postconditions on success.
  DCHECK(!isolate->has_pending_exception());
  DCHECK(function->shared()->is_compiled());
  DCHECK(function->is_compiled());
  return true;
}

bool Compiler::CompileBaseline(Handle<JSFunction> function) {
  Isolate* isolate = function->GetIsolate();
  DCHECK(AllowCompilation::IsAllowed(isolate));

  // Start a compilation.
  Handle<Code> code;
  if (!GetBaselineCode(function).ToHandle(&code)) {
    // Baseline generation failed, get unoptimized code.
    DCHECK(function->shared()->is_compiled());
    code = handle(function->shared()->code());
    isolate->clear_pending_exception();
  }

  // Install code on closure.
  function->ReplaceCode(*code);
  JSFunction::EnsureLiterals(function);

  // Check postconditions on success.
  DCHECK(!isolate->has_pending_exception());
  DCHECK(function->shared()->is_compiled());
  DCHECK(function->is_compiled());
  return true;
}

bool Compiler::CompileOptimized(Handle<JSFunction> function,
                                ConcurrencyMode mode) {
  if (function->IsOptimized()) return true;
  Isolate* isolate = function->GetIsolate();
  DCHECK(AllowCompilation::IsAllowed(isolate));

  // Start a compilation.
  Handle<Code> code;
  if (!GetOptimizedCode(function, mode).ToHandle(&code)) {
    // Optimization failed, get unoptimized code.
    DCHECK(!isolate->has_pending_exception());
    if (function->shared()->is_compiled()) {
      code = handle(function->shared()->code(), isolate);
    } else if (function->shared()->HasBytecodeArray()) {
      code = isolate->builtins()->InterpreterEntryTrampoline();
      function->shared()->ReplaceCode(*code);
    } else {
      Zone zone(isolate->allocator(), ZONE_NAME);
      ParseInfo parse_info(&zone, handle(function->shared()));
      CompilationInfo info(&parse_info, function);
      if (!GetUnoptimizedCode(&info).ToHandle(&code)) {
        return false;
      }
    }
  }

  // Install code on closure.
  function->ReplaceCode(*code);
  JSFunction::EnsureLiterals(function);

  // Check postconditions on success.
  DCHECK(!isolate->has_pending_exception());
  DCHECK(function->shared()->is_compiled());
  DCHECK(function->is_compiled());
  return true;
}

bool Compiler::CompileDebugCode(Handle<JSFunction> function) {
  Isolate* isolate = function->GetIsolate();
  DCHECK(AllowCompilation::IsAllowed(isolate));

  // Start a compilation.
  Zone zone(isolate->allocator(), ZONE_NAME);
  ParseInfo parse_info(&zone, handle(function->shared()));
  CompilationInfo info(&parse_info, Handle<JSFunction>::null());
  info.MarkAsDebug();
  if (GetUnoptimizedCode(&info).is_null()) {
    isolate->clear_pending_exception();
    return false;
  }

  // Check postconditions on success.
  DCHECK(!isolate->has_pending_exception());
  DCHECK(function->shared()->is_compiled());
  DCHECK(function->shared()->HasDebugCode());
  return true;
}

bool Compiler::CompileDebugCode(Handle<SharedFunctionInfo> shared) {
  Isolate* isolate = shared->GetIsolate();
  DCHECK(AllowCompilation::IsAllowed(isolate));

  // Start a compilation.
  Zone zone(isolate->allocator(), ZONE_NAME);
  ParseInfo parse_info(&zone, shared);
  CompilationInfo info(&parse_info, Handle<JSFunction>::null());
  info.MarkAsDebug();
  if (GetUnoptimizedCode(&info).is_null()) {
    isolate->clear_pending_exception();
    return false;
  }

  // Check postconditions on success.
  DCHECK(!isolate->has_pending_exception());
  DCHECK(shared->is_compiled());
  DCHECK(shared->HasDebugCode());
  return true;
}

MaybeHandle<JSArray> Compiler::CompileForLiveEdit(Handle<Script> script) {
  Isolate* isolate = script->GetIsolate();
  DCHECK(AllowCompilation::IsAllowed(isolate));

  // In order to ensure that live edit function info collection finds the newly
  // generated shared function infos, clear the script's list temporarily
  // and restore it at the end of this method.
  Handle<Object> old_function_infos(script->shared_function_infos(), isolate);
  script->set_shared_function_infos(Smi::kZero);

  // Start a compilation.
  Zone zone(isolate->allocator(), ZONE_NAME);
  ParseInfo parse_info(&zone, script);
  CompilationInfo info(&parse_info, Handle<JSFunction>::null());
  info.MarkAsDebug();

  // TODO(635): support extensions.
  const bool compilation_succeeded = !CompileToplevel(&info).is_null();
  Handle<JSArray> infos;
  if (compilation_succeeded) {
    // Check postconditions on success.
    DCHECK(!isolate->has_pending_exception());
    infos = LiveEditFunctionTracker::Collect(parse_info.literal(), script,
                                             &zone, isolate);
  }

  // Restore the original function info list in order to remain side-effect
  // free as much as possible, since some code expects the old shared function
  // infos to stick around.
  script->set_shared_function_infos(*old_function_infos);

  return infos;
}

bool Compiler::EnsureBytecode(CompilationInfo* info) {
  if (!ShouldUseIgnition(info)) return false;
  if (!info->shared_info()->HasBytecodeArray()) {
    Handle<Code> original_code(info->shared_info()->code());
    if (GetUnoptimizedCode(info).is_null()) return false;
    if (info->shared_info()->HasAsmWasmData()) return false;
    DCHECK(info->shared_info()->is_compiled());
    if (original_code->kind() == Code::FUNCTION) {
      // Generating bytecode will install the {InterpreterEntryTrampoline} as
      // shared code on the function. To avoid an implicit tier down we restore
      // original baseline code in case it existed beforehand.
      info->shared_info()->ReplaceCode(*original_code);
    }
  }
  DCHECK(info->shared_info()->HasBytecodeArray());
  return true;
}

// TODO(turbofan): In the future, unoptimized code with deopt support could
// be generated lazily once deopt is triggered.
bool Compiler::EnsureDeoptimizationSupport(CompilationInfo* info) {
  DCHECK_NOT_NULL(info->literal());
  DCHECK_NOT_NULL(info->scope());
  Handle<SharedFunctionInfo> shared = info->shared_info();
  if (!shared->has_deoptimization_support()) {
    Zone zone(info->isolate()->allocator(), ZONE_NAME);
    CompilationInfo unoptimized(info->parse_info(), info->closure());
    unoptimized.EnableDeoptimizationSupport();

    // TODO(4280): For now we do not switch generators or async functions to
    // baseline code because there might be suspended activations stored in
    // generator objects on the heap. We could eventually go directly to
    // TurboFan in this case.
    if (IsResumableFunction(shared->kind())) return false;

    // TODO(4280): For now we disable switching to baseline code in the presence
    // of interpreter activations of the given function. The reasons is that the
    // underlying bytecode is cleared below. The expensive check for activations
    // only needs to be done when the given function has bytecode, otherwise we
    // can be sure there are no activations. Note that this only applies in case
    // the --ignition-preserve-bytecode flag is not passed.
    if (!FLAG_ignition_preserve_bytecode && shared->HasBytecodeArray()) {
      InterpreterActivationsFinder activations_finder(*shared);
      if (HasInterpreterActivations(info->isolate(), &activations_finder)) {
        return false;
      }
    }

    // When we call PrepareForSerializing below, we will change the shared
    // ParseInfo. Make sure to reset it.
    bool old_will_serialize_value = info->parse_info()->will_serialize();

    // If the current code has reloc info for serialization, also include
    // reloc info for serialization for the new code, so that deopt support
    // can be added without losing IC state.
    if (shared->code()->kind() == Code::FUNCTION &&
        shared->code()->has_reloc_info_for_serialization()) {
      unoptimized.PrepareForSerializing();
    }
    EnsureFeedbackMetadata(&unoptimized);
    if (!FullCodeGenerator::MakeCode(&unoptimized)) return false;

    info->parse_info()->set_will_serialize(old_will_serialize_value);

    // TODO(4280): For now we play it safe and remove the bytecode array when we
    // switch to baseline code. We might consider keeping around the bytecode so
    // that it can be used as the ""source of truth"" eventually. Note that this
    // only applies in case the --ignition-preserve-bytecode flag is not passed.
    if (!FLAG_ignition_preserve_bytecode && shared->HasBytecodeArray()) {
      shared->ClearBytecodeArray();
    }

    // The scope info might not have been set if a lazily compiled
    // function is inlined before being called for the first time.
    if (shared->scope_info() == ScopeInfo::Empty(info->isolate())) {
      InstallSharedScopeInfo(info, shared);
    }

    // Install compilation result on the shared function info
    shared->EnableDeoptimizationSupport(*unoptimized.code());

    // The existing unoptimized code was replaced with the new one.
    RecordFunctionCompilation(CodeEventListener::LAZY_COMPILE_TAG,
                              &unoptimized);
  }
  return true;
}

// static
Compiler::CompilationTier Compiler::NextCompilationTier(JSFunction* function) {
  Handle<SharedFunctionInfo> shared(function->shared(), function->GetIsolate());
  if (shared->code()->is_interpreter_trampoline_builtin()) {
    if (FLAG_turbo_from_bytecode && UseTurboFan(shared)) {
      return OPTIMIZED;
    } else {
      return BASELINE;
    }
  } else {
    return OPTIMIZED;
  }
}

MaybeHandle<JSFunction> Compiler::GetFunctionFromEval(
    Handle<String> source, Handle<SharedFunctionInfo> outer_info,
    Handle<Context> context, LanguageMode language_mode,
    ParseRestriction restriction, int eval_scope_position, int eval_position,
    int line_offset, int column_offset, Handle<Object> script_name,
    ScriptOriginOptions options) {
  Isolate* isolate = source->GetIsolate();
  int source_length = source->length();
  isolate->counters()->total_eval_size()->Increment(source_length);
  isolate->counters()->total_compile_size()->Increment(source_length);

  CompilationCache* compilation_cache = isolate->compilation_cache();
  MaybeHandle<SharedFunctionInfo> maybe_shared_info =
      compilation_cache->LookupEval(source, outer_info, context, language_mode,
                                    eval_scope_position);
  Handle<SharedFunctionInfo> shared_info;

  Handle<Script> script;
  if (!maybe_shared_info.ToHandle(&shared_info)) {
    script = isolate->factory()->NewScript(source);
    if (!script_name.is_null()) {
      script->set_name(*script_name);
      script->set_line_offset(line_offset);
      script->set_column_offset(column_offset);
    }
    script->set_origin_options(options);
    script->set_compilation_type(Script::COMPILATION_TYPE_EVAL);
    Script::SetEvalOrigin(script, outer_info, eval_position);

    Zone zone(isolate->allocator(), ZONE_NAME);
    ParseInfo parse_info(&zone, script);
    CompilationInfo info(&parse_info, Handle<JSFunction>::null());
    parse_info.set_eval();
    parse_info.set_language_mode(language_mode);
    parse_info.set_parse_restriction(restriction);
    if (!context->IsNativeContext()) {
      parse_info.set_outer_scope_info(handle(context->scope_info()));
    }

    shared_info = CompileToplevel(&info);

    if (shared_info.is_null()) {
      return MaybeHandle<JSFunction>();
    } else {
      // If caller is strict mode, the result must be in strict mode as well.
      DCHECK(is_sloppy(language_mode) ||
             is_strict(shared_info->language_mode()));
      compilation_cache->PutEval(source, outer_info, context, shared_info,
                                 eval_scope_position);
    }
  }

  Handle<JSFunction> result =
      isolate->factory()->NewFunctionFromSharedFunctionInfo(
          shared_info, context, NOT_TENURED);

  // OnAfterCompile has to be called after we create the JSFunction, which we
  // may require to recompile the eval for debugging, if we find a function
  // that contains break points in the eval script.
  isolate->debug()->OnAfterCompile(script);

  return result;
}

namespace {

bool CodeGenerationFromStringsAllowed(Isolate* isolate,
                                      Handle<Context> context) {
  DCHECK(context->allow_code_gen_from_strings()->IsFalse(isolate));
  // Check with callback if set.
  AllowCodeGenerationFromStringsCallback callback =
      isolate->allow_code_gen_callback();
  if (callback == NULL) {
    // No callback set and code generation disallowed.
    return false;
  } else {
    // Callback set. Let it decide if code generation is allowed.
    VMState<EXTERNAL> state(isolate);
    return callback(v8::Utils::ToLocal(context));
  }
}

}  // namespace

MaybeHandle<JSFunction> Compiler::GetFunctionFromString(
    Handle<Context> context, Handle<String> source,
    ParseRestriction restriction) {
  Isolate* const isolate = context->GetIsolate();
  Handle<Context> native_context(context->native_context(), isolate);

  // Check if native context allows code generation from
  // strings. Throw an exception if it doesn't.
  if (native_context->allow_code_gen_from_strings()->IsFalse(isolate) &&
      !CodeGenerationFromStringsAllowed(isolate, native_context)) {
    Handle<Object> error_message =
        native_context->ErrorMessageForCodeGenerationFromStrings();
    THROW_NEW_ERROR(isolate, NewEvalError(MessageTemplate::kCodeGenFromStrings,
                                          error_message),
                    JSFunction);
  }

  // Compile source string in the native context.
  int eval_scope_position = 0;
  int eval_position = kNoSourcePosition;
  Handle<SharedFunctionInfo> outer_info(native_context->closure()->shared());
  return Compiler::GetFunctionFromEval(source, outer_info, native_context,
                                       SLOPPY, restriction, eval_scope_position,
                                       eval_position);
}

Handle<SharedFunctionInfo> Compiler::GetSharedFunctionInfoForScript(
    Handle<String> source, Handle<Object> script_name, int line_offset,
    int column_offset, ScriptOriginOptions resource_options,
    Handle<Object> source_map_url, Handle<Context> context,
    v8::Extension* extension, ScriptData** cached_data,
    ScriptCompiler::CompileOptions compile_options, NativesFlag natives,
    bool is_module) {
  Isolate* isolate = source->GetIsolate();
  if (compile_options == ScriptCompiler::kNoCompileOptions) {
    cached_data = NULL;
  } else if (compile_options == ScriptCompiler::kProduceParserCache ||
             compile_options == ScriptCompiler::kProduceCodeCache) {
    DCHECK(cached_data && !*cached_data);
    DCHECK(extension == NULL);
    DCHECK(!isolate->debug()->is_loaded());
  } else {
    DCHECK(compile_options == ScriptCompiler::kConsumeParserCache ||
           compile_options == ScriptCompiler::kConsumeCodeCache);
    DCHECK(cached_data && *cached_data);
    DCHECK(extension == NULL);
  }
  int source_length = source->length();
  isolate->counters()->total_load_size()->Increment(source_length);
  isolate->counters()->total_compile_size()->Increment(source_length);

  LanguageMode language_mode = construct_language_mode(FLAG_use_strict);
  CompilationCache* compilation_cache = isolate->compilation_cache();

  // Do a lookup in the compilation cache but not for extensions.
  MaybeHandle<SharedFunctionInfo> maybe_result;
  Handle<SharedFunctionInfo> result;
  if (extension == NULL) {
    // First check per-isolate compilation cache.
    maybe_result = compilation_cache->LookupScript(
        source, script_name, line_offset, column_offset, resource_options,
        context, language_mode);
    if (maybe_result.is_null() && FLAG_serialize_toplevel &&
        compile_options == ScriptCompiler::kConsumeCodeCache &&
        !isolate->debug()->is_loaded()) {
      // Then check cached code provided by embedder.
      HistogramTimerScope timer(isolate->counters()->compile_deserialize());
      RuntimeCallTimerScope runtimeTimer(isolate,
                                         &RuntimeCallStats::CompileDeserialize);
      TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT(""v8.compile""),
                   ""V8.CompileDeserialize"");
      Handle<SharedFunctionInfo> result;
      if (CodeSerializer::Deserialize(isolate, *cached_data, source)
              .ToHandle(&result)) {
        // Promote to per-isolate compilation cache.
        compilation_cache->PutScript(source, context, language_mode, result);
        return result;
      }
      // Deserializer failed. Fall through to compile.
    }
  }

  base::ElapsedTimer timer;
  if (FLAG_profile_deserialization && FLAG_serialize_toplevel &&
      compile_options == ScriptCompiler::kProduceCodeCache) {
    timer.Start();
  }

  if (!maybe_result.ToHandle(&result) ||
      (FLAG_serialize_toplevel &&
       compile_options == ScriptCompiler::kProduceCodeCache)) {
    // No cache entry found, or embedder wants a code cache. Compile the script.

    // Create a script object describing the script to be compiled.
    Handle<Script> script = isolate->factory()->NewScript(source);
    if (natives == NATIVES_CODE) {
      script->set_type(Script::TYPE_NATIVE);
      script->set_hide_source(true);
    } else if (natives == EXTENSION_CODE) {
      script->set_type(Script::TYPE_EXTENSION);
      script->set_hide_source(true);
    }
    if (!script_name.is_null()) {
      script->set_name(*script_name);
      script->set_line_offset(line_offset);
      script->set_column_offset(column_offset);
    }
    script->set_origin_options(resource_options);
    if (!source_map_url.is_null()) {
      script->set_source_mapping_url(*source_map_url);
    }

    // Compile the function and add it to the cache.
    Zone zone(isolate->allocator(), ZONE_NAME);
    ParseInfo parse_info(&zone, script);
    CompilationInfo info(&parse_info, Handle<JSFunction>::null());
    if (is_module) parse_info.set_module();
    if (compile_options != ScriptCompiler::kNoCompileOptions) {
      parse_info.set_cached_data(cached_data);
    }
    parse_info.set_compile_options(compile_options);
    parse_info.set_extension(extension);
    if (!context->IsNativeContext()) {
      parse_info.set_outer_scope_info(handle(context->scope_info()));
    }
    if (FLAG_serialize_toplevel &&
        compile_options == ScriptCompiler::kProduceCodeCache) {
      info.PrepareForSerializing();
    }

    parse_info.set_language_mode(
        static_cast<LanguageMode>(parse_info.language_mode() | language_mode));
    result = CompileToplevel(&info);
    if (extension == NULL && !result.is_null()) {
      compilation_cache->PutScript(source, context, language_mode, result);
      if (FLAG_serialize_toplevel &&
          compile_options == ScriptCompiler::kProduceCodeCache) {
        HistogramTimerScope histogram_timer(
            isolate->counters()->compile_serialize());
        RuntimeCallTimerScope runtimeTimer(isolate,
                                           &RuntimeCallStats::CompileSerialize);
        TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT(""v8.compile""),
                     ""V8.CompileSerialize"");
        *cached_data = CodeSerializer::Serialize(isolate, result, source);
        if (FLAG_profile_deserialization) {
          PrintF(""[Compiling and serializing took %0.3f ms]\\n"",
                 timer.Elapsed().InMillisecondsF());
        }
      }
    }

    if (result.is_null()) {
      isolate->ReportPendingMessages();
    } else {
      isolate->debug()->OnAfterCompile(script);
    }
  } else if (result->ic_age() != isolate->heap()->global_ic_age()) {
    result->ResetForNewContext(isolate->heap()->global_ic_age());
  }
  return result;
}

Handle<SharedFunctionInfo> Compiler::GetSharedFunctionInfoForStreamedScript(
    Handle<Script> script, ParseInfo* parse_info, int source_length) {
  Isolate* isolate = script->GetIsolate();
  // TODO(titzer): increment the counters in caller.
  isolate->counters()->total_load_size()->Increment(source_length);
  isolate->counters()->total_compile_size()->Increment(source_length);

  LanguageMode language_mode = construct_language_mode(FLAG_use_strict);
  parse_info->set_language_mode(
      static_cast<LanguageMode>(parse_info->language_mode() | language_mode));

  CompilationInfo compile_info(parse_info, Handle<JSFunction>::null());

  // The source was parsed lazily, so compiling for debugging is not possible.
  DCHECK(!compile_info.is_debug());

  Handle<SharedFunctionInfo> result = CompileToplevel(&compile_info);
  if (!result.is_null()) isolate->debug()->OnAfterCompile(script);
  return result;
}


Handle<SharedFunctionInfo> Compiler::GetSharedFunctionInfo(
    FunctionLiteral* literal, Handle<Script> script,
    CompilationInfo* outer_info) {
  // Precondition: code has been parsed and scopes have been analyzed.
  Isolate* isolate = outer_info->isolate();
  MaybeHandle<SharedFunctionInfo> maybe_existing;

  // Find any previously allocated shared function info for the given literal.
  if (outer_info->shared_info()->never_compiled()) {
    // On the first compile, there are no existing shared function info for
    // inner functions yet, so do not try to find them. All bets are off for
    // live edit though.
    SLOW_DCHECK(script->FindSharedFunctionInfo(literal).is_null() ||
                isolate->debug()->live_edit_enabled());
  } else {
    maybe_existing = script->FindSharedFunctionInfo(literal);
  }

  // We found an existing shared function info. If it has any sort of code
  // attached, don't worry about compiling and simply return it. Otherwise,
  // continue to decide whether to eagerly compile.
  // Note that we also carry on if we are compiling eager to obtain code for
  // debugging, unless we already have code with debug break slots.
  Handle<SharedFunctionInfo> existing;
  if (maybe_existing.ToHandle(&existing)) {
    DCHECK(!existing->is_toplevel());
    if (existing->HasBaselineCode() || existing->HasBytecodeArray()) {
      if (!outer_info->is_debug() || existing->HasDebugCode()) {
        return existing;
      }
    }
  }

  // Allocate a shared function info object.
  Handle<SharedFunctionInfo> result;
  if (!maybe_existing.ToHandle(&result)) {
    result = NewSharedFunctionInfoForLiteral(isolate, literal, script);
    result->set_is_toplevel(false);

    // If the outer function has been compiled before, we cannot be sure that
    // shared function info for this function literal has been created for the
    // first time. It may have already been compiled previously.
    result->set_never_compiled(outer_info->shared_info()->never_compiled());
  }

  Zone zone(isolate->allocator(), ZONE_NAME);
  ParseInfo parse_info(&zone, script);
  CompilationInfo info(&parse_info, Handle<JSFunction>::null());
  parse_info.set_literal(literal);
  parse_info.set_shared_info(result);
  parse_info.set_language_mode(literal->scope()->language_mode());
  if (outer_info->will_serialize()) info.PrepareForSerializing();
  if (outer_info->is_debug()) info.MarkAsDebug();

  // Generate code
  TimerEventScope<TimerEventCompileCode> timer(isolate);
  RuntimeCallTimerScope runtimeTimer(isolate, &RuntimeCallStats::CompileCode);
  TRACE_EVENT0(TRACE_DISABLED_BY_DEFAULT(""v8.compile""), ""V8.CompileCode"");

  if (!literal->ShouldEagerCompile()) {
    info.SetCode(isolate->builtins()->CompileLazy());
    Scope* outer_scope = literal->scope()->GetOuterScopeWithContext();
    if (outer_scope) {
      result->set_outer_scope_info(*outer_scope->scope_info());
    }
  } else if (Renumber(info.parse_info()) && GenerateUnoptimizedCode(&info)) {
    // Code generation will ensure that the feedback vector is present and
    // appropriately sized.
    DCHECK(!info.code().is_null());
    if (literal->should_be_used_once_hint()) {
      info.code()->MarkToBeExecutedOnce(isolate);
    }
  } else {
    return Handle<SharedFunctionInfo>::null();
  }

  if (maybe_existing.is_null()) {
    RecordFunctionCompilation(CodeEventListener::FUNCTION_TAG, &info);
  }

  return result;
}

Handle<SharedFunctionInfo> Compiler::GetSharedFunctionInfoForNative(
    v8::Extension* extension, Handle<String> name) {
  Isolate* isolate = name->GetIsolate();
  v8::Isolate* v8_isolate = reinterpret_cast<v8::Isolate*>(isolate);

  // Compute the function template for the native function.
  v8::Local<v8::FunctionTemplate> fun_template =
      extension->GetNativeFunctionTemplate(v8_isolate,
                                           v8::Utils::ToLocal(name));
  DCHECK(!fun_template.IsEmpty());

  // Instantiate the function and create a shared function info from it.
  Handle<JSFunction> fun = Handle<JSFunction>::cast(Utils::OpenHandle(
      *fun_template->GetFunction(v8_isolate->GetCurrentContext())
           .ToLocalChecked()));
  Handle<Code> code = Handle<Code>(fun->shared()->code());
  Handle<Code> construct_stub = Handle<Code>(fun->shared()->construct_stub());
  Handle<SharedFunctionInfo> shared = isolate->factory()->NewSharedFunctionInfo(
      name, fun->shared()->num_literals(), FunctionKind::kNormalFunction, code,
      Handle<ScopeInfo>(fun->shared()->scope_info()));
  shared->set_outer_scope_info(fun->shared()->outer_scope_info());
  shared->SetConstructStub(*construct_stub);
  shared->set_feedback_metadata(fun->shared()->feedback_metadata());

  // Copy the function data to the shared function info.
  shared->set_function_data(fun->shared()->function_data());
  int parameters = fun->shared()->internal_formal_parameter_count();
  shared->set_internal_formal_parameter_count(parameters);

  return shared;
}

MaybeHandle<Code> Compiler::GetOptimizedCodeForOSR(Handle<JSFunction> function,
                                                   BailoutId osr_ast_id,
                                                   JavaScriptFrame* osr_frame) {
  DCHECK(!osr_ast_id.IsNone());
  DCHECK_NOT_NULL(osr_frame);
  return GetOptimizedCode(function, NOT_CONCURRENT, osr_ast_id, osr_frame);
}

CompilationJob* Compiler::PrepareUnoptimizedCompilationJob(
    CompilationInfo* info) {
  VMState<COMPILER> state(info->isolate());
  std::unique_ptr<CompilationJob> job(GetUnoptimizedCompilationJob(info));
  if (job->PrepareJob() != CompilationJob::SUCCEEDED) {
    return nullptr;
  }
  return job.release();
}

bool Compiler::FinalizeCompilationJob(CompilationJob* raw_job) {
  // Take ownership of compilation job.  Deleting job also tears down the zone.
  std::unique_ptr<CompilationJob> job(raw_job);

  VMState<COMPILER> state(job->info()->isolate());
  if (job->info()->IsOptimizing()) {
    return FinalizeOptimizedCompilationJob(job.get()) ==
           CompilationJob::SUCCEEDED;
  } else {
    if (FinalizeUnoptimizedCompilationJob(job.get()) ==
        CompilationJob::SUCCEEDED) {
      RecordFunctionCompilation(CodeEventListener::LAZY_COMPILE_TAG,
                                job->info());
      return true;
    }
    return false;
  }
}

void Compiler::PostInstantiation(Handle<JSFunction> function,
                                 PretenureFlag pretenure) {
  Handle<SharedFunctionInfo> shared(function->shared());

  if (FLAG_always_opt && shared->allows_lazy_compilation()) {
    function->MarkForOptimization();
  }

  CodeAndLiterals cached = shared->SearchOptimizedCodeMap(
      function->context()->native_context(), BailoutId::None());
  if (cached.code != nullptr) {
    // Caching of optimized code enabled and optimized code found.
    DCHECK(!cached.code->marked_for_deoptimization());
    DCHECK(function->shared()->is_compiled());
    function->ReplaceCode(cached.code);
  }

  if (cached.literals != nullptr) {
    DCHECK(shared->is_compiled());
    function->set_literals(cached.literals);
  } else if (shared->is_compiled()) {
    // TODO(mvstanton): pass pretenure flag to EnsureLiterals.
    JSFunction::EnsureLiterals(function);
  }
}

}  // namespace internal
}  // namespace v8
",16276,True,3219.892604675167,median
"= [[BlockManager]] BlockManager -- Key-Value Store of Blocks of Data

`BlockManager` is a key-value store of blocks of data (*block storage*) identified by a block ID.

`BlockManager` runs on every node in a Spark application, i.e. the <<spark-driver.adoc#, driver>> and <<spark-Executor.adoc#, executors>>.

`BlockManager` is a <<spark-BlockDataManager.adoc#, BlockDataManager>> and manages the storage for blocks that with cached RDD partitions, intermediate shuffle outputs, broadcasts, etc.

`BlockManager` is a local cache.

`BlockManager` provides interface for uploading and fetching blocks both locally and remotely using various stores, i.e. <<stores, memory, disk, and off-heap>>.

`BlockManager` is <<creating-instance, created>> exclusively when `SparkEnv` is <<spark-SparkEnv.adoc#create-BlockManager, created>> (for the driver and executors). `BlockManager` gets a <<diskBlockManager, DiskBlockManager>>, a <<blockInfoManager, BlockInfoManager>>, a <<memoryStore, MemoryStore>> and a <<diskStore, DiskStore>> (and wires them up together).

[[futureExecutionContext]]
`BlockManager` uses a Scala https://www.scala-lang.org/api/current/scala/concurrent/ExecutionContextExecutorService.html[ExecutionContextExecutorService] to execute *FIXME* asynchronously (on a thread pool with *block-manager-future* prefix and maximum of 128 threads).

`BlockManager` is available as <<spark-SparkEnv.adoc#blockManager, SparkEnv.blockManager>> regardless of the node (i.e. the driver or executors).

[source, scala]
----
// BlockManager is a private[spark] class
// so the following has to be under org.apache.spark package
// e.g. package org.apache.spark
import org.apache.spark.storage.BlockManager
val bm: BlockManager = SparkEnv.get.blockManager
----

`BlockManager` is a link:spark-BlockEvictionHandler.adoc[BlockEvictionHandler] that can <<dropFromMemory, drop a block from memory and store it on a disk>> if required.

*Cached blocks* are blocks with non-zero sum of memory and disk sizes.

TIP: Use link:spark-webui.adoc[Web UI], esp. link:spark-webui-storage.adoc[Storage] and link:spark-webui-executors.adoc[Executors] tabs, to monitor the memory used.

TIP: Use link:spark-submit.adoc[spark-submit]'s command-line options, i.e. link:spark-submit.adoc#driver-memory[--driver-memory] for the driver and link:spark-submit.adoc#executor-memory[--executor-memory] for executors or their equivalents as Spark properties, i.e. link:spark-submit.adoc#spark.executor.memory[spark.executor.memory] and link:spark-submit.adoc#spark_driver_memory[spark.driver.memory], to control the memory for storage memory.

A <<creating-instance, `BlockManager` is created>> when a link:spark-SparkEnv.adoc#create[Spark application starts] and must be <<initialize, initialized>> before it is fully operable.

When <<externalShuffleServiceEnabled, External Shuffle Service is enabled>>, `BlockManager` uses link:spark-ShuffleClient-ExternalShuffleClient.adoc[ExternalShuffleClient] to read other executors' shuffle files.

[[metrics]]
`BlockManager` uses link:spark-BlockManager-BlockManagerSource.adoc[BlockManagerSource] to report metrics under the name *BlockManager*.

[[internal-properties]]
.BlockManager's Internal Properties
[cols=""1,1,2"",options=""header"",width=""100%""]
|===
| Name
| Initial Value
| Description

| `blockInfoManager`
| FIXME
| [[blockInfoManager]] link:spark-BlockInfoManager.adoc[BlockInfoManager] for...FIXME

| `diskStore`
| FIXME
| [[diskStore]] link:spark-DiskStore.adoc[DiskStore] for...FIXME

| `diskBlockManager`
| FIXME
| [[diskBlockManager]] link:spark-DiskBlockManager.adoc[DiskBlockManager] for...FIXME

| `maxMemory`
| Total available link:spark-MemoryManager.adoc#maxOnHeapStorageMemory[on-heap] and link:spark-MemoryManager.adoc#maxOffHeapStorageMemory[off-heap] memory for storage (in bytes)
| [[maxMemory]] Total maximum value that `BlockManager` can ever possibly use (that depends on <<memoryManager, MemoryManager>> and may vary over time).

| `maxOffHeapMemory`
|
| [[maxOffHeapMemory]]

| `maxOnHeapMemory`
|
| [[maxOnHeapMemory]]

| `memoryStore`
|
| [[memoryStore]] link:spark-MemoryStore.adoc[MemoryStore] (with the <<blockInfoManager, BlockInfoManager>>, the <<serializerManager, SerializerManager>>, <<memoryManager, MemoryManager>> and this `BlockManager` as the link:spark-BlockEvictionHandler.adoc[BlockEvictionHandler])
|===

[[logging]]
[TIP]
====
Enable `INFO`, `DEBUG` or `TRACE` logging level for `org.apache.spark.storage.BlockManager` logger to see what happens inside.

Add the following line to `conf/log4j.properties`:

```
log4j.logger.org.apache.spark.storage.BlockManager=TRACE
```

Refer to link:spark-logging.adoc[Logging].
====

[TIP]
====
You may want to shut off WARN messages being printed out about the current state of blocks using the following line to cut the noise:

```
log4j.logger.org.apache.spark.storage.BlockManager=OFF
```
====

== [[getLocations]] `getLocations` Method

CAUTION: FIXME

== [[blockIdsToHosts]] `blockIdsToHosts` Method

CAUTION: FIXME

== [[getLocationBlockIds]] `getLocationBlockIds` Method

CAUTION: FIXME

== [[getPeers]] `getPeers` Method

CAUTION: FIXME

== [[releaseAllLocksForTask]] `releaseAllLocksForTask` Method

CAUTION: FIXME

== [[stop]] Stopping BlockManager -- `stop` Method

[source, scala]
----
stop(): Unit
----

`stop`...FIXME

NOTE: `stop` is used exclusively when `SparkEnv` is requested to link:spark-SparkEnv.adoc#stop[stop].

== [[getMatchingBlockIds]] Getting IDs of Existing Blocks (For a Given Filter) -- `getMatchingBlockIds` Method

[source, scala]
----
getMatchingBlockIds(filter: BlockId => Boolean): Seq[BlockId]
----

`getMatchingBlockIds`...FIXME

NOTE: `getMatchingBlockIds` is used exclusively when `BlockManagerSlaveEndpoint` is requested to link:spark-blockmanager-BlockManagerSlaveEndpoint.adoc#GetMatchingBlockIds[handle a GetMatchingBlockIds message].

== [[getLocalValues]] `getLocalValues` Method

[source, scala]
----
getLocalValues(blockId: BlockId): Option[BlockResult]
----

`getLocalValues`...FIXME

Internally, when `getLocalValues` is executed, you should see the following DEBUG message in the logs:

```
DEBUG BlockManager: Getting local block [blockId]
```

`getLocalValues` link:spark-BlockInfoManager.adoc#lockForReading[obtains a read lock for `blockId`].

When no `blockId` block was found, you should see the following DEBUG message in the logs and `getLocalValues` returns ""nothing"" (i.e. `NONE`).

```
DEBUG Block [blockId] was not found
```

When the `blockId` block was found, you should see the following DEBUG message in the logs:

```
DEBUG Level for block [blockId] is [level]
```

If `blockId` block has memory level and link:spark-MemoryStore.adoc#contains[is registered in `MemoryStore`], `getLocalValues` returns a <<BlockResult, BlockResult>> as `Memory` read method and with a `CompletionIterator` for an interator:

1. link:spark-MemoryStore.adoc#getValues[Values iterator from `MemoryStore` for `blockId`] for ""deserialized"" persistence levels.
2. Iterator from link:spark-SerializerManager.adoc#dataDeserializeStream[`SerializerManager` after the data stream has been deserialized] for the `blockId` block and link:spark-MemoryStore.adoc#getBytes[the bytes for `blockId` block] for ""serialized"" persistence levels.

NOTE: `getLocalValues` is used when link:spark-TorrentBroadcast.adoc#readBroadcastBlock[`TorrentBroadcast` reads the blocks of a broadcast variable and stores them in a local `BlockManager`].

CAUTION: FIXME

== [[getRemoteValues]] `getRemoteValues` Internal Method

[source, scala]
----
getRemoteValues[T: ClassTag](blockId: BlockId): Option[BlockResult]
----

`getRemoteValues`...FIXME

== [[get]] Retrieving Block from Local or Remote Block Managers -- `get` Method

[source, scala]
----
get[T: ClassTag](blockId: BlockId): Option[BlockResult]
----

`get` attempts to get the `blockId` block from a local block manager first before requesting it from remote block managers.

Internally, `get` tries to <<getLocalValues, get the block from the local BlockManager>>. If the block was found, you should see the following INFO message in the logs and `get` returns the local <<BlockResult, BlockResult>>.

```
INFO Found block [blockId] locally
```

If however the block was not found locally, `get` tries to <<getRemoteValues, get the block from remote block managers>>. If retrieved from a remote block manager, you should see the following INFO message in the logs and `get` returns the remote <<BlockResult, BlockResult>>.

```
INFO Found block [blockId] remotely
```

In the end, `get` returns ""nothing"" (i.e. `NONE`) when the `blockId` block was not found either in the local `BlockManager` or any remote `BlockManager`.

[NOTE]
====
`get` is used when:

* `BlockManager` is requested to <<getOrElseUpdate, getOrElseUpdate>> and <<getSingle, getSingle>>

* `BlockRDD` is requested to link:spark-streaming-BlockRDD.adoc#compute[compute a partition]

* Spark Streaming's `WriteAheadLogBackedBlockRDD` is requested to `compute` a partition
====

== [[getLocalBytes]] Retrieving Block Data from Local Block Manager (As Serialized Bytes) -- `getLocalBytes` Method

CAUTION: FIXME

== [[getBlockData]] Retrieving Block Data -- `getBlockData` Method

[source, scala]
----
getBlockData(blockId: BlockId): ManagedBuffer
----

NOTE: `getBlockData` is part of the <<spark-BlockDataManager.adoc#getBlockData, BlockDataManager Contract>> to...FIXME.

`getBlockData`...FIXME

NOTE: `getBlockData` is used when...FIXME

== [[removeBlockInternal]] `removeBlockInternal` Method

CAUTION: FIXME

== [[externalShuffleServiceEnabled]] Is External Shuffle Service Enabled? -- `externalShuffleServiceEnabled` Flag

When the link:spark-ExternalShuffleService.adoc[External Shuffle Service] is enabled for a Spark application, `BlockManager` uses link:spark-ShuffleClient-ExternalShuffleClient.adoc[ExternalShuffleClient] to read other executors' shuffle files.

CAUTION: FIXME How is `shuffleClient` used?

== [[stores]] Stores

A *Store* is the place where blocks are held.

There are the following possible stores:

* link:spark-MemoryStore.adoc[MemoryStore] for memory storage level.
* link:spark-DiskStore.adoc[DiskStore] for disk storage level.
* `ExternalBlockStore` for OFF_HEAP storage level.

== [[putBlockData]] Storing Block Data Locally -- `putBlockData` Method

[source, scala]
----
putBlockData(
  blockId: BlockId,
  data: ManagedBuffer,
  level: StorageLevel,
  classTag: ClassTag[_]): Boolean
----

`putBlockData` simply <<putBytes, stores `blockId` locally>> (given the given storage `level`).

NOTE: `putBlockData` is part of the link:spark-BlockDataManager.adoc#putBlockData[BlockDataManager Contract].

Internally, `putBlockData` wraps `ChunkedByteBuffer` around `data` buffer's NIO `ByteBuffer` and calls <<putBytes, putBytes>>.

== [[putBytes]] Storing Block Bytes Locally -- `putBytes` Method

[source, scala]
----
putBytes(
  blockId: BlockId,
  bytes: ChunkedByteBuffer,
  level: StorageLevel,
  tellMaster: Boolean = true): Boolean
----

`putBytes` makes sure that the `bytes` are not `null` and <<doPutBytes, doPutBytes>>.

[NOTE]
====
`putBytes` is used when:

* `BlockManager` is requested to <<putBlockData, puts a block data locally>>

* `TaskRunner` is requested to link:spark-Executor-TaskRunner.adoc#run-result-sent-via-blockmanager[run] (and the result size is above link:spark-Executor.adoc#maxDirectResultSize[maxDirectResultSize])

* `TorrentBroadcast` is requested to link:spark-TorrentBroadcast.adoc#writeBlocks[writeBlocks] and link:spark-TorrentBroadcast.adoc#readBlocks[readBlocks]

* Spark Streaming's `WriteAheadLogBackedBlockRDD` is requested to `compute`

* Spark Streaming's `BlockManagerBasedBlockHandler` is requested to `storeBlock`

* Spark Streaming's `WriteAheadLogBasedBlockHandler` is requested to `storeBlock`
====

=== [[doPutBytes]] `doPutBytes` Internal Method

[source, scala]
----
def doPutBytes[T](
  blockId: BlockId,
  bytes: ChunkedByteBuffer,
  level: StorageLevel,
  classTag: ClassTag[T],
  tellMaster: Boolean = true,
  keepReadLock: Boolean = false): Boolean
----

`doPutBytes` calls the internal helper <<doPut, doPut>> with a function that accepts a `BlockInfo` and does the uploading.

Inside the function, if the link:spark-rdd-StorageLevel.adoc[storage `level`]'s replication is greater than 1, it immediately starts <<replicate, replication>> of the `blockId` block on a separate thread (from `futureExecutionContext` thread pool). The replication uses the input `bytes` and `level` storage level.

For a memory storage level, the function checks whether the storage `level` is deserialized or not. For a deserialized storage `level`, ``BlockManager``'s link:spark-SerializerManager.adoc#dataDeserializeStream[`SerializerManager` deserializes `bytes` into an iterator of values] that link:spark-MemoryStore.adoc#putIteratorAsValues[`MemoryStore` stores]. If however the storage `level` is not deserialized, the function requests link:spark-MemoryStore.adoc#putBytes[`MemoryStore` to store the bytes]

If the put did not succeed and the storage level is to use disk, you should see the following WARN message in the logs:

```
WARN BlockManager: Persisting block [blockId] to disk instead.
```

And link:spark-DiskStore.adoc#putBytes[`DiskStore` stores the bytes].

NOTE: link:spark-DiskStore.adoc[DiskStore] is requested to store the bytes of a block with memory and disk storage level only when link:spark-MemoryStore.adoc[MemoryStore] has failed.

If the storage level is to use disk only, link:spark-DiskStore.adoc#putBytes[`DiskStore` stores the bytes].

`doPutBytes` requests <<getCurrentBlockStatus, current block status>> and if the block was successfully stored, and the driver should know about it (`tellMaster`), the function <<reportBlockStatus, reports the current storage status of the block to the driver>>. The link:spark-executor-TaskMetrics.adoc#incUpdatedBlockStatuses[current `TaskContext` metrics are updated with the updated block status] (only when executed inside a task where `TaskContext` is available).

You should see the following DEBUG message in the logs:

```
DEBUG BlockManager: Put block [blockId] locally took [time] ms
```

The function waits till the earlier asynchronous replication finishes for a block with replication level greater than `1`.

The final result of `doPutBytes` is the result of storing the block successful or not (as computed earlier).

NOTE: `doPutBytes` is used exclusively when `BlockManager` is requested to <<putBytes, putBytes>>.

== [[maybeCacheDiskValuesInMemory]] `maybeCacheDiskValuesInMemory` Method

CAUTION: FIXME

== [[doPut]] `doPut` Internal Method

[source, scala]
----
doPut[T](
  blockId: BlockId,
  level: StorageLevel,
  classTag: ClassTag[_],
  tellMaster: Boolean,
  keepReadLock: Boolean)(putBody: BlockInfo => Option[T]): Option[T]
----

`doPut` is an internal helper method for <<doPutBytes, doPutBytes>> and <<doPutIterator, doPutIterator>>.

`doPut` executes the input `putBody` function with a link:spark-BlockInfo.adoc[BlockInfo] being a new `BlockInfo` object (with `level` storage level) that link:spark-BlockInfoManager.adoc#lockNewBlockForWriting[`BlockInfoManager` managed to create a write lock for].

If the block has already been created (and link:spark-BlockInfoManager.adoc#lockNewBlockForWriting[`BlockInfoManager` did not manage to create a write lock for]), the following WARN message is printed out to the logs:

```
WARN Block [blockId] already exists on this machine; not re-adding it
```

`doPut` <<releaseLock, releases the read lock for the block>> when `keepReadLock` flag is disabled and returns `None` immediately.

If however the write lock has been given, `doPut` executes `putBody`.

If the result of `putBody` is `None` the block is considered saved successfully.

For successful save and `keepReadLock` enabled, link:spark-BlockInfoManager.adoc#downgradeLock[`BlockInfoManager` is requested to downgrade an exclusive write lock for `blockId` to a shared read lock].

For successful save and `keepReadLock` disabled, link:spark-BlockInfoManager.adoc#unlock[`BlockInfoManager` is requested to release lock on `blockId`].

For unsuccessful save, <<removeBlockInternal, the block is removed from memory and disk stores>> and the following WARN message is printed out to the logs:

```
WARN Putting block [blockId] failed
```

Ultimately, the following DEBUG message is printed out to the logs:

```
DEBUG Putting block [blockId] [withOrWithout] replication took [usedTime] ms
```

== [[removeBlock]] Removing Block From Memory and Disk -- `removeBlock` Method

[source, scala]
----
removeBlock(blockId: BlockId, tellMaster: Boolean = true): Unit
----

`removeBlock` removes the `blockId` block from the link:spark-MemoryStore.adoc[MemoryStore] and link:spark-DiskStore.adoc[DiskStore].

When executed, it prints out the following DEBUG message to the logs:

```
DEBUG Removing block [blockId]
```

It requests link:spark-BlockInfoManager.adoc[BlockInfoManager] for lock for writing for the `blockId` block. If it receives none, it prints out the following WARN message to the logs and quits.

```
WARN Asked to remove block [blockId], which does not exist
```

Otherwise, with a write lock for the block, the block is removed from link:spark-MemoryStore.adoc[MemoryStore] and link:spark-DiskStore.adoc[DiskStore] (see link:spark-MemoryStore.adoc#remove[Removing Block in `MemoryStore`] and link:spark-DiskStore.adoc#remove[Removing Block in `DiskStore`]).

If both removals fail, it prints out the following WARN message:

```
WARN Block [blockId] could not be removed as it was not found in either the disk, memory, or external block store
```

The block is removed from link:spark-BlockInfoManager.adoc[BlockInfoManager].

It then <<getCurrentBlockStatus, calculates the current block status>> that is used to <<reportBlockStatus, report the block status to the driver>> (if the input `tellMaster` and the info's `tellMaster` are both enabled, i.e. `true`) and the link:spark-executor-TaskMetrics.adoc#incUpdatedBlockStatuses[current TaskContext metrics are updated with the change].

NOTE: It is used to <<removeRdd, remove RDDs>> and <<removeBroadcast, broadcast>> as well as in link:spark-blockmanager-BlockManagerSlaveEndpoint.adoc#RemoveBlock[`BlockManagerSlaveEndpoint` while handling `RemoveBlock` messages].

== [[removeRdd]] Removing RDD Blocks -- `removeRdd` Method

[source, scala]
----
removeRdd(rddId: Int): Int
----

`removeRdd` removes all the blocks that belong to the `rddId` RDD.

It prints out the following INFO message to the logs:

```
INFO Removing RDD [rddId]
```

It then requests RDD blocks from link:spark-BlockInfoManager.adoc[BlockInfoManager] and <<removeBlock, removes them (from memory and disk)>> (without informing the driver).

The number of blocks removed is the final result.

NOTE: It is used by link:spark-blockmanager-BlockManagerSlaveEndpoint.adoc#RemoveRdd[`BlockManagerSlaveEndpoint` while handling `RemoveRdd` messages].

== [[removeBroadcast]] Removing All Blocks of Broadcast Variable -- `removeBroadcast` Method

[source, scala]
----
removeBroadcast(broadcastId: Long, tellMaster: Boolean): Int
----

`removeBroadcast` removes all the blocks of the input `broadcastId` broadcast.

Internally, it starts by printing out the following DEBUG message to the logs:

```
DEBUG Removing broadcast [broadcastId]
```

It then requests all the link:spark-BlockDataManager.adoc#BroadcastBlockId[BroadcastBlockId] objects that belong to the `broadcastId` broadcast from link:spark-BlockInfoManager.adoc[BlockInfoManager] and <<removeBlock, removes them (from memory and disk)>>.

The number of blocks removed is the final result.

NOTE: It is used by link:spark-blockmanager-BlockManagerSlaveEndpoint.adoc#RemoveBroadcast[`BlockManagerSlaveEndpoint` while handling `RemoveBroadcast` messages].

== [[getStatus]] Getting Block Status -- `getStatus` Method

CAUTION: FIXME

== [[creating-instance]] Creating BlockManager Instance

`BlockManager` takes the following when created:

* [[executorId]] Executor ID
* [[rpcEnv]] link:spark-rpc.adoc[RpcEnv]
* [[master]] link:spark-BlockManagerMaster.adoc[BlockManagerMaster]
* [[serializerManager]] link:spark-SerializerManager.adoc[SerializerManager]
* [[conf]] link:spark-SparkConf.adoc[SparkConf]
* [[memoryManager]] link:spark-MemoryManager.adoc[MemoryManager]
* [[mapOutputTracker]] link:spark-service-mapoutputtracker.adoc[MapOutputTracker]
* [[shuffleManager]] link:spark-shuffle-ShuffleManager.adoc[ShuffleManager]
* <<blockTransferService, BlockTransferService>>
* [[securityManager]] `SecurityManager`
* [[numUsableCores]] CPU cores

NOTE: `executorId` is `SparkContext.DRIVER_IDENTIFIER`, i.e. `driver` for the driver, and the value of link:spark-CoarseGrainedExecutorBackend.adoc#executor-id[--executor-id] command-line argument for link:spark-CoarseGrainedExecutorBackend.adoc[CoarseGrainedExecutorBackend] executors or link:spark-executor-backends-MesosExecutorBackend.adoc[MesosExecutorBackend].

CAUTION: FIXME Elaborate on the executor backends and executor ids.

When created, `BlockManager` sets <<externalShuffleServiceEnabled, externalShuffleServiceEnabled>> internal flag per link:spark-ExternalShuffleService.adoc#spark.shuffle.service.enabled[spark.shuffle.service.enabled] Spark property.

`BlockManager` then creates an instance of link:spark-DiskBlockManager.adoc[DiskBlockManager] (requesting `deleteFilesOnStop` when an external shuffle service is not in use).

`BlockManager` creates an instance of link:spark-BlockInfoManager.adoc[BlockInfoManager] (as `blockInfoManager`).

`BlockManager` creates *block-manager-future* daemon cached thread pool with 128 threads maximum (as `futureExecutionContext`).

`BlockManager` creates a link:spark-MemoryStore.adoc[MemoryStore] and link:spark-DiskStore.adoc[DiskStore].

link:spark-MemoryManager.adoc[MemoryManager] gets the link:spark-MemoryStore.adoc[MemoryStore] object assigned.

`BlockManager` calculates the maximum memory to use (as `maxMemory`) by requesting the maximum link:spark-MemoryManager.adoc#maxOnHeapStorageMemory[on-heap] and link:spark-MemoryManager.adoc#maxOffHeapStorageMemory[off-heap] storage memory from the assigned `MemoryManager`.

NOTE: link:spark-UnifiedMemoryManager.adoc[UnifiedMemoryManager] is the default `MemoryManager` (as of Spark 1.6).

`BlockManager` calculates the port used by the external shuffle service (as `externalShuffleServicePort`).

NOTE: It is computed specially in Spark on YARN.

CAUTION: FIXME Describe the YARN-specific part.

`BlockManager` creates a client to read other executors' shuffle files (as `shuffleClient`). If the external shuffle service is used an link:spark-ShuffleClient-ExternalShuffleClient.adoc[ExternalShuffleClient] is created or the input link:spark-BlockTransferService.adoc[BlockTransferService] is used.

`BlockManager` sets <<spark.block.failures.beforeLocationRefresh, the maximum number of failures before this block manager refreshes the block locations from the driver>> (as `maxFailuresBeforeLocationRefresh`).

`BlockManager` registers link:spark-blockmanager-BlockManagerSlaveEndpoint.adoc[BlockManagerSlaveEndpoint] with the input link:spark-rpc.adoc[RpcEnv], itself, and link:spark-service-mapoutputtracker.adoc[MapOutputTracker] (as `slaveEndpoint`).

== [[shuffleServerId]] `shuffleServerId`

CAUTION: FIXME

== [[initialize]] Initializing BlockManager -- `initialize` Method

[source, scala]
----
initialize(appId: String): Unit
----

`initialize` initializes a `BlockManager` on the driver and executors (see link:spark-SparkContext.adoc#creating-instance[Creating SparkContext Instance] and link:spark-Executor.adoc#creating-instance[Creating Executor Instance], respectively).

NOTE: The method must be called before a `BlockManager` can be considered fully operable.

`initialize` does the following in order:

1. Initializes link:spark-BlockTransferService.adoc#init[BlockTransferService]
2. Initializes the internal shuffle client, be it link:spark-ShuffleClient-ExternalShuffleClient.adoc[ExternalShuffleClient] or link:spark-BlockTransferService.adoc[BlockTransferService].
3. link:spark-BlockManagerMaster.adoc#registerBlockManager[Registers itself with the driver's `BlockManagerMaster`] (using the `id`, `maxMemory` and its `slaveEndpoint`).
+
The `BlockManagerMaster` reference is passed in when the <<creating-instance, `BlockManager` is created>> on the driver and executors.
4. Sets <<shuffleServerId, shuffleServerId>> to an instance of <<BlockManagerId, BlockManagerId>> given an executor id, host name and port for link:spark-BlockTransferService.adoc[BlockTransferService].
5. It creates the address of the server that serves this executor's shuffle files (using <<shuffleServerId, shuffleServerId>>)

CAUTION: FIXME Review the initialize procedure again

CAUTION: FIXME Describe `shuffleServerId`. Where is it used?

If the <<externalShuffleServiceEnabled, External Shuffle Service is used>>, the following INFO appears in the logs:

```
INFO external shuffle service port = [externalShuffleServicePort]
```

It link:spark-BlockManagerMaster.adoc#registerBlockManager[registers itself to the driver's BlockManagerMaster] passing the <<BlockManagerId, BlockManagerId>>, the maximum memory (as `maxMemory`), and the link:spark-blockmanager-BlockManagerSlaveEndpoint.adoc[BlockManagerSlaveEndpoint].

Ultimately, if the initialization happens on an executor and the <<externalShuffleServiceEnabled, External Shuffle Service is used>>, it <<registerWithExternalShuffleServer, registers to the shuffle service>>.

NOTE: `initialize` is called when the link:spark-SparkContext-creating-instance-internals.adoc#BlockManager-initialization[driver is launched (and `SparkContext` is created)] and when an link:spark-Executor.adoc#creating-instance[`Executor` is created] (for link:spark-CoarseGrainedExecutorBackend.adoc#RegisteredExecutor[CoarseGrainedExecutorBackend] and link:spark-executor-backends-MesosExecutorBackend.adoc[MesosExecutorBackend]).

=== [[registerWithExternalShuffleServer]] Registering Executor's BlockManager with External Shuffle Server -- `registerWithExternalShuffleServer` Method

[source, scala]
----
registerWithExternalShuffleServer(): Unit
----

`registerWithExternalShuffleServer` is an internal helper method to register the `BlockManager` for an executor with an link:spark-ExternalShuffleService.adoc[external shuffle server].

NOTE: It is executed when a <<initialize, `BlockManager` is initialized on an executor and an external shuffle service is used>>.

When executed, you should see the following INFO message in the logs:

```
INFO Registering executor with local external shuffle service.
```

It uses <<shuffleClient, shuffleClient>> to link:spark-ShuffleClient-ExternalShuffleClient.adoc#registerWithShuffleServer[register the block manager] using <<shuffleServerId, shuffleServerId>> (i.e. the host, the port and the executorId) and a `ExecutorShuffleInfo`.

NOTE: The `ExecutorShuffleInfo` uses `localDirs` and `subDirsPerLocalDir` from link:spark-DiskBlockManager.adoc[DiskBlockManager] and the class name of the constructor link:spark-shuffle-ShuffleManager.adoc[ShuffleManager].

It tries to register at most 3 times with 5-second sleeps in-between.

NOTE: The maximum number of attempts and the sleep time in-between are hard-coded, i.e. they are not configured.

Any issues while connecting to the external shuffle service are reported as ERROR messages in the logs:

```
ERROR Failed to connect to external shuffle server, will retry [#attempts] more times after waiting 5 seconds...
```

== [[reregister]] Re-registering BlockManager with Driver and Reporting Blocks -- `reregister` Method

[source, scala]
----
reregister(): Unit
----

When executed, `reregister` prints the following INFO message to the logs:

```
INFO BlockManager: BlockManager [blockManagerId] re-registering with master
```

`reregister` then link:spark-BlockManagerMaster.adoc#registerBlockManager[registers itself to the driver's `BlockManagerMaster`] (just as it was when <<initialize, BlockManager was initializing>>). It passes the <<BlockManagerId, BlockManagerId>>, the maximum memory (as `maxMemory`), and the link:spark-blockmanager-BlockManagerSlaveEndpoint.adoc[BlockManagerSlaveEndpoint].

`reregister` will then report all the local blocks to the link:spark-BlockManagerMaster.adoc[BlockManagerMaster].

You should see the following INFO message in the logs:

```
INFO BlockManager: Reporting [blockInfoManager.size] blocks to the master.
```

For each block metadata (in link:spark-BlockInfoManager.adoc[BlockInfoManager]) it <<getCurrentBlockStatus, gets block current status>> and <<tryToReportBlockStatus, tries to send it to the BlockManagerMaster>>.

If there is an issue communicating to the link:spark-BlockManagerMaster.adoc[BlockManagerMaster], you should see the following ERROR message in the logs:

```
ERROR BlockManager: Failed to report [blockId] to master; giving up.
```

After the ERROR message, `reregister` stops reporting.

NOTE: `reregister` is called when a link:spark-Executor.adoc#heartbeats-and-active-task-metrics[`Executor` was informed to re-register while sending heartbeats].

== [[getCurrentBlockStatus]] Calculate Current Block Status -- `getCurrentBlockStatus` Method

[source, scala]
----
getCurrentBlockStatus(blockId: BlockId, info: BlockInfo): BlockStatus
----

`getCurrentBlockStatus` returns the current `BlockStatus` of the `BlockId` block (with the block's current link:spark-rdd-StorageLevel.adoc[StorageLevel], memory and disk sizes). It uses link:spark-MemoryStore.adoc[MemoryStore] and link:spark-DiskStore.adoc[DiskStore] for size and other information.

NOTE: Most of the information to build `BlockStatus` is already in `BlockInfo` except that it may not necessarily reflect the current state per link:spark-MemoryStore.adoc[MemoryStore] and link:spark-DiskStore.adoc[DiskStore].

Internally, it uses the input link:spark-BlockInfo.adoc[BlockInfo] to know about the block's storage level. If the storage level is not set (i.e. `null`), the returned `BlockStatus` assumes the link:spark-rdd-StorageLevel.adoc[default `NONE` storage level] and the memory and disk sizes being `0`.

If however the storage level is set, `getCurrentBlockStatus` uses link:spark-MemoryStore.adoc[MemoryStore] and link:spark-DiskStore.adoc[DiskStore] to check whether the block is stored in the storages or not and request for their sizes in the storages respectively (using their `getSize` or assume `0`).

NOTE: It is acceptable that the `BlockInfo` says to use memory or disk yet the block is not in the storages (yet or anymore). The method will give current status.

NOTE: `getCurrentBlockStatus` is used when <<reregister, executor's BlockManager is requested to report the current status of the local blocks to the master>>, <<doPutBytes, saving a block to a storage>> or <<dropFromMemory, removing a block from memory only>> or <<removeBlock, both, i.e. from memory and disk>>.

== [[reportAllBlocks]] `reportAllBlocks` Internal Method

[source, scala]
----
reportAllBlocks(): Unit
----

`reportAllBlocks`...FIXME

NOTE: `reportAllBlocks` is used when `BlockManager` is requested to <<reregister, re-register all blocks to the driver>>.

== [[reportBlockStatus]] Reporting Current Storage Status of Block to Driver -- `reportBlockStatus` Internal Method

[source, scala]
----
reportBlockStatus(
  blockId: BlockId,
  info: BlockInfo,
  status: BlockStatus,
  droppedMemorySize: Long = 0L): Unit
----

`reportBlockStatus` is an internal method for <<tryToReportBlockStatus, reporting a block status to the driver>> and if told to re-register it prints out the following INFO message to the logs:

```
INFO BlockManager: Got told to re-register updating block [blockId]
```

It does asynchronous reregistration (using `asyncReregister`).

In either case, it prints out the following DEBUG message to the logs:

```
DEBUG BlockManager: Told master about block [blockId]
```

NOTE: `reportBlockStatus` is used when `BlockManager` is requested to <<getBlockData, getBlockData>>, <<doPutBytes, doPutBytes>>, <<doPutIterator, doPutIterator>>, <<dropFromMemory, dropFromMemory>> and <<removeBlockInternal, removeBlockInternal>>.

== [[tryToReportBlockStatus]] Reporting Block Status Update to Driver -- `tryToReportBlockStatus` Internal Method

[source, scala]
----
def tryToReportBlockStatus(
  blockId: BlockId,
  info: BlockInfo,
  status: BlockStatus,
  droppedMemorySize: Long = 0L): Boolean
----

`tryToReportBlockStatus` link:spark-BlockManagerMaster.adoc#updateBlockInfo[reports block status update] to <<master, BlockManagerMaster>> and returns its response.

NOTE: `tryToReportBlockStatus` is used when `BlockManager` is requested to <<reportAllBlocks, reportAllBlocks>> or <<reportBlockStatus, reportBlockStatus>>.

== [[broadcast]] Broadcast Values

When a new broadcast value is created, link:spark-TorrentBroadcast.adoc[TorrentBroadcast] blocks are put in the block manager.

You should see the following `TRACE` message:

```
TRACE Put for block [blockId] took [startTimeMs] to get into synchronized block
```

It puts the data in the memory first and drop to disk if the memory store can't hold it.

```
DEBUG Put block [blockId] locally took [startTimeMs]
```

== [[BlockManagerId]] BlockManagerId

FIXME

== [[execution-context]] Execution Context

*block-manager-future* is the execution context for...FIXME

== Misc

The underlying abstraction for blocks in Spark is a `ByteBuffer` that limits the size of a block to 2GB (`Integer.MAX_VALUE` - see http://stackoverflow.com/q/8076472/1305344[Why does FileChannel.map take up to Integer.MAX_VALUE of data?] and https://issues.apache.org/jira/browse/SPARK-1476[SPARK-1476 2GB limit in spark for blocks]). This has implication not just for managed blocks in use, but also for shuffle blocks (memory mapped blocks are limited to 2GB, even though the API allows for `long`), ser-deser via byte array-backed output streams.

When a non-local executor starts, it initializes a `BlockManager` object using link:spark-SparkConf.adoc#spark.app.id[spark.app.id] Spark property for the id.

== [[BlockResult]] BlockResult

`BlockResult` is a description of a fetched block with the `readMethod` and `bytes`.

== [[registerTask]] Registering Task with BlockInfoManager -- `registerTask` Method

[source, scala]
----
registerTask(taskAttemptId: Long): Unit
----

`registerTask` link:spark-BlockInfoManager.adoc#registerTask[registers the input `taskAttemptId` with `BlockInfoManager`].

NOTE: `registerTask` is used exclusively when link:spark-scheduler-Task.adoc#run[`Task` runs].

== [[getDiskWriter]] Creating DiskBlockObjectWriter -- `getDiskWriter` Method

[source, scala]
----
getDiskWriter(
  blockId: BlockId,
  file: File,
  serializerInstance: SerializerInstance,
  bufferSize: Int,
  writeMetrics: ShuffleWriteMetrics): DiskBlockObjectWriter
----

`getDiskWriter` simply creates a <<spark-blockmanager-DiskBlockObjectWriter.adoc#, DiskBlockObjectWriter>> (with <<spark-configuration-properties.adoc#spark.shuffle.sync, spark.shuffle.sync>> Spark property for `syncWrites`).

NOTE: `getDiskWriter` uses the same `serializerManager` that was used to <<creating-instance, create a `BlockManager`>>.

[NOTE]
====
`getDiskWriter` is used when:

* `BypassMergeSortShuffleWriter` is requested to <<spark-shuffle-BypassMergeSortShuffleWriter.adoc#write, write records>>

* `ShuffleExternalSorter` is requested to <<spark-shuffle-ShuffleExternalSorter.adoc#writeSortedFile, writeSortedFile>>

* `ExternalAppendOnlyMap` is requested to `spillMemoryIteratorToDisk`

* `ExternalSorter` is requested to <<spark-ExternalSorter.adoc#spillMemoryIteratorToDisk, spillMemoryIteratorToDisk>> and <<spark-ExternalSorter.adoc#writePartitionedFile, writePartitionedFile>>

* `UnsafeSorterSpillWriter` is created
====

== [[addUpdatedBlockStatusToTaskMetrics]] Recording Updated BlockStatus In Current Task's TaskMetrics -- `addUpdatedBlockStatusToTaskMetrics` Internal Method

[source, scala]
----
addUpdatedBlockStatusToTaskMetrics(blockId: BlockId, status: BlockStatus): Unit
----

`addUpdatedBlockStatusToTaskMetrics` link:spark-TaskContext.adoc#get[takes an active `TaskContext`] (if available) and link:spark-executor-TaskMetrics.adoc#incUpdatedBlockStatuses[records updated `BlockStatus` for `Block`] (in the link:spark-TaskContext.adoc#taskMetrics[task's `TaskMetrics`]).

NOTE: `addUpdatedBlockStatusToTaskMetrics` is used when `BlockManager` <<doPutBytes, doPutBytes>> (for a block that was successfully stored), <<doPut, doPut>>, <<doPutIterator, doPutIterator>>, <<dropFromMemory, removes blocks from memory>> (possibly spilling it to disk) and <<removeBlock, removes block from memory and disk>>.

== [[shuffleMetricsSource]] Requesting Shuffle-Related Spark Metrics Source -- `shuffleMetricsSource` Method

[source, scala]
----
shuffleMetricsSource: Source
----

`shuffleMetricsSource` requests the <<shuffleClient, ShuffleClient>> for the link:spark-ShuffleClient.adoc#shuffleMetrics[shuffle-related metrics] and creates a link:spark-BlockManager-ShuffleMetricsSource.adoc[ShuffleMetricsSource] with the link:spark-BlockManager-ShuffleMetricsSource.adoc#sourceName[source name] per link:spark-ExternalShuffleService.adoc#spark.shuffle.service.enabled[spark.shuffle.service.enabled] configuration property:

* *ExternalShuffle* when link:spark-ExternalShuffleService.adoc#spark.shuffle.service.enabled[spark.shuffle.service.enabled] configuration property is on (`true`)

* *NettyBlockTransfer* when link:spark-ExternalShuffleService.adoc#spark.shuffle.service.enabled[spark.shuffle.service.enabled] configuration property is off (`false`)

NOTE: link:spark-ExternalShuffleService.adoc#spark.shuffle.service.enabled[spark.shuffle.service.enabled] configuration property is off (`false`) by default.

NOTE: `shuffleMetricsSource` is used exclusively when `Executor` is link:spark-Executor.adoc#creating-instance[created] (for non-local / cluster modes).

== [[settings]] Settings

.Spark Properties
[cols=""1,1,2"",options=""header"",width=""100%""]
|===
| Spark Property
| Default Value
| Description

| [[spark_blockManager_port]] `spark.blockManager.port`
| `0`
| Port to use for the block manager when a more specific setting for the driver or executors is not provided.

|===

== [[replicate]] Replicating Block To Peers -- `replicate` Internal Method

[source, scala]
----
replicate(
  blockId: BlockId,
  data: BlockData,
  level: StorageLevel,
  classTag: ClassTag[_],
  existingReplicas: Set[BlockManagerId] = Set.empty): Unit
----

`replicate`...FIXME

NOTE: `replicate` is used when `BlockManager` is requested to <<doPutBytes, doPutBytes>>, <<doPutIterator, doPutIterator>> and <<replicateBlock, replicateBlock>>.

== [[replicateBlock]] `replicateBlock` Method

[source, scala]
----
replicateBlock(
  blockId: BlockId,
  existingReplicas: Set[BlockManagerId],
  maxReplicas: Int): Unit
----

`replicateBlock`...FIXME

NOTE: `replicateBlock` is used exclusively when `BlockManagerSlaveEndpoint` is requested to link:spark-blockmanager-BlockManagerSlaveEndpoint.adoc#receiveAndReply-ReplicateBlock[handle ReplicateBlock messages].

== [[putIterator]] `putIterator` Method

[source, scala]
----
putIterator[T: ClassTag](
  blockId: BlockId,
  values: Iterator[T],
  level: StorageLevel,
  tellMaster: Boolean = true): Boolean
----

`putIterator`...FIXME

[NOTE]
====
`putIterator` is used when:

* `BlockManager` is requested to <<putSingle, putSingle>>

* Spark Streaming's `BlockManagerBasedBlockHandler` is requested to `storeBlock`
====

== [[putSingle]] `putSingle` Method

[source, scala]
----
putSingle[T: ClassTag](
  blockId: BlockId,
  value: T,
  level: StorageLevel,
  tellMaster: Boolean = true): Boolean
----

`putSingle`...FIXME

NOTE: `putSingle` is used when `TorrentBroadcast` is requested to link:spark-TorrentBroadcast.adoc#writeBlocks[read the blocks of a broadcast variable] and link:spark-TorrentBroadcast.adoc#readBroadcastBlock[readBroadcastBlock].

== [[getRemoteBytes]] Fetching Block From Remote Nodes -- `getRemoteBytes` Method

[source, scala]
----
getRemoteBytes(blockId: BlockId): Option[ChunkedByteBuffer]
----

`getRemoteBytes`...FIXME

[NOTE]
====
`getRemoteBytes` is used when:

* `BlockManager` is requested to <<getRemoteValues, getRemoteValues>>

* `TorrentBroadcast` is requested to link:spark-TorrentBroadcast.adoc#readBlocks[readBlocks]

* `TaskResultGetter` is requested to link:spark-scheduler-TaskResultGetter.adoc#enqueueSuccessfulTask[enqueuing a successful IndirectTaskResult]
====

== [[getRemoteValues]] `getRemoteValues` Internal Method

[source, scala]
----
getRemoteValues[T: ClassTag](blockId: BlockId): Option[BlockResult]
----

`getRemoteValues`...FIXME

NOTE: `getRemoteValues` is used exclusively when `BlockManager` is requested to <<get, get a block by BlockId>>.

== [[getSingle]] `getSingle` Method

[source, scala]
----
getSingle[T: ClassTag](blockId: BlockId): Option[T]
----

`getSingle`...FIXME

NOTE: `getSingle` is used exclusively in Spark tests.

== [[shuffleClient]] `shuffleClient` Property

[source, scala]
----
shuffleClient: ShuffleClient
----

`shuffleClient` is a link:spark-ShuffleClient.adoc[ShuffleClient] that `BlockManager` uses for the following:

* <<shuffleMetricsSource, shuffleMetricsSource>>

* <<registerWithExternalShuffleServer, Registering the BlockManager of an executor with an external shuffle server>>

`shuffleClient` is also used when `BlockStoreShuffleReader` is requested to link:spark-shuffle-BlockStoreShuffleReader.adoc#read[read combined key-value records for a reduce task] (and creates a link:spark-ShuffleBlockFetcherIterator.adoc#shuffleClient[ShuffleBlockFetcherIterator]).

`shuffleClient` can be either a link:spark-ShuffleClient-ExternalShuffleClient.adoc[ExternalShuffleClient] or the <<blockTransferService, BlockTransferService>> (that is the link:spark-NettyBlockTransferService.adoc[NettyBlockTransferService] given by link:spark-SparkEnv.adoc#create-BlockManager[SparkEnv]).

CAUTION: FIXME Figure

[[shuffleClient-externalShuffleServiceEnabled]]
`shuffleClient` uses `spark.shuffle.service.enabled` configuration property (default: `false`) that controls whether to use link:spark-ShuffleClient-ExternalShuffleClient.adoc[ExternalShuffleClient] (`true`) or the <<blockTransferService, BlockTransferService>> (i.e. link:spark-NettyBlockTransferService.adoc[NettyBlockTransferService]).

== [[blockTransferService]] `blockTransferService` Property

When <<creating-instance, created>>, `BlockManager` is given a link:spark-BlockTransferService.adoc[BlockTransferService] that is used for the following services:

* <<getRemoteBytes, Fetching a block from remote nodes>>

* <<replicate, Replicating a block to peers>>

NOTE: Remote nodes, peers, block managers are all synonyms.

The `BlockTransferService` acts as the <<shuffleClient, ShuffleClient>> when <<shuffleClient-externalShuffleServiceEnabled, spark.shuffle.service.enabled>> configuration property is off (which is the default).

When <<initialize, initialized>>, `BlockManager` requests the `BlockTransferService` to link:spark-BlockTransferService.adoc#init[init]. `BlockManager` also requests the <<shuffleClient, ShuffleClient>> to link:spark-ShuffleClient.adoc#init[init] (that does nothing by default).

When <<stop, stopped>>, `BlockManager` requests the `BlockTransferService` to link:spark-BlockTransferService.adoc#close[close]. `BlockManager` also requests the <<shuffleClient, ShuffleClient>> to `close`.

== [[getOrElseUpdate]] Getting Block From Block Managers Or Computing and Storing It Otherwise -- `getOrElseUpdate` Method

[source, scala]
----
getOrElseUpdate[T](
  blockId: BlockId,
  level: StorageLevel,
  classTag: ClassTag[T],
  makeIterator: () => Iterator[T]): Either[BlockResult, Iterator[T]]
----

[NOTE]
====
_I think_ it is fair to say that `getOrElseUpdate` is like link:++https://www.scala-lang.org/api/current/scala/collection/mutable/Map.html#getOrElseUpdate(key:K,op:=%3EV):V++[getOrElseUpdate] of https://www.scala-lang.org/api/current/scala/collection/mutable/Map.html[scala.collection.mutable.Map] in Scala.

[source, scala]
----
getOrElseUpdate(key: K, op: ⇒ V): V
----

Quoting the official scaladoc:

If given key `K` is already in this map, `getOrElseUpdate` returns the associated value `V`.

Otherwise, `getOrElseUpdate` computes a value `V` from given expression `op`, stores with the key `K` in the map and returns that value.

Since `BlockManager` is a key-value store of blocks of data identified by a block ID that works just fine.
====

`getOrElseUpdate` first attempts to <<get, get the block>> by the `BlockId` (from the local block manager first and, if unavailable, requesting remote peers).

[TIP]
====
Enable `INFO` logging level for `org.apache.spark.storage.BlockManager` logger to see what happens when `BlockManager` tries to <<get, get a block>>.

See <<logging, logging>> in this document.
====

`getOrElseUpdate` gives the `BlockResult` of the block if found.

If however the block was not found (in any block manager in a Spark cluster), `getOrElseUpdate` <<doPutIterator, doPutIterator>> (for the input `BlockId`, the `makeIterator` function and the `StorageLevel`).

`getOrElseUpdate` branches off per the result.

For `None`, `getOrElseUpdate` <<getLocalValues, getLocalValues>> for the `BlockId` and eventually returns the `BlockResult` (unless terminated by a `SparkException` due to some internal error).

For `Some(iter)`, `getOrElseUpdate` returns an iterator of `T` values.

NOTE: `getOrElseUpdate` is used exclusively when `RDD` is requested to link:spark-rdd-RDD.adoc#getOrCompute[get or compute an RDD partition] (for a `RDDBlockId` with a RDD ID and a partition index).

== [[doPutIterator]] `doPutIterator` Internal Method

[source, scala]
----
doPutIterator[T](
  blockId: BlockId,
  iterator: () => Iterator[T],
  level: StorageLevel,
  classTag: ClassTag[T],
  tellMaster: Boolean = true,
  keepReadLock: Boolean = false): Option[PartiallyUnrolledIterator[T]]
----

`doPutIterator` simply <<doPut, doPut>> with the `putBody` function that accepts a `BlockInfo` and does the following:

. `putBody` branches off per whether the `StorageLevel` indicates to use a link:spark-rdd-StorageLevel.adoc#useMemory[memory] or simply a link:spark-rdd-StorageLevel.adoc#useDisk[disk], i.e.

* When the input `StorageLevel` indicates to link:spark-rdd-StorageLevel.adoc#useMemory[use a memory] for storage in link:spark-rdd-StorageLevel.adoc#deserialized[deserialized] format, `putBody` requests <<memoryStore, MemoryStore>> to link:spark-MemoryStore.adoc#putIteratorAsValues[putIteratorAsValues] (for the `BlockId` and with the `iterator` factory function).
+
If the <<memoryStore, MemoryStore>> returned a correct value, the internal `size` is set to the value.
+
If however the <<memoryStore, MemoryStore>> failed to give a correct value, FIXME

* When the input `StorageLevel` indicates to link:spark-rdd-StorageLevel.adoc#useMemory[use memory] for storage in link:spark-rdd-StorageLevel.adoc#deserialized[serialized] format, `putBody`...FIXME

* When the input `StorageLevel` does not indicate to use memory for storage but link:spark-rdd-StorageLevel.adoc#useDisk[disk] instead, `putBody`...FIXME

. `putBody` requests the <<getCurrentBlockStatus, current block status>>

. Only when the block was successfully stored in either the memory or disk store:

* `putBody` <<reportBlockStatus, reports the block status>> to the <<master, BlockManagerMaster>> when the input `tellMaster` flag (default: enabled) and the `tellMaster` flag of the block info are both enabled.

* `putBody` <<addUpdatedBlockStatusToTaskMetrics, addUpdatedBlockStatusToTaskMetrics>> (with the `BlockId` and `BlockStatus`)

* `putBody` prints out the following DEBUG message to the logs:
+
```
Put block [blockId] locally took [time] ms
```

* When the input `StorageLevel` indicates to use link:spark-rdd-StorageLevel.adoc#replication[replication], `putBody` <<doGetLocalBytes, doGetLocalBytes>> followed by <<replicate, replicate>> (with the input `BlockId` and the `StorageLevel` as well as the `BlockData` to replicate)

* With a successful replication, `putBody` prints out the following DEBUG message to the logs:
+
```
Put block [blockId] remotely took [time] ms
```

. In the end, `putBody` may or may not give a `PartiallyUnrolledIterator` if...FIXME

NOTE: `doPutIterator` is used when `BlockManager` is requested to <<getOrElseUpdate, get a block from block managers or computing and storing it otherwise>> and <<putIterator, putIterator>>.

== [[dropFromMemory]] Removing Blocks From Memory Only -- `dropFromMemory` Method

[source, scala]
----
dropFromMemory(
  blockId: BlockId,
  data: () => Either[Array[T], ChunkedByteBuffer]): StorageLevel
----

NOTE: `dropFromMemory` is part of the link:spark-BlockEvictionHandler.adoc#dropFromMemory[BlockEvictionHandler Contract] to...FIXME

When `dropFromMemory` is executed, you should see the following INFO message in the logs:

```
INFO BlockManager: Dropping block [blockId] from memory
```

It then asserts that the `blockId` block is link:spark-BlockInfoManager.adoc#assertBlockIsLockedForWriting[locked for writing].

If the block's link:spark-rdd-StorageLevel.adoc[StorageLevel] uses disks and the internal link:spark-DiskStore.adoc[DiskStore] object (`diskStore`) does not contain the block, it is saved then. You should see the following INFO message in the logs:

```
INFO BlockManager: Writing block [blockId] to disk
```

CAUTION: FIXME Describe the case with saving a block to disk.

The block's memory size is fetched and recorded (using `MemoryStore.getSize`).

The block is link:spark-MemoryStore.adoc#remove[removed from memory] if exists. If not, you should see the following WARN message in the logs:

```
WARN BlockManager: Block [blockId] could not be dropped from memory as it does not exist
```

It then <<getCurrentBlockStatus, calculates the current storage status of the block>> and <<reportBlockStatus, reports it to the driver>>. It only happens when `info.tellMaster`.

CAUTION: FIXME When would `info.tellMaster` be `true`?

A block is considered updated when it was written to disk or removed from memory or both. If either happened, the link:spark-executor-TaskMetrics.adoc#incUpdatedBlockStatuses[current TaskContext metrics are updated with the change].

Ultimately, `dropFromMemory` returns the current storage level of the block.

== [[handleLocalReadFailure]] `handleLocalReadFailure` Internal Method

[source, scala]
----
handleLocalReadFailure(blockId: BlockId): Nothing
----

`handleLocalReadFailure`...FIXME

NOTE: `handleLocalReadFailure` is used when...FIXME

== [[releaseLockAndDispose]] `releaseLockAndDispose` Method

[source, scala]
----
releaseLockAndDispose(
  blockId: BlockId,
  data: BlockData,
  taskAttemptId: Option[Long] = None): Unit
----

`releaseLockAndDispose`...FIXME

NOTE: `releaseLockAndDispose` is used when...FIXME
",12492,True,2807.7882498478198,median
":toc: macro
toc::[]
:idprefix:
:idseparator: -
ifdef::env-github[]
:tip-caption: :bulb:
:note-caption: :information_source:
:important-caption: :heavy_exclamation_mark:
:caution-caption: :fire:
:warning-caption: :warning:
endif::[]

== devon4j adding Custom Functionality

Now we have a fully functional blank project. All we have to do now is to create the components and services which will compose our application.

First, we are going to develop the views of the app through its components, then we will create the services with the logic, security and back-end connection.


==  Creating Components

[NOTE]
== == 
You have already learned about creating Components in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-components#create-a-new-component[here]. +
You can go back and read that section again to refresh your memory.
== == 

Our app is going to consist of 3 main views:

* `Login`
* `Register`
* `ViewQueue`

To navigate between these views/components, we are going to implement routes using the Angular Router.

To see our progress, move to the root folder of the `angular` project and run `ng serve -o` again. This will recompile and publish our client app to http://localhost:4200. Angular will keep watching for changes, so whenever we modify the code, the app will automatically reload.

== Root Component

`app.component.ts` inside `angular/src/app` will be our root component, so we don't have to create a new file yet. We are going to add elements to the root component that will be common no matter what view will be displayed.

[NOTE]
== == 
You have already learned about the Root Component in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-components#root-component[here]. +
You can go back and read that section again to refresh your memory.
== == 

This applies to the header element which will be on top of the window and on top of all other components. If you want, you can read more about https://teradata.github.io/covalent/#/layouts[Covalent layouts], which we are going to use a lot from now on, for every view component.

[NOTE]
== == 
You have already learned about Covalent Layouts in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-components#teradata-covalent-layouts[here]. +
You can go back and read that section again to refresh your memory.
== == 

We don't really need anything more than a header, so we are going to use the simplest layout for this purpose; the *nav view*.

In order to be able to use Covalent and Angular Material we are going to create a core module, which we will import into every other module where we want to use Covalent and Angular Material. First, we create a folder called `shared` in the `angular/src/app` directory. Inside there we are going to create a file called `core.module.ts` and will fill it with the following content:

[source, typescript]
----
import { NgModule } from '@angular/core';
import { RouterModule } from '@angular/router';
import { CommonModule } from '@angular/common';
import { HttpClientModule, HTTP_INTERCEPTORS } from '@angular/common/http';
import { BrowserAnimationsModule } from '@angular/platform-browser/animations';
import {
  MatAutocompleteModule,
  MatButtonModule,
  MatButtonToggleModule,
  MatCardModule,
  MatCheckboxModule,
  MatChipsModule,
  MatDatepickerModule,
  MatDialogModule,
  MatExpansionModule,
  MatGridListModule,
  MatIconModule,
  MatInputModule,
  MatListModule,
  MatMenuModule,
  MatNativeDateModule,
  MatPaginatorModule,
  MatProgressBarModule,
  MatProgressSpinnerModule,
  MatRadioModule,
  MatRippleModule,
  MatSelectModule,
  MatSidenavModule,
  MatSliderModule,
  MatSlideToggleModule,
  MatSnackBarModule,
  MatSortModule,
  MatTableModule,
  MatTabsModule,
  MatToolbarModule,
  MatTooltipModule,
} from '@angular/material';
import { CdkTableModule } from '@angular/cdk/table';
import {
  CovalentChipsModule,
  CovalentLayoutModule,
  CovalentExpansionPanelModule,
  CovalentDataTableModule,
  CovalentPagingModule,
  CovalentDialogsModule,
  CovalentLoadingModule,
  CovalentMediaModule,
  CovalentNotificationsModule,
  CovalentCommonModule,
} from '@covalent/core';

@NgModule({
  imports: [
    RouterModule,
    BrowserAnimationsModule,
    MatCardModule,
    MatButtonModule,
    MatIconModule,
    CovalentMediaModule,
    CovalentLayoutModule,
    CdkTableModule,
  ],
  exports: [
    CommonModule,
    CovalentChipsModule,
    CovalentLayoutModule,
    CovalentExpansionPanelModule,
    CovalentDataTableModule,
    CovalentPagingModule,
    CovalentDialogsModule,
    CovalentLoadingModule,
    CovalentMediaModule,
    CovalentNotificationsModule,
    CovalentCommonModule,
    CdkTableModule,
    MatAutocompleteModule,
    MatButtonModule,
    MatButtonToggleModule,
    MatCardModule,
    MatCheckboxModule,
    MatChipsModule,
    MatDatepickerModule,
    MatDialogModule,
    MatExpansionModule,
    MatGridListModule,
    MatIconModule,
    MatInputModule,
    MatListModule,
    MatMenuModule,
    MatNativeDateModule,
    MatPaginatorModule,
    MatProgressBarModule,
    MatProgressSpinnerModule,
    MatRadioModule,
    MatRippleModule,
    MatSelectModule,
    MatSidenavModule,
    MatSliderModule,
    MatSlideToggleModule,
    MatSnackBarModule,
    MatSortModule,
    MatTableModule,
    MatTabsModule,
    MatToolbarModule,
    MatTooltipModule,
    HttpClientModule,
  ],
  declarations: [],
  providers: [
    HttpClientModule
  ],
})
export class CoreModule {}
----

[NOTE]
== == 
This `CoreModule` has almost every module of the different components for *Angular Material* and *Covalent Teradata*. If you decide to use a component that is not included yet, you need to add the corresponding module here.
== == 

Remember that we need to import this `CoreModule` module into the `AppModule` and inside every module of the different components that use *Angular Material* and *Covalent Teradata*. If a component does not have a module, it will be imported in the `AppModule` and hence automatically have the `CoreModule`. Our `app.module.ts` should have the following content:

[source, typescript]
----
import { BrowserModule } from '@angular/platform-browser';
import { NgModule, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';

// Application components and services
import { AppRoutingModule } from './app-routing.module';
import { AppComponent } from './app.component';
import { CoreModule } from './shared/core.module';

@NgModule({
  declarations: [
    AppComponent
  ],
  imports: [
    BrowserModule,
    AppRoutingModule,
    CoreModule,
  ],
  providers: [
  ],
  bootstrap: [AppComponent],
  schemas: [ CUSTOM_ELEMENTS_SCHEMA ]
})
export class AppModule { }
----
[NOTE]
== == 
Even if we setup module correctly the HTML file can give us this red flag: ""If `td-layout` is a Web Component then add 'CUSTOM_ELEMENTS_SCHEMA' to the `@NgModule.schemas` of this component to suppress this message.""
To solve this we add ""schemas: [ CUSTOM_ELEMENTS_SCHEMA ]"" inside the `@NgModule` of all the affected modules.
== == 

[NOTE]
== == 
Remember this step because you will have to repeat it for every other component from Teradata you use in your app.
== == 

Now we can use this layout, so let's implement it in `app.component.html`. Use the following code:

[source, html]
----
<td-layout-nav>             <!-- Layout tag-->
  <div td-toolbar-content>
    Jump The Queue          <!-- Header container-->
  </div>
  <h1>
    app works!              <!-- Main content-->
  </h1>
</td-layout-nav>
----

[NOTE]
== == 
You have already learned about Toolbars in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-components#toolbars[here]. +
You can go back and read that section again to refresh your memory.
== == 

[NOTE]
== == 
You have already learned about Toolbars in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-components#toolbars[here]. +
You can go back and read that section again to refresh your memory.
== == 

Once this is done, our app should have a header and ""app works!"" should appear in the body of the page:

image::images/devon4ng/3.BuildYourOwn/root_header.jpg[Root Header, 250]

To go a step further, we have to modify the body of the root component because it should be the *output of the router*. Now it's time to prepare the routing system.

First, we need to create a component to show as default which will be our access view. We will modify it later. Stop `ng serve` and run:

```
ng generate component form-login
```

It will add a folder to our project with all the files needed for a component. Now we can move on to the router task again. Run `ng serve` again to continue the development.

Let's create a module that navigates between components when the Router checks for routes. The file `app-routing.module.ts` was created automatically when we chose to include Angular Routing during project creation and we only need to modify it now:

[source, typescript]
----
import { NgModule } from '@angular/core';
import { RouterModule, Routes } from '@angular/router';
import { FormLoginComponent } from './form-login/form-login.component';

const appRoutes: Routes = [
  { path: 'FormLogin', component: FormLoginComponent},        // Redirect if url path is /FormLogin.
  { path: '**', redirectTo: '/FormLogin', pathMatch: 'full' } // Redirect if url path do not match any other route.
];

@NgModule({
  imports: [
    RouterModule.forRoot(
      appRoutes,
      { enableTracing: true }, // <-- debugging purposes only
    ),
  ],
  exports: [RouterModule],
})
export class AppRoutingModule {}
----

[NOTE]
== == 
You have already learned about Routing in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-components#routing[here]. +
You can go back and read that section again to refresh your memory.
== == 

Finally, we remove the `<h1>app works!</h1>` from `app.component.html` and replace it with a `<router-outlet></router-outlet>` tag. The final result of our root component will look like this:

image::images/devon4ng/3.BuildYourOwn/root_router.jpg[Root Router, 250]

As you can see, now the body content is the HTML of `FormLoginComponent`. This is because we told the Router to redirect to login form when the path is `/FormLogin`, but also, redirect to it by default if any of the other routes match the given path.

For now we are going to leave the header like this. In the future we will separate it into another component inside a layout folder.

== `LoginForm` Component

As we have already created this component from the section before, let's move on to building the template of the login view.

First, we need to add the Covalent Layout and the card to the file `form-login.component.html`:

[source, html]
----
<td-layout>
  <mat-card>
    <mat-card-title>Login</mat-card-title>
  </mat-card>
</td-layout>
----

This will add a gray background to the view and a card on top of it with the title ""Login"" now that we have the basic structure of the view.

Now we are going to add this image:

image::images/devon4ng/3.BuildYourOwn/jumptheq.png[JumpTheQueue Logo Image, 250]

In order to have it available, save it in the following path of the project: `angular/src/assets/images/` and name it `jumptheq.png`.

The final code with the form added will look like this:

[source, html]
----
<td-layout>
  <mat-card>
    <img mat-card-image src=""assets/images/jumptheq.png"">
  </mat-card>
</td-layout>
----

This code will give us as a result similar to this:

image::images/devon4ng/3.BuildYourOwn/formlogin.png[Form Login, 250]

This is going to be the container for the login. +
Now we will continue with the second component: Login.

== Login Component

Our first step will be to create the component in the exact same way we created the `FormLogin` component but this time we are going to generate it in a new folder called components inside `formlogin`. Putting every child component inside that folder will allow us to keep a good and clear structure. In order to do this, we use the command:

```
ng generate component form-login/components/login
```

After _Angular/CLI_ has finished generating the component, we have to create two modules, one for the form-login and one for the login:

1.- We create a new file called `login-module.ts` in the login root:

[source, typescript]
----
import { NgModule, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
import { CommonModule } from '@angular/common';
import { CoreModule } from 'src/app/shared/core.module';
import { LoginComponent } from './login.component';

@NgModule({
  imports: [CommonModule, CoreModule],
  providers: [],
  declarations: [LoginComponent],
  exports: [LoginComponent],
  schemas: [ CUSTOM_ELEMENTS_SCHEMA ]
})
export class LoginModule {}
----

2.- We create a new file called `form-login-module.ts` in the form-login root:

[source, typescript]
----
import { NgModule, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
import { CommonModule } from '@angular/common';
import { FormLoginComponent } from './form-login.component';
import { CoreModule } from '../shared/core.module';
import { LoginModule } from './components/login/login-module';

@NgModule({
  imports: [CommonModule, CoreModule, LoginModule],
  providers: [],
  declarations: [FormLoginComponent],
  exports: [FormLoginComponent],
  schemas: [ CUSTOM_ELEMENTS_SCHEMA ]
})
export class FormLoginModule {}
----

As you can see, the `LoginModule` is already added to the `FormLoginModule`. Once this is done, we need to remove the `FormLoginComponent` and the `LoginComponent` from the `declarations` since they are already declared in their own modules. Then add the `FormLoginModule`. This will be done inside `AppModule`:

[source, typescript]
----
...
import { FormLoginModule } from './form-login/form-login-module';
...
  declarations: [
    AppComponent,
  ]

  imports: [
    BrowserModule,
    FormLoginModule,
    CoreModule,
    AppRoutingModule
  ]
...
----

[NOTE]
== == 
This is done so the `form-login` (container/wrapper) and the `login` stay separated allowing us to reuse the login without having the card around in other views.
== == 

After this, we modify the `login.component.html` and add the form: 

[source, typescript]
----
<form #loginForm=""ngForm"" layout-padding>
    <div layout=""row"" flex>
        <mat-form-field flex>
                <input matInput placeholder=""Email"" ngModel email name=""username"" required>
        </mat-form-field>
    </div>
    <div layout=""row"" flex>
        <mat-form-field flex>
            <input matInput placeholder=""Password"" ngModel name=""password"" type=""password"" required>
        </mat-form-field>
    </div>
    <div layout=""row"" flex>
    </div>
    <div layout=""row"" flex layout-margin>
        <div layout=""column"" flex>
            <button mat-raised-button [disabled]=""!loginForm.form.valid"">Login</button>
        </div>
        <div layout=""column"" flex>
            <button mat-raised-button color=""primary"">Register</button>
        </div>
    </div>
</form>
----

[NOTE]
== == 
You have already learned about Forms in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-components#forms[here]. +
You can go back and read that section again to refresh your memory.
== == 

This form contains two input containers from Material. The containers enclose the input with the properties listed above.

We also need to add a button to send the information and redirect to the `QueueViewer` or show an error if something went wrong in the process. But for the moment, as we neither have another component nor the `auth` service yet, we will implement the button visually, as well as the validator to disable it if the form is not correct. We will tackle the on-click-event later.

As a last step we will add this component to the `form-login-component.html`:

[source, html]
----
<td-layout>
    <mat-card>
        <img mat-card-image src=""assets/images/jumptheq.png"">
        <app-login></app-login>
    </mat-card>
</td-layout>
----

Now you should see something like this:

image::images/devon4ng/3.BuildYourOwn/login.png[JumpTheQueue Login Screen, 250]

With two components already created, we need to use the router to navigate between them. Following the application flow of events, we are going to add a _navigate_ function to the register button. When we press it, we will be redirected to our future register component.

== Register Component

First, we are going to generate the register component via:

```
ng generate component register`
```

This will create our component so we can start working on it. Turning back to `login.component.html` we have to modify these lines of code:

[source, html]
----
<form (ngSubmit)=""submitLogin()"" #loginForm=""ngForm"" layout-padding>
... 
<button mat-raised-button type=""submit"" [disabled]=""!loginForm.form.valid"">Login</button>
...       
<button mat-raised-button (click)=""onRegisterClick()"" color=""primary"">Register</button>
----

Two events were added. First, when we submit the form, the method `submitLogin()` is going to be called. Second, when the user clicks the button `(click)` will send an event to the function `onRegisterClick()`. This function should be inside `login.component.ts` which is going to be created now:

[source, typescript]
----
  ...
  import { Router } from '@angular/router';
  ...
  constructor(private router: Router) { }
  ...
  onRegisterClick(): void {
    this.router.navigate(['Register']);
  }

  submitLogin(): void {
  }
----

We need to inject an instance of the Router object and declare it with the name _router_ in order to use it in the code, as we did with `onRegisterClick()`. Doing this will use the navigate function and redirect to the next view. In our case, it will redirect using the route we are going to define in `app.routing.module.ts`:

[source, typescript]
----
...
import { RegisterComponent } from './register/register.component';
...
const appRoutes: Routes = [
  { path: 'FormLogin', component: FormLoginComponent},          // Redirect if url path is /FormLogin.
  { path: 'Register', component: RegisterComponent},            // Redirect if url path is /Register.
  { path: '**', redirectTo: '/FormLogin', pathMatch: 'full' }   // Redirect if url path do not match any other route.
];
...
----

[NOTE]
== == 
You have already learned about Dependency Injection in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-services#dependency-injection[here]. +
You can go back and read that section again to refresh your memory.
== == 

Now we are going to imitate the `login` to shape our `register.component.html`:

[source, html]
----
<form layout-padding (ngSubmit)=""submitRegister()"" #registerForm=""ngForm"">
  <div layout=""row"" flex>
      <mat-form-field flex>
        <input matInput placeholder=""Email"" ngModel email name=""username"" required>
      </mat-form-field>
  </div>
  <div layout=""row"" flex>
      <mat-form-field flex>
        <input matInput placeholder=""Password"" ngModel name=""password"" type=""password"" required>
      </mat-form-field>
  </div>
  <div layout=""row"" flex>
      <mat-form-field flex>
        <input matInput placeholder=""Name"" ngModel name=""name"" required>
      </mat-form-field>
  </div>
  <div layout=""row"" flex>
      <mat-form-field flex>
        <input matInput placeholder=""Phone Number"" ngModel name=""phoneNumber"" required>
      </mat-form-field>
  </div>
  <div layout-xs=""row"" flex>
      <div layout=""column"" flex>
        <mat-checkbox name=""acceptedTerms"" ngModel required>Accept Terms And conditions</mat-checkbox>
      </div>
  </div>
  <div layout-xs=""row"" flex>
      <div layout=""column"" flex>
        <mat-checkbox name=""acceptedCommercial"" ngModel required>I want to receive notifications</mat-checkbox>
      </div>
  </div>
  <div layout=""row"" flex>
  </div>
  <div layout=""row"" flex>
      <div layout=""column"" flex=""10"">
        </div>
      <div layout=""column"" flex>
          <button mat-raised-button type=""submit"" [disabled]=""!registerForm.form.valid"">Register</button>
      </div>
      <div layout=""column"" flex=""10"">
      </div>
  </div>
</form>
----

Now that we have a minimum of navigation flow inside our application, we are going to generate our first service using the command:

```
ng generate service register/services/register
```

This will create a folder ""services"" inside ""register"" and create the service itself. Services are where we keep the logic that connects to our database and fetches data which is going to be used by our `component.ts`.

In order to use the service, we are going to create some interface models. Let's create a folder called `backendModels` inside ""shared"" and inside this folder a file called `interfaces.ts` in which we are going to add the model interfaces that will match our back-end:

[source, typescript]
----
export class Visitor {
    id?: number;
    username: string;
    name: string;
    password: string;
    phoneNumber: string;
    acceptedCommercial: boolean;
    acceptedTerms: boolean;
    userType: boolean;
}
export class VisitorArray {
    content: Visitor[];
}
----

[NOTE]
== == 
You have already learned about creating new services in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-services#create-a-new-service[here]. +
You can go back and read that section again to refresh your memory.
== == 

If we take a closer look, we can see that id has a `?` behind it. This indicates that the id is optional.

[NOTE]
== == 
At this point we are going to assume that you have finished the https://github.com/devonfw/jump-the-queue/wiki/build-devon4j-application[devon4j] part of this tutorial, or have at least downloaded the project and have the back end running locally on http://localhost:8081.
== == 

After doing this, we are going to add an environment variable with our base-URL for the REST services. This way we won't have to change every URL when we switch to production. Inside `environments/environment.ts` we add:

[source, typescript]
----
export const environment: {production: boolean, baseUrlRestServices: string} = {
  production: false,
  baseUrlRestServices: 'http://localhost:8081/jumpthequeue/services/rest'
};
----

Now in the service, we are going to add a `registerVisitor` method.

To call the server in this method we are going to inject the Angular `HttpClient` class from `@angular/common/http`. This class is the standard used by Angular to perform HTTP calls. The register call demands a `Visitor` model which we created in the `interfaces` file. We are going to build a POST call and send the information to the proper URL of the server service. The call will return an observable:

[source, typescript]
----
import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Visitor} from 'src/app/shared/backendModels/interfaces';
import { Observable } from 'rxjs';
import { environment } from 'src/environments/environment';

@Injectable({
  providedIn: 'root'
})
export class RegisterService {

  private baseUrl = environment.baseUrlRestServices;

  constructor(private http: HttpClient) { }

  registerVisitor(visitor: Visitor): Observable<Visitor> {
    return this.http.post<Visitor>(`${this.baseUrl}` + '/visitormanagement/v1/visitor', visitor);
  }
}
----

This method will send our model to the back-end and return an Observable that we will use on the `component.ts`.

[NOTE]
== == 
You have already learned about Observables and RxJs in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-services#server-communication[here]. +
You can go back and read that section again to refresh your memory.
== == 

Now we are going to modify `register.component.ts` to call this service:

[source, typescript]
----
import { Component, OnInit } from '@angular/core';
import { RegisterService } from './services/register.service';
import { Visitor } from '../shared/backendModels/interfaces';
import { Router } from '@angular/router';
import { MatSnackBar } from '@angular/material/snack-bar';

@Component({
  selector: 'app-register',
  templateUrl: './register.component.html',
  styleUrls: ['./register.component.scss']
})
export class RegisterComponent implements OnInit {

  constructor(private registerService: RegisterService, private router: Router, public snackBar: MatSnackBar) { }

  submitRegister(formValue): void {
    const visitor: Visitor = new Visitor();
    visitor.username = formValue.username;
    visitor.name = formValue.name;
    visitor.phoneNumber = formValue.phoneNumber;
    visitor.password = formValue.password;
    visitor.acceptedCommercial = formValue.acceptedCommercial;
    visitor.acceptedTerms = formValue.acceptedTerms;
    visitor.userType = false;

    this.registerService.registerVisitor(visitor).subscribe(
      (visitorResult: Visitor) => console.log(JSON.stringify(visitorResult)), // When call is received
      (err) =>  this.snackBar.open(err.error.message, 'OK', {
        duration: 5000,
      }), // When theres an error
    );
  }

  ngOnInit() {
  }
}
----

In this file we injected `RegisterService` and `Router` to use them. Then, inside the method `submitRegister`, we created a visitor that we are going to pass to the service. We called the service method `registerVisitor`, we passed the visitor and we subscribed to the `Observable<Visitor>`, which we returned from the service. This subscription allows us to control three things:

. What to do when the data is received.

. What to do when there's an error.

. What to do when the call is complete.

Finally, we modify the `register.component.html` to send the form values to the method:

[source, html]
----
...
<form layout-padding (ngSubmit)=""submitRegister(registerForm.form.value)"" #registerForm=""ngForm"">
...
----

image::images/devon4ng/3.BuildYourOwn/register.png[Register Page, 250]

Using the method and taking a look at the browser console, we should see the visitor model being returned.

==  Creating Services

Now that we registered a `Visitor`, it's time to create 3 important services:

- AuthService
- AuthGuardService
- LoginService

The `AuthService` will be the one that contains the login info, the `AuthGuardService` will check if a user is authorized to use a component (via the `canActivate` method), and the `LoginService` will be used to fill the `AuthService`.

[NOTE]
== == 
To keep this tutorial simple, we are going to perform the password check client side. *THIS IS NOT CORRECT!* Usually, you would send the username and password to the back-end, check that the values are correct, and create a corresponding token which you would pass in the header and use it inside the `AuthService` -- checking with some interceptors that the token is both in the `AuthService` and in the request.
== == 

== Login, Auth and AuthGuard Services

We are going to create the 3 services via `ng generate service <path>`:

. `LoginService` via: +
`ng generate service form-login/components/login/services/login`

. `Auth` service via: +
`ng generate service core/authentication/auth`

. `AuthGuard` service via: +
`ng generate service core/authentication/auth-guard`

After generating the services, we are going to start modifying the interfaces. Inside `angular/src/app/shared/backendModels/interfaces` we are going to add `Role`, `FilterVisitor`, `Pageable` and a `Sort` interface:

[source, typescript]
----
...
export class FilterVisitor {
    pageable: Pageable;
    username?: string;
    password?: string;
}

export class Pageable {
    pageSize: number;
    pageNumber: number;
    sort: Sort[];
}

export class Sort {
    property: string;
    direction: string;
}

export class Role {
    name: string;
    permission: number;
}
----

[NOTE]
== == 
As you can see, we added a `Pageable`, since a lot of the search methods in the back-end are using `SearchCriterias`. These need pageables which specify a `paseSize` and `pageNumber`. Also, we can see that in this case `FilterVisitor` uses a pageable and adds parameters as a filter (`username` and `password`), which are optional.
== == 

Then we are going to create a `config.ts` file inside the root (`angular/app`). We are going to use that file to set up default config variables, for example: role names with their permission number, default pagination settings etc. For now we are just adding the roles:

[source, typescript]
----
export const config: any = {
    roles: [
        { name: 'VISITOR', permission: 0 },
        { name: 'BOSS', permission: 1 },
    ],
};
----

After that, we are going to modify the `auth.service.ts`:

[source, typescript]
----
import { Injectable } from '@angular/core';
import { find } from 'lodash';
import { Role } from 'src/app/shared/backendModels/interfaces';
import { config } from 'src/app/config';

@Injectable({
  providedIn: 'root'
})
export class AuthService {
  private logged = false;
  private user = '';
  private userId = 0;
  private currentRole = 'NONE';
  private token: string;

  public isLogged(): boolean {
    return this.logged;
  }

  public setLogged(login: boolean): void {
    this.logged = login;
  }

  public getUser(): string {
    return this.user;
  }

  public setUser(username: string): void {
    this.user = username;
  }

  public getUserId(): number {
    return this.userId;
  }

  public setUserId(userId: number): void {
    this.userId = userId;
  }

  public getToken(): string {
    return this.token;
  }

  public setToken(token: string): void {
    this.token = token;
  }

  public setRole(role: string): void {
    this.currentRole = role;
  }

  public getPermission(roleName: string): number {
    const role: Role = <Role>find(config.roles, { name: roleName });
    return role.permission;
  }

  public isPermited(userRole: string): boolean {
    return (
      this.getPermission(this.currentRole) == this.getPermission(userRole)
    );
  }
}
----

We will use this service to fill it with information from the logged-in user once the user logs in. This will allow us to check the information of the logged-in user in any way necessary.

[NOTE]
== == 
You have already learned about Authentication in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-services#authentication[here]. +
You can go back and read that section again to refresh your memory.
== == 

Now we are going to use this class to fill the `auth-guard.service.ts`:

[source, typescript]
----
import { Injectable } from '@angular/core';
import {
  CanActivate,
  Router,
  ActivatedRouteSnapshot,
  RouterStateSnapshot,
} from '@angular/router';
import { AuthService } from './auth.service';

@Injectable({
  providedIn: 'root'
})
export class AuthGuardService implements CanActivate {
  constructor(
    private authService: AuthService,
    private router: Router,
  ) {}

  canActivate(
    route: ActivatedRouteSnapshot,
    state: RouterStateSnapshot,
  ): boolean {
    if (this.authService.isLogged() && this.authService.isPermited('VISITOR')) { // If its logged in and its role is visitor
      return true;
    }

    if (!this.authService.isLogged()) { // if its not logged in
      console.log('Error login');
    }

    if (this.router.url == '/') {  // if the router is the app route
      this.router.navigate(['/login']);
    }
    return false;
  }
}
----

This service will be slightly different because we have to implement an interface called `CanActivate`. It has a method called `canActivate()` returning a boolean. This method will be called when navigating to a specified route, and -- depending on the return value of this implemented method -- the navigation will proceed or be rejected.

[NOTE]
== == 
You have already learned about Guards in devon4ng https://github.com/devonfw/jump-the-queue/wiki/devon4ng-services#guards[here]. +
You can go back and read that section again to refresh your memory.
== == 

Once this is done, the last step is to fill the `login.service.ts`. In this case, there's going to be three methods:

. `getVisitorByUsername(username: string)`: +
A method that recovers a single user corresponding to the email.

. `login(username: string, password: string)`: +
A method, which is going to use the previous method, to check that the username and password match the form input and then fill the `AuthService`.

. `logout()`: +
This is going to be used to reset the `AuthService` and log out the user.

Also, we see the first use of `pipe` and `map`: +
`pipe` allows us to execute a chain of functions, then `map` allows us to return the single visitor instead of all the parameters that the server will send us.

[source, typescript]
----
import { map, tap } from 'rxjs/operators';
import { Injectable } from '@angular/core';
import { Observable } from 'rxjs';
import { Visitor, FilterVisitor, Pageable } from 'src/app/shared/backendModels/interfaces';
import { HttpClient } from '@angular/common/http';
import { environment } from 'src/environments/environment';
import { AuthService } from 'src/app/core/authentication/auth.service';
import { Router } from '@angular/router';
import { MatSnackBar } from '@angular/material/snack-bar';

@Injectable({
  providedIn: 'root'
})
export class LoginService {

    private baseUrl = environment.baseUrlRestServices;
    constructor(private router: Router, private http: HttpClient, private authService: AuthService, public snackBar: MatSnackBar) { }

    getVisitorByUsername(username: string): Observable<Visitor> {
        const filters: FilterVisitor = new FilterVisitor();
        const pageable: Pageable = new Pageable();

        pageable.pageNumber = 0;
        pageable.pageSize = 1;
        pageable.sort= [];
        filters.username = username;
        filters.pageable = pageable;
        return this.http.post<VisitorArray>(`${this.baseUrl}` + '/visitormanagement/v1/visitor/search', filters)
       .pipe(
            map(visitors => visitors.content[0]),
        );
    }

    login(username: string, password: string): void {
      // Checks if given username and password are the ones aved in the database
      this.getVisitorByUsername(username).subscribe(
          (visitorFound) => {
              if (visitorFound.username == username && visitorFound.password == password) {
                  this.authService.setUserId(visitorFound.id);
                  this.authService.setLogged(true);
                  this.authService.setUser(visitorFound.username);
                  if (visitorFound.userType == false) {
                      this.authService.setRole('VISITOR');
                      this.router.navigate(['ViewQueue']);
                  } else {
                      this.authService.setLogged(false);
                      this.snackBar.open('access error', 'OK', {
                          duration: 2000,
                        });
                  }
              } else {
                  this.snackBar.open('access error', 'OK', {
                      duration: 2000,
                    });
              }
          },
          (err: any) => {
            this.snackBar.open('access error', 'OK', {
              duration: 2000,
            });
          },
      );
    }

    logout(): void {
        this.authService.setLogged(false);
        this.authService.setUser('');
        this.authService.setUserId(0);
        this.router.navigate(['FormLogin']);
    }
}
----

If you remember the devon4j tutorial, we used `Criteria` in order to filter and to search the DB. The `Criteria` require a pageable and you can add extra parameters to get specific results. In `getVisitorByUsername()` you can see the creation of a `FilterVisitor` corresponding to the `Criteria` in the back-end. This `FilterVisitor` gets a `Pageable` and a `username` and will return a single result as soon as the POST call is performed. That's why we return the first page and only a single result.

[NOTE]
== == 
For the tutorial we are only considering the visitor side of the application. That's why we `setLogged(false)` if it's `userType == true` (BOSS side).
== == 

Then we add to the `login-module.ts` and `LoginService`:

[source, typescript]
----
...
import { LoginService } from './services/login.service';

@NgModule({
  ...
  providers: [LoginService],
  ...
})
...
----

After that, we are going to add the `AuthGuard` and the `Auth` into the `shared/core-module.ts`. This will allow us to employ these two services when importing the core module avoiding having to provide these services in every component:

[source, typescript]
----
...
  providers: [
    HttpClientModule,
    AuthService,
    AuthGuardService,
  ],
...
----

You need to import these modules as well, as shown earlier.

Finally, we modify the `login.component.html` to send the form values to the `login.component.ts` like we did with the register form. Afterwards, we are going to modify the `register.components.ts`: When the visitor registers, we can log him in automatically to avoid any nuisances. Let's start with the `login.component.html`:

[source, html]
----
...
<form (ngSubmit)=""submitLogin(loginForm.form.value)"" #loginForm=""ngForm"" layout-padding>
...
----

As you can see, in the form we just added, the values to the `ngSubmit` allow us to call the method `submitLogin()` within the logic, sending the `loginForm.form.values` which are the form's input values. In the next step we are going to modify the `login.components.ts`, adding the `submitLogin()` method. This method calls the `LoginService`, providing the service with the necessary values received from the form (i.e. the `loginFormValues`).

[source, typescript]
----
...
import { LoginService } from './services/login.service';
...
export class LoginComponent implements OnInit {
  ...
  constructor(private router: Router, private loginService: LoginService) {
  }
  ...
  submitLogin(loginFormValues): void {
    this.loginService.login(loginFormValues.username, loginFormValues.password);
  }
}
----

Finally, in the `register.components.ts` we are going to inject the `LoginService` and use it to login the visitor after registering him. This will also send the user to the `ViewQueue`, which we will create and secure later in the tutorial.

[source, typescript]
----
import { LoginService } from '../form-login/components/login/services/login.service';
...
constructor(private registerService: RegisterService, private router: Router, public snackBar: MatSnackBar,
    private loginService: LoginService) { } 
...
  submitRegister(formValue): void {
    ...
    this.registerService.registerVisitor(visitor).subscribe(
      (visitorResult: Visitor) => {
        this.loginService.login(visitorResult.username, visitorResult.password);
      },
      ...
    );
  }
...
----

==  Finishing Touches

Now we only need to generate two more components (`header` and `view-queue`) and services (`AccessCodeService` and `QueueService`) in order to finish the implementation of our _JumpTheQueue_ app.

== Separating Header from Layout

By separating the header on top of the page from the layout, we enable the reuse of this component and reach a better separation of concerns across our application. To do this, we are going to generate a new component inside `angular/src/app/layout/header` via:

```
ng generate component layout/header
```

Now we are going to add it to the main view `app.component.html`:

[source, html]
----
...
  <div td-toolbar-content flex>
    <app-header layout-align=""center center"" layout=""row"" flex></app-header>
  </div> <!-- Header container-->
...
----

After adding the component to the header view (`app-header`), we are going to modify the HTML of the component (`header.component.html`) and the logic of the component (`header.component.ts`). As a first step, we are going to modify the HTML, adding an icon as a button, which checks whether or not the user is logged in via `*ngIf` by calling the `auth` service's `isLogged()` method. This will make the icon appear only if the user is logged in:

[source, html]
----
Jump The Queue
<span flex></span> 
<button mat-icon-button mdTooltip=""Log out"" (click)=onClickLogout() *ngIf=""authService.isLogged()"">
  <mat-icon>exit_to_app</mat-icon>
</button>
----

In the header logic (`header.component.ts`) we are simply going to inject the `AuthService` and `LoginService`, then we are going call `logout()` from `LoginService` in the `OnClickLogout()`. Finally, the `AuthService` is needed because it's being used by the HTML template to control if the user is logged in with `isLogged()`:

[source, typescript]
----
...
  constructor(private authService: AuthService, private loginService: LoginService) { }
...
  onClickLogout(): void {
    this.loginService.logout();
  }
...
----

Separating components will allow us to keep the code clean and easy to work with.

== `ViewQueue` Component

For the last view, we are going to learn how to use our Observables on the HTML template directly without having to `subscribe()` to them.

First, we are going to generate the component via:

```
ng generate component view-queue
```

After that, we are going to include the component in the `app-routing.module.ts`, also adding the guard, to only allow users that are `VISITOR` to see the component. It is important to insert the following code before `{ path: '**', redirectTo: '/FormLogin', pathMatch: 'full' }`:

[source, typescript]
----
...
const appRoutes: Routes = [
  ...
  { path: 'ViewQueue',
    component: ViewQueueComponent,
    canActivate: [AuthGuardService]}, // Redirect if url path is /ViewQueue, check if canActivate() with the AuthGuardService.
  ...
];
...
----

Now in order to make this view work, we are going to do these things:
  
. Add the `Queue` and `AccessCode` interface in our `angular/src/app/shared/backendModels/interfaces` and their corresponding filters.

. Generate the `QueueService` and `AccessCodeService` and add the necessary methods.

. Modify the `view-queue.component.html`.

. Modify the logic of the component `view-queue.component.ts`.

First, we are going to add the necessary interfaces. We modify `angular/src/app/shared/backendModels/interfaces.ts` and add the `FilterQueue`, `Queue`, `FilterAccessCode`, `AccessCode`, `QueueArray` and `AccessCodeArray`. These are going to be necessary in order to communicate with the back-end.

[source, typescript]
----
...
export class FilterAccessCode {
    pageable: Pageable;
    visitorId?: Number;
    endTime?: string;
}

export class FilterQueue {
    pageable: Pageable;
    active: boolean;
}

export class AccessCode {
    id?: number;
    ticketNumber: string;
    creationTime: string;
    startTime?: string;
    endTime?: string;
    visitorId: number;
    queueId: number;
    content: any;
}

export class Queue {
    id?: number;
    name: string;
    logo: string;
    currentNumber: string;
    attentionTime: string;
    minAttentionTime: string;
    active: boolean;
    customers: number;
    content: any;
}

export class QueueArray {
    content: Queue[];
}

export class AccessCodeArray {
    content: [{
        accessCode: AccessCode
    }];
}
...
----

== AccessCode and Queue Services

After this is done, we are going to generate the `AccessCodeService` and the `QueueService`:

```
ng generate service view-queue/services/Queue

ng generate service view-queue/services/AccessCode
```

Once this is done, we are going to modify them and add the necessary methods: 

- For the `AccessCodeService` we are going to need a full CRUD:

[source, typescript]
----
import { Injectable } from '@angular/core';
import { AuthService } from 'src/app/core/authentication/auth.service';
import { Router } from '@angular/router';
import { HttpClient } from '@angular/common/http';
import { AccessCode, Pageable, FilterAccessCode } from 'src/app/shared/backendModels/interfaces';
import { Observable } from 'rxjs';
import { environment } from 'src/environments/environment';
import { map } from 'rxjs/operators';

@Injectable({
  providedIn: 'root'
})
export class AccessCodeService {

  private baseUrl = environment.baseUrlRestServices;

  constructor(private router: Router, private http: HttpClient, private authService: AuthService) { }

  getCurrentlyAttendedAccessCode(): Observable<AccessCode> {
    const filters: FilterAccessCode = new FilterAccessCode();
    const pageable: Pageable = new Pageable();

    filters.endTime = null;
    pageable.pageNumber = 0;
    pageable.pageSize = 1;
    filters.pageable = pageable;
    return this.http.post<AccessCodeArray>(`${this.baseUrl}` + '/accesscodemanagement/v1/accesscode/cto/search', filters)
    .pipe(
        map(accesscodes => {
          if (!accesscodes.content[0]) {  // if theres no response it means theres noone in the queue
            return null;
          } else {
            if (accesscodes.content[0].accessCode.startTime != null) {
              // if start time is not null it means that hes being attended
              return accesscodes.content[0].accessCode;
            } else {
              // noone being attended
              return null;
            }
          }
        }),
     );
  }

  getVisitorAccessCode(visitorId: number): Observable<AccessCode> {
    const filters: FilterAccessCode = new FilterAccessCode();
    const pageable: Pageable = new Pageable();

    pageable.pageNumber = 0;
    pageable.pageSize = 1;
    filters.visitorId = visitorId;
    filters.pageable = pageable;
    return this.http.post<AccessCodeArray>(`${this.baseUrl}` + '/accesscodemanagement/v1/accesscode/cto/search', filters)
    .pipe(
      map(accesscodes => {
        if (accesscodes.content[0]) {
          return accesscodes.content[0].accessCode;
        } else {
          return null;
        }
      }),
    );
  }

  deleteAccessCode(codeAccessId: number) {
    this.http.delete<AccessCode>(`${this.baseUrl}` + '/accesscodemanagement/v1/accesscode/' + codeAccessId + '/').subscribe();
  }

  saveAccessCode(visitorId: number, queueId: number) {
    const accessCode: AccessCode = new AccessCode();
    accessCode.visitorId = visitorId;
    accessCode.queueId = queueId;
    return this.http.post<AccessCode>(`${this.baseUrl}` + '/accesscodemanagement/v1/accesscode/', accessCode);
  }
}
----

In the methods `getCurrentlyAttendedAccessCode` and `getVisitorAccessCode` we can see the use of `Pageable` and `FilterAccessCode` to match the `Criteria` in the back-end like we explained in previous steps. In this case, the `getVisitorAccessCode` method will be used to see if the visitor has an `AccessCode` and the `getCurrentlyAttendedAccessCode` is going to recover the first `AccessCode` of the queue.

- For the `QueueService` we are only going to need to find the active queue:

[source, typescript]
----
import { Injectable } from '@angular/core';
import { HttpClient } from '@angular/common/http';
import { Router } from '@angular/router';
import { Observable } from 'rxjs';
import { Queue, FilterQueue, Pageable } from 'src/app/shared/backendModels/interfaces';
import { environment } from 'src/environments/environment';
import { map } from 'rxjs/operators';

@Injectable({
  providedIn: 'root'
})
export class QueueService {

  private baseUrl = environment.baseUrlRestServices;

  constructor(private router: Router, private http: HttpClient) { }

  getActiveQueue(): Observable<Queue> {
    const filters: FilterQueue = new FilterQueue();
    filters.active = true;
    const pageable: Pageable = new Pageable();
    pageable.pageNumber = 0;
    pageable.pageSize = 1;
    pageable.sort = [];
    filters.pageable = pageable;
    return this.http.post<QueueArray>(`${this.baseUrl}` + '/queuemanagement/v1/queue/search', filters)
    .pipe(
         map(queues => queues.content[0]),
     );
  }
}
----

Now we are going to create the template `view-queue.component.html` (which will use this data) and we will also introduce a new concept: `async` pipes in templates.

[source, html]
----
<td-layout *ngIf=""{
  accessCodeAttended: accessCodeAttended$ | async,
  accessCodeVisitor: accessCodeVisitor$  | async,
  queue: queue$ | async
} as data;"">
  <div *ngIf=""data.queue"">
    <mat-card>
    <img mat-card-image src=""assets/images/jumptheq.png"">
    
      <div *ngIf=""data.accessCodeVisitor"">
        <div class=""text-center row"">
          <h1 style=""margin-bottom:10px;"" class=""text-left text-xl push-md"">Your Number:</h1> 
        </div>
        <div class=""text-center row"">
          <h1 style=""font-size: 75px; margin:0px;"" class=""text-center text-xxl push-left-md"">{{data.accessCodeVisitor.ticketNumber}}</h1> 
        </div>
        <div style=""border-bottom: 2px solid black;"" class=""row"">
          <p class=""push-left-md"">Currently estimate time: 10:00:00</p>
        </div>
      </div>
      <div class=""text-center"">
        <div class=""text-center row"">
          <h1 style=""margin-bottom:10px;"" class=""text-left text-xl push-md"">Currently Being Attended:</h1> 
        </div>
        <div class=""row"">
          <h1 style=""font-size: 100px"" class=""text-center text-xxl push-lg"">{{data.accessCodeAttended?.ticketNumber}}</h1> 
        </div>
      </div>
      <div style=""border-top: 2px solid black;"" class=""pad-bottom-lg pad-top-lg text-center row"" *ngIf=""data.accessCodeVisitor == null"">
        <button mat-raised-button (click)=""onJoinQueue(data.queue.id)"" color=""primary"" class=""text-upper"">Join the queue</button> 
      </div>
    </mat-card>
    <div *ngIf=""data.accessCodeVisitor"" style=""margin: 8px;"" class=""row text-right"">
        <button mat-raised-button (click)=""onLeaveQueue(data.accessCodeVisitor.id)"" color=""primary"" class=""text-upper"">Leave the queue</button> 
    </div>
  </div>
  <div *ngIf=""data.queue == null || (data.queue !==  null && data.queue.active == false)"" class=""row"">
    <h1 style=""font-size: 50px"" class=""text-center text-xxl push-lg"">The queue is not active try again later</h1> 
  </div>
</td-layout>
----

If you watch closely, the starting `td-layout` has an `*ngIf` inside it. This `*ngIf` allows us to asynchronously pipe the observables that we will assign in the next steps. This solution avoids having to use `subscribe()` (as it subscribes automatically) and -- as a result -- we don't have to worry about where to `unsubscribe()` from the observables.

In this HTML, we give `*ngif` another use: We use it to hide certain panels. Using `accessCodeVisitor`, we hide the ticket number panel and the ""leave the queue""-button and show the button to join the queue. On the contrary we can hide the ticket number and the ""leave the queue""-button and only show the ""join the queue""-button.

[NOTE]
== == 
In this case, since we are using HTTP and the calls are finite, there wouldn't be any problems if you don't `unsubscribe()` from their corresponding observables. However, if -- for example -- we use an observable to keep track of an input and `subscribe()` to it but not controlling the `unsubscribe()` method, the app could end up containing a memory leak. This is because -- every time we visit the component with the input -- it is going to create another subscription without unsubscribing from the last one.
== == 

Finally, to adapt the `async` pipe, the `ngOnInit()` method inside `view-queue.component.ts` now does not subscribe to the observable. In its place, we equal the queue variable directly to the observable, so we can load it using `*ngIf`.

[source, typescript]
----
import { Component, OnInit } from '@angular/core';
import { AccessCode, Queue } from '../shared/backendModels/interfaces';
import { Observable, timer } from 'rxjs';
import { AccessCodeService } from './services/access-code.service';
import { switchMap } from 'rxjs/operators';
import { AuthService } from '../core/authentication/auth.service';
import { QueueService } from './services/queue.service';

@Component({
  selector: 'app-view-queue',
  templateUrl: './view-queue.component.html',
  styleUrls: ['./view-queue.component.scss']
})
export class ViewQueueComponent implements OnInit {

  accessCodeAttended$: Observable<AccessCode>;
  accessCodeVisitor$: Observable<AccessCode>;
  queue$: Observable<Queue>;

  constructor(private accessCodeService: AccessCodeService, private queueService: QueueService, private authService: AuthService) { }

  ngOnInit() {
     // Every minute we are going to update accessCodeAttended$ starting instantly
    this.accessCodeAttended$ = timer(0, 60000).pipe(
      // we switchMap and give it the value necesary from the accessCodeService
      switchMap(() => {
        return this.accessCodeService.getCurrentlyAttendedAccessCode();
      })
    );
    this.accessCodeVisitor$ = this.accessCodeService.getVisitorAccessCode(this.authService.getUserId());
    this.queue$ = this.queueService.getActiveQueue();
  }

  onJoinQueue(queueId: number): void {
    this.accessCodeVisitor$ = this.accessCodeService.saveAccessCode(this.authService.getUserId(), queueId);
  }

  onLeaveQueue(accessCodeId: number): void {
    this.accessCodeService.deleteAccessCode(accessCodeId);
    this.accessCodeVisitor$ = null;
  }
}
----

In this last component we assign the `Observables` when the component is initiated. After that, when clicking the ""join the queue""-button, we assign a new `Observable` called `AccessCode` to the `accessCodeVisitor$`. Finally, when we leave the queue, we delete the `AccessCode` and set the `accessCodeVisitor` to null. Since we are using an `async` pipe, every time we modify the status of the `Observables`, they are going to update the template.

image::images/devon4ng/3.BuildYourOwn/withCodeAccess.png[Queue Page with Access Code, 250]

image::images/devon4ng/3.BuildYourOwn/withoutCodeAccess.png[Queue Page without Access Code, 250]

This is all on how to build your own devon4ng application. Now it's up to you to add features, change styles and do everything you can imagine doing with this app.

As a final step to complete the tutorial, however, we are going to run the app outside of our local machine by deploying it.

'''
*Next Chapter*: link:devon4ng-deployment[Deploy your devon4ng App]
",12408,False,2118.623928307715,median
"// Copyright 2014 PDFium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
 
// Original code copyright 2014 Foxit Software Inc. http://www.foxitsoftware.com

#include ""../../../include/fpdfapi/fpdf_page.h""
#include ""../../../include/fpdfapi/fpdf_module.h""
#include ""../../../include/fxcodec/fx_codec.h""
#include ""pageint.h""
#include <limits.h>
void sRGB_to_AdobeCMYK(FX_FLOAT R, FX_FLOAT G, FX_FLOAT B, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k)
{
    c = 1.0f - R;
    m = 1.0f - G;
    y = 1.0f - B;
    k = c;
    if (m < k) {
        k = m;
    }
    if (y < k) {
        k = y;
    }
}
CPDF_DeviceCS::CPDF_DeviceCS(int family)
{
    m_Family = family;
    if (m_Family == PDFCS_DEVICERGB) {
        m_nComponents = 3;
    } else if (m_Family == PDFCS_DEVICEGRAY) {
        m_nComponents = 1;
    } else {
        m_nComponents = 4;
    }
}
FX_BOOL CPDF_DeviceCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
{
    if (m_Family == PDFCS_DEVICERGB) {
        R = pBuf[0];
        if (R < 0) {
            R = 0;
        } else if (R > 1) {
            R = 1;
        }
        G = pBuf[1];
        if (G < 0) {
            G = 0;
        } else if (G > 1) {
            G = 1;
        }
        B = pBuf[2];
        if (B < 0) {
            B = 0;
        } else if (B > 1) {
            B = 1;
        }
    } else if (m_Family == PDFCS_DEVICEGRAY) {
        R = *pBuf;
        if (R < 0) {
            R = 0;
        } else if (R > 1) {
            R = 1;
        }
        G = B = R;
    } else if (m_Family == PDFCS_DEVICECMYK) {
        if (!m_dwStdConversion) {
            AdobeCMYK_to_sRGB(pBuf[0], pBuf[1], pBuf[2], pBuf[3], R, G, B);
        } else {
            FX_FLOAT k = pBuf[3];
            R = 1.0f - FX_MIN(1.0f, pBuf[0] + k);
            G = 1.0f - FX_MIN(1.0f, pBuf[1] + k);
            B = 1.0f - FX_MIN(1.0f, pBuf[2] + k);
        }
    } else {
        ASSERT(m_Family == PDFCS_PATTERN);
        R = G = B = 0;
        return FALSE;
    }
    return TRUE;
}
FX_BOOL CPDF_DeviceCS::v_GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const
{
    if (m_Family != PDFCS_DEVICECMYK) {
        return FALSE;
    }
    c = pBuf[0];
    m = pBuf[1];
    y = pBuf[2];
    k = pBuf[3];
    return TRUE;
}
FX_BOOL CPDF_DeviceCS::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
{
    if (m_Family == PDFCS_DEVICERGB) {
        pBuf[0] = R;
        pBuf[1] = G;
        pBuf[2] = B;
        return TRUE;
    } else if (m_Family == PDFCS_DEVICEGRAY) {
        if (R == G && R == B) {
            *pBuf = R;
            return TRUE;
        } else {
            return FALSE;
        }
    } else if (m_Family == PDFCS_DEVICECMYK) {
        sRGB_to_AdobeCMYK(R, G, B, pBuf[0], pBuf[1], pBuf[2], pBuf[3]);
        return TRUE;
    }
    return FALSE;
}
FX_BOOL CPDF_DeviceCS::v_SetCMYK(FX_FLOAT* pBuf, FX_FLOAT c, FX_FLOAT m, FX_FLOAT y, FX_FLOAT k) const
{
    if (m_Family == PDFCS_DEVICERGB) {
        AdobeCMYK_to_sRGB(c, m, y, k, pBuf[0], pBuf[1], pBuf[2]);
        return TRUE;
    } else if (m_Family == PDFCS_DEVICEGRAY) {
        return FALSE;
    } else if (m_Family == PDFCS_DEVICECMYK) {
        pBuf[0] = c;
        pBuf[1] = m;
        pBuf[2] = y;
        pBuf[3] = k;
        return TRUE;
    }
    return FALSE;
}
static void ReverseRGB(FX_LPBYTE pDestBuf, FX_LPCBYTE pSrcBuf, int pixels)
{
    if (pDestBuf == pSrcBuf)
        for (int i = 0; i < pixels; i ++) {
            FX_BYTE temp = pDestBuf[2];
            pDestBuf[2] = pDestBuf[0];
            pDestBuf[0] = temp;
            pDestBuf += 3;
        }
    else
        for (int i = 0; i < pixels; i ++) {
            *pDestBuf ++ = pSrcBuf[2];
            *pDestBuf ++ = pSrcBuf[1];
            *pDestBuf ++ = pSrcBuf[0];
            pSrcBuf += 3;
        }
}
void CPDF_DeviceCS::TranslateImageLine(FX_LPBYTE pDestBuf, FX_LPCBYTE pSrcBuf, int pixels, int image_width, int image_height, FX_BOOL bTransMask) const
{
    if (bTransMask && m_Family == PDFCS_DEVICECMYK) {
        for (int i = 0; i < pixels; i ++) {
            int k = 255 - pSrcBuf[3];
            pDestBuf[0] = ((255 - pSrcBuf[0]) * k) / 255;
            pDestBuf[1] = ((255 - pSrcBuf[1]) * k) / 255;
            pDestBuf[2] = ((255 - pSrcBuf[2]) * k) / 255;
            pDestBuf += 3;
            pSrcBuf += 4;
        }
        return;
    }
    if (m_Family == PDFCS_DEVICERGB) {
        ReverseRGB(pDestBuf, pSrcBuf, pixels);
    } else if (m_Family == PDFCS_DEVICEGRAY) {
        for (int i = 0; i < pixels; i ++) {
            *pDestBuf ++ = pSrcBuf[i];
            *pDestBuf ++ = pSrcBuf[i];
            *pDestBuf ++ = pSrcBuf[i];
        }
    } else {
        for (int i = 0; i < pixels; i ++) {
            if (!m_dwStdConversion) {
                AdobeCMYK_to_sRGB1(pSrcBuf[0], pSrcBuf[1], pSrcBuf[2], pSrcBuf[3], pDestBuf[2], pDestBuf[1], pDestBuf[0]);
            } else {
                FX_BYTE k = pSrcBuf[3];
                pDestBuf[2] = 255 - FX_MIN(255, pSrcBuf[0] + k);
                pDestBuf[1] = 255 - FX_MIN(255, pSrcBuf[1] + k);
                pDestBuf[0] = 255 - FX_MIN(255, pSrcBuf[2] + k);
            }
            pSrcBuf += 4;
            pDestBuf += 3;
        }
    }
}
const FX_BYTE g_sRGBSamples1[] = {
    0,   3,   6,  10,  13,  15,  18,  20,  22,  23,  25,  27,  28,  30,  31,  32,
    34,  35,  36,  37,  38,  39,  40,  41,  42,  43,  44,  45,  46,  47,  48,  49,
    49,  50,  51,  52,  53,  53,  54,  55,  56,  56,  57,  58,  58,  59,  60,  61,
    61,  62,  62,  63,  64,  64,  65,  66,  66,  67,  67,  68,  68,  69,  70,  70,
    71,  71,  72,  72,  73,  73,  74,  74,  75,  76,  76,  77,  77,  78,  78,  79,
    79,  79,  80,  80,  81,  81,  82,  82,  83,  83,  84,  84,  85,  85,  85,  86,
    86,  87,  87,  88,  88,  88,  89,  89,  90,  90,  91,  91,  91,  92,  92,  93,
    93,  93,  94,  94,  95,  95,  95,  96,  96,  97,  97,  97,  98,  98,  98,  99,
    99,  99, 100, 100, 101, 101, 101, 102, 102, 102, 103, 103, 103, 104, 104, 104,
    105, 105, 106, 106, 106, 107, 107, 107, 108, 108, 108, 109, 109, 109, 110, 110,
    110, 110, 111, 111, 111, 112, 112, 112, 113, 113, 113, 114, 114, 114, 115, 115,
    115, 115, 116, 116, 116, 117, 117, 117, 118, 118, 118, 118, 119, 119, 119, 120,
};
const FX_BYTE g_sRGBSamples2[] = {
    120, 121, 122, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136,
    137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 148, 149, 150, 151,
    152, 153, 154, 155, 155, 156, 157, 158, 159, 159, 160, 161, 162, 163, 163, 164,
    165, 166, 167, 167, 168, 169, 170, 170, 171, 172, 173, 173, 174, 175, 175, 176,
    177, 178, 178, 179, 180, 180, 181, 182, 182, 183, 184, 185, 185, 186, 187, 187,
    188, 189, 189, 190, 190, 191, 192, 192, 193, 194, 194, 195, 196, 196, 197, 197,
    198, 199, 199, 200, 200, 201, 202, 202, 203, 203, 204, 205, 205, 206, 206, 207,
    208, 208, 209, 209, 210, 210, 211, 212, 212, 213, 213, 214, 214, 215, 215, 216,
    216, 217, 218, 218, 219, 219, 220, 220, 221, 221, 222, 222, 223, 223, 224, 224,
    225, 226, 226, 227, 227, 228, 228, 229, 229, 230, 230, 231, 231, 232, 232, 233,
    233, 234, 234, 235, 235, 236, 236, 237, 237, 238, 238, 238, 239, 239, 240, 240,
    241, 241, 242, 242, 243, 243, 244, 244, 245, 245, 246, 246, 246, 247, 247, 248,
    248, 249, 249, 250, 250, 251, 251, 251, 252, 252, 253, 253, 254, 254, 255, 255,
};
static void XYZ_to_sRGB(FX_FLOAT X, FX_FLOAT Y, FX_FLOAT Z, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B)
{
    FX_FLOAT R1 = 3.2410f * X - 1.5374f * Y - 0.4986f * Z;
    FX_FLOAT G1 = -0.9692f * X + 1.8760f * Y + 0.0416f * Z;
    FX_FLOAT B1 =  0.0556f * X - 0.2040f * Y + 1.0570f * Z;
    if (R1 > 1) {
        R1 = 1;
    }
    if (R1 < 0) {
        R1 = 0;
    }
    if (G1 > 1) {
        G1 = 1;
    }
    if (G1 < 0) {
        G1 = 0;
    }
    if (B1 > 1) {
        B1 = 1;
    }
    if (B1 < 0) {
        B1 = 0;
    }
    int scale = (int)(R1 * 1023);
    if (scale < 0) {
        scale = 0;
    }
    if (scale < 192) {
        R = (g_sRGBSamples1[scale] / 255.0f);
    } else {
        R = (g_sRGBSamples2[scale / 4 - 48] / 255.0f);
    }
    scale = (int)(G1 * 1023);
    if (scale < 0) {
        scale = 0;
    }
    if (scale < 192) {
        G = (g_sRGBSamples1[scale] / 255.0f);
    } else {
        G = (g_sRGBSamples2[scale / 4 - 48] / 255.0f);
    }
    scale = (int)(B1 * 1023);
    if (scale < 0) {
        scale = 0;
    }
    if (scale < 192) {
        B = (g_sRGBSamples1[scale] / 255.0f);
    } else {
        B = (g_sRGBSamples2[scale / 4 - 48] / 255.0f);
    }
}
class CPDF_CalGray : public CPDF_ColorSpace
{
public:
    CPDF_CalGray();
    virtual FX_BOOL		v_Load(CPDF_Document* pDoc, CPDF_Array* pArray);
    virtual FX_BOOL		GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const;
    virtual void		TranslateImageLine(FX_LPBYTE pDestBuf, FX_LPCBYTE pSrcBuf, int pixels, int image_width, int image_height, FX_BOOL bTransMask = FALSE) const;
    FX_BOOL				SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const;
    FX_FLOAT			m_WhitePoint[3];
    FX_FLOAT			m_BlackPoint[3];
    FX_FLOAT			m_Gamma;
};
CPDF_CalGray::CPDF_CalGray()
{
    m_Family = PDFCS_CALGRAY;
    m_nComponents = 1;
}
FX_BOOL CPDF_CalGray::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
{
    CPDF_Dictionary* pDict = pArray->GetDict(1);
    CPDF_Array* pParam = pDict->GetArray(FX_BSTRC(""WhitePoint""));
    int i;
    for (i = 0; i < 3; i ++) {
        m_WhitePoint[i] = pParam ? pParam->GetNumber(i) : 0;
    }
    pParam = pDict->GetArray(FX_BSTRC(""BlackPoint""));
    for (i = 0; i < 3; i ++) {
        m_BlackPoint[i] = pParam ? pParam->GetNumber(i) : 0;
    }
    m_Gamma = pDict->GetNumber(FX_BSTRC(""Gamma""));
    if (m_Gamma == 0) {
        m_Gamma = 1.0f;
    }
    return TRUE;
}
FX_BOOL CPDF_CalGray::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
{
    R = G = B = *pBuf;
    return TRUE;
}
FX_BOOL CPDF_CalGray::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
{
    if (R == G && R == B) {
        *pBuf = R;
        return TRUE;
    } else {
        return FALSE;
    }
}
void CPDF_CalGray::TranslateImageLine(FX_LPBYTE pDestBuf, FX_LPCBYTE pSrcBuf, int pixels, int image_width, int image_height, FX_BOOL bTransMask) const
{
    for (int i = 0; i < pixels; i ++) {
        *pDestBuf ++ = pSrcBuf[i];
        *pDestBuf ++ = pSrcBuf[i];
        *pDestBuf ++ = pSrcBuf[i];
    }
}
class CPDF_CalRGB : public CPDF_ColorSpace
{
public:
    CPDF_CalRGB();
    virtual FX_BOOL		v_Load(CPDF_Document* pDoc, CPDF_Array* pArray);
    virtual FX_BOOL		GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const;
    virtual void		TranslateImageLine(FX_LPBYTE pDestBuf, FX_LPCBYTE pSrcBuf, int pixels, int image_width, int image_height, FX_BOOL bTransMask = FALSE) const;
    FX_BOOL				SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const;
    FX_FLOAT			m_WhitePoint[3];
    FX_FLOAT			m_BlackPoint[3];
    FX_FLOAT			m_Gamma[3];
    FX_FLOAT			m_Matrix[9];
    FX_BOOL				m_bGamma, m_bMatrix;
};
CPDF_CalRGB::CPDF_CalRGB()
{
    m_Family = PDFCS_CALRGB;
    m_nComponents = 3;
}
FX_BOOL CPDF_CalRGB::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
{
    CPDF_Dictionary* pDict = pArray->GetDict(1);
    CPDF_Array* pParam = pDict->GetArray(FX_BSTRC(""WhitePoint""));
    int i;
    for (i = 0; i < 3; i ++) {
        m_WhitePoint[i] = pParam ? pParam->GetNumber(i) : 0;
    }
    pParam = pDict->GetArray(FX_BSTRC(""BlackPoint""));
    for (i = 0; i < 3; i ++) {
        m_BlackPoint[i] = pParam ? pParam->GetNumber(i) : 0;
    }
    pParam = pDict->GetArray(FX_BSTRC(""Gamma""));
    if (pParam) {
        m_bGamma = TRUE;
        for (i = 0; i < 3; i ++) {
            m_Gamma[i] = pParam->GetNumber(i);
        }
    } else {
        m_bGamma = FALSE;
    }
    pParam = pDict->GetArray(FX_BSTRC(""Matrix""));
    if (pParam) {
        m_bMatrix = TRUE;
        for (i = 0; i < 9; i ++) {
            m_Matrix[i] = pParam->GetNumber(i);
        }
    } else {
        m_bMatrix = FALSE;
    }
    return TRUE;
}
FX_BOOL CPDF_CalRGB::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
{
    FX_FLOAT A_ = pBuf[0];
    FX_FLOAT B_ = pBuf[1];
    FX_FLOAT C_ = pBuf[2];
    if (m_bGamma) {
        A_ = (FX_FLOAT)FXSYS_pow(A_, m_Gamma[0]);
        B_ = (FX_FLOAT)FXSYS_pow(B_, m_Gamma[1]);
        C_ = (FX_FLOAT)FXSYS_pow(C_, m_Gamma[2]);
    }
    FX_FLOAT X, Y, Z;
    if (m_bMatrix) {
        X = m_Matrix[0] * A_ + m_Matrix[3] * B_ + m_Matrix[6] * C_;
        Y = m_Matrix[1] * A_ + m_Matrix[4] * B_ + m_Matrix[7] * C_;
        Z = m_Matrix[2] * A_ + m_Matrix[5] * B_ + m_Matrix[8] * C_;
    } else {
        X = A_;
        Y = B_;
        Z = C_;
    }
    XYZ_to_sRGB(X, Y, Z, R, G, B);
    return TRUE;
}
FX_BOOL CPDF_CalRGB::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
{
    pBuf[0] = R;
    pBuf[1] = G;
    pBuf[2] = B;
    return TRUE;
}
void CPDF_CalRGB::TranslateImageLine(FX_LPBYTE pDestBuf, FX_LPCBYTE pSrcBuf, int pixels, int image_width, int image_height, FX_BOOL bTransMask) const
{
    if (bTransMask) {
        FX_FLOAT Cal[3];
        FX_FLOAT R, G, B;
        for(int i = 0; i < pixels; i ++) {
            Cal[0] = ((FX_FLOAT)pSrcBuf[2]) / 255;
            Cal[1] = ((FX_FLOAT)pSrcBuf[1]) / 255;
            Cal[2] = ((FX_FLOAT)pSrcBuf[0]) / 255;
            GetRGB(Cal, R, G, B);
            pDestBuf[0] = FXSYS_round(B * 255);
            pDestBuf[1] = FXSYS_round(G * 255);
            pDestBuf[2] = FXSYS_round(R * 255);
            pSrcBuf += 3;
            pDestBuf += 3;
        }
    }
    ReverseRGB(pDestBuf, pSrcBuf, pixels);
}
class CPDF_LabCS : public CPDF_ColorSpace
{
public:
    CPDF_LabCS()
    {
        m_Family = PDFCS_LAB;
        m_nComponents = 3;
    }
    virtual FX_BOOL		v_Load(CPDF_Document* pDoc, CPDF_Array* pArray);
    virtual void		GetDefaultValue(int iComponent, FX_FLOAT& value, FX_FLOAT& min, FX_FLOAT& max) const;
    virtual FX_BOOL		GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const;
    FX_BOOL		SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const;
    virtual void		TranslateImageLine(FX_LPBYTE pDestBuf, FX_LPCBYTE pSrcBuf, int pixels, int image_width, int image_height, FX_BOOL bTransMask = FALSE) const;
    FX_FLOAT	m_WhitePoint[3];
    FX_FLOAT	m_BlackPoint[3];
    FX_FLOAT	m_Ranges[4];
};
FX_BOOL CPDF_LabCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
{
    CPDF_Dictionary* pDict = pArray->GetDict(1);
    CPDF_Array* pParam = pDict->GetArray(FX_BSTRC(""WhitePoint""));
    int i;
    for (i = 0; i < 3; i ++) {
        m_WhitePoint[i] = pParam ? pParam->GetNumber(i) : 0;
    }
    pParam = pDict->GetArray(FX_BSTRC(""BlackPoint""));
    for (i = 0; i < 3; i ++) {
        m_BlackPoint[i] = pParam ? pParam->GetNumber(i) : 0;
    }
    pParam = pDict->GetArray(FX_BSTRC(""Range""));
    const FX_FLOAT def_ranges[4] = { -100 * 1.0f, 100 * 1.0f, -100 * 1.0f, 100 * 1.0f};
    for (i = 0; i < 4; i ++) {
        m_Ranges[i] = pParam ? pParam->GetNumber(i) : def_ranges[i];
    }
    return TRUE;
}
void CPDF_LabCS::GetDefaultValue(int iComponent, FX_FLOAT& value, FX_FLOAT& min, FX_FLOAT& max) const
{
    value = 0;
    if (iComponent == 0) {
        min = 0;
        max = 100 * 1.0f;
    } else {
        min = m_Ranges[iComponent * 2 - 2];
        max = m_Ranges[iComponent * 2 - 1];
        if (value < min) {
            value = min;
        } else if (value > max) {
            value = max;
        }
    }
}
FX_BOOL CPDF_LabCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
{
    FX_FLOAT Lstar = pBuf[0];
    FX_FLOAT astar = pBuf[1];
    FX_FLOAT bstar = pBuf[2];
    FX_FLOAT M = (Lstar + 16.0f) / 116.0f;
    FX_FLOAT L = M + astar / 500.0f;
    FX_FLOAT N = M - bstar / 200.0f;
    FX_FLOAT X, Y, Z;
    if (L < 0.2069f) {
        X = 0.957f * 0.12842f * (L - 0.1379f);
    } else {
        X = 0.957f * L * L * L;
    }
    if (M < 0.2069f) {
        Y = 0.12842f * (M - 0.1379f);
    } else {
        Y = M * M * M;
    }
    if (N < 0.2069f) {
        Z = 1.0889f * 0.12842f * (N - 0.1379f);
    } else {
        Z = 1.0889f * N * N * N;
    }
    XYZ_to_sRGB(X, Y, Z, R, G, B);
    return TRUE;
}
FX_BOOL CPDF_LabCS::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
{
    return FALSE;
}
void CPDF_LabCS::TranslateImageLine(FX_LPBYTE pDestBuf, FX_LPCBYTE pSrcBuf, int pixels, int image_width, int image_height, FX_BOOL bTransMask) const
{
    for (int i = 0; i < pixels; i ++) {
        FX_FLOAT lab[3];
        FX_FLOAT R, G, B;
        lab[0] = (pSrcBuf[0] * 100 / 255.0f);
        lab[1] = (FX_FLOAT)(pSrcBuf[1] - 128);
        lab[2] = (FX_FLOAT)(pSrcBuf[2] - 128);
        GetRGB(lab, R, G, B);
        pDestBuf[0] = (FX_INT32)(B * 255);
        pDestBuf[1] = (FX_INT32)(G * 255);
        pDestBuf[2] = (FX_INT32)(R * 255);
        pDestBuf += 3;
        pSrcBuf += 3;
    }
}
CPDF_IccProfile::CPDF_IccProfile(FX_LPCBYTE pData, FX_DWORD dwSize, int nComponents)
{
    m_bsRGB = nComponents == 3 && dwSize == 3144 && FXSYS_memcmp32(pData + 0x190, ""sRGB IEC61966-2.1"", 17) == 0;
    m_pTransform = NULL;
    if (!m_bsRGB && CPDF_ModuleMgr::Get()->GetIccModule()) {
        m_pTransform = CPDF_ModuleMgr::Get()->GetIccModule()->CreateTransform_sRGB(pData, dwSize, nComponents);
    }
}
CPDF_IccProfile::~CPDF_IccProfile()
{
    if (m_pTransform) {
        CPDF_ModuleMgr::Get()->GetIccModule()->DestroyTransform(m_pTransform);
    }
}
class CPDF_ICCBasedCS : public CPDF_ColorSpace
{
public:
    CPDF_ICCBasedCS();
    virtual ~CPDF_ICCBasedCS();
    virtual FX_BOOL		v_Load(CPDF_Document* pDoc, CPDF_Array* pArray);
    void				GetDefaultValue(int i, FX_FLOAT& min, FX_FLOAT& max) const
    {
        min = m_pRanges[i * 2];
        max = m_pRanges[i * 2 + 1];
    }
    virtual FX_BOOL		GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const;
    FX_BOOL				v_GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const;
    FX_BOOL				SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const;
    virtual void		EnableStdConversion(FX_BOOL bEnabled);
    virtual void		TranslateImageLine(FX_LPBYTE pDestBuf, FX_LPCBYTE pSrcBuf, int pixels, int image_width, int image_height, FX_BOOL bTransMask = FALSE) const;
    FX_FLOAT*		m_pRanges;
    CPDF_IccProfile*	m_pProfile;
    CPDF_ColorSpace*	m_pAlterCS;
    FX_LPBYTE			m_pCache;
    FX_BOOL				m_bOwn;
};
CPDF_ICCBasedCS::CPDF_ICCBasedCS()
{
    m_pAlterCS = NULL;
    m_pProfile = NULL;
    m_Family = PDFCS_ICCBASED;
    m_pCache = NULL;
    m_pRanges = NULL;
    m_bOwn = FALSE;
}
CPDF_ICCBasedCS::~CPDF_ICCBasedCS()
{
    if (m_pCache) {
        FX_Free(m_pCache);
    }
    if (m_pRanges) {
        FX_Free(m_pRanges);
    }
    if (m_pAlterCS && m_bOwn) {
        m_pAlterCS->ReleaseCS();
    }
    if (m_pProfile && m_pDocument) {
        m_pDocument->GetPageData()->ReleaseIccProfile(NULL, m_pProfile);
    }
}
FX_BOOL CPDF_ICCBasedCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
{
    CPDF_Stream* pStream = pArray->GetStream(1);
    if (pStream == NULL) {
        return FALSE;
    }
    CPDF_Dictionary* pDict = pStream->GetDict();
    m_nComponents = pDict ? pDict->GetInteger(FX_BSTRC(""N"")) : 0;
    if (m_nComponents <= 0 || m_nComponents > (1 << 16)) {
        return FALSE;
    }
    CPDF_Array* pRanges = pDict->GetArray(FX_BSTRC(""Range""));
    m_pRanges = FX_Alloc(FX_FLOAT, m_nComponents * 2);
    for (int i = 0; i < m_nComponents * 2; i ++) {
        if (pRanges) {
            m_pRanges[i] = pRanges->GetNumber(i);
        } else if (i % 2) {
            m_pRanges[i] = 1.0f;
        } else {
            m_pRanges[i] = 0;
        }
    }
    m_pProfile = pDoc->LoadIccProfile(pStream, m_nComponents);
    if (!m_pProfile) {
        return FALSE;
    }
    if (m_pProfile->m_pTransform == NULL) {
        CPDF_Object* pAlterCSObj = pDict ? pDict->GetElementValue(FX_BSTRC(""Alternate"")) : NULL;
        if (pAlterCSObj) {
            CPDF_ColorSpace* alter_cs = CPDF_ColorSpace::Load(pDoc, pAlterCSObj);
            if (alter_cs) {
                if (alter_cs->CountComponents() > m_nComponents) {
                    alter_cs->ReleaseCS();
                } else {
                    m_pAlterCS = alter_cs;
                    m_bOwn = TRUE;
                }
            }
        }
        if (!m_pAlterCS) {
            if (m_nComponents == 3) {
                m_pAlterCS = GetStockCS(PDFCS_DEVICERGB);
            } else if (m_nComponents == 4) {
                m_pAlterCS = GetStockCS(PDFCS_DEVICECMYK);
            } else {
                m_pAlterCS = GetStockCS(PDFCS_DEVICEGRAY);
            }
        }
    }
    return TRUE;
}
FX_BOOL CPDF_ICCBasedCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
{
    if (m_pProfile && m_pProfile->m_bsRGB) {
        R = pBuf[0];
        G = pBuf[1];
        B = pBuf[2];
        return TRUE;
    }
    ICodec_IccModule *pIccModule = CPDF_ModuleMgr::Get()->GetIccModule();
    if (m_pProfile->m_pTransform == NULL || pIccModule == NULL) {
        if (m_pAlterCS) {
            m_pAlterCS->GetRGB(pBuf, R, G, B);
        } else {
            R = G = B = 0.0f;
        }
        return TRUE;
    }
    FX_FLOAT rgb[3];
    pIccModule->SetComponents(m_nComponents);
    pIccModule->Translate(m_pProfile->m_pTransform, pBuf, rgb);
    R = rgb[0];
    G = rgb[1];
    B = rgb[2];
    return TRUE;
}
FX_BOOL CPDF_ICCBasedCS::v_GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const
{
    if (m_nComponents != 4) {
        return FALSE;
    }
    c = pBuf[0];
    m = pBuf[1];
    y = pBuf[2];
    k = pBuf[3];
    return TRUE;
}
FX_BOOL CPDF_ICCBasedCS::SetRGB(FX_FLOAT* pBuf, FX_FLOAT R, FX_FLOAT G, FX_FLOAT B) const
{
    return FALSE;
}
void CPDF_ICCBasedCS::EnableStdConversion(FX_BOOL bEnabled)
{
    CPDF_ColorSpace::EnableStdConversion(bEnabled);
    if (m_pAlterCS) {
        m_pAlterCS->EnableStdConversion(bEnabled);
    }
}
void CPDF_ICCBasedCS::TranslateImageLine(FX_LPBYTE pDestBuf, FX_LPCBYTE pSrcBuf, int pixels, int image_width, int image_height, FX_BOOL bTransMask) const
{
    if (m_pProfile->m_bsRGB) {
        ReverseRGB(pDestBuf, pSrcBuf, pixels);
    } else if (m_pProfile->m_pTransform) {
        int nMaxColors = 1;
        for (int i = 0; i < m_nComponents; i ++) {
            nMaxColors *= 52;
        }
        if (m_nComponents > 3 || image_width * image_height < nMaxColors * 3 / 2) {
            CPDF_ModuleMgr::Get()->GetIccModule()->TranslateScanline(m_pProfile->m_pTransform, pDestBuf, pSrcBuf, pixels);
        } else {
            if (m_pCache == NULL) {
                ((CPDF_ICCBasedCS*)this)->m_pCache = FX_Alloc(FX_BYTE, nMaxColors * 3);
                FX_LPBYTE temp_src = FX_Alloc(FX_BYTE, nMaxColors * m_nComponents);
                FX_LPBYTE pSrc = temp_src;
                for (int i = 0; i < nMaxColors; i ++) {
                    FX_DWORD color = i;
                    FX_DWORD order = nMaxColors / 52;
                    for (int c = 0; c < m_nComponents; c ++) {
                        *pSrc++ = (FX_BYTE)(color / order * 5);
                        color %= order;
                        order /= 52;
                    }
                }
                CPDF_ModuleMgr::Get()->GetIccModule()->TranslateScanline(m_pProfile->m_pTransform, m_pCache, temp_src, nMaxColors);
                FX_Free(temp_src);
            }
            for (int i = 0; i < pixels; i ++) {
                int index = 0;
                for (int c = 0; c < m_nComponents; c ++) {
                    index = index * 52 + (*pSrcBuf) / 5;
                    pSrcBuf ++;
                }
                index *= 3;
                *pDestBuf++ = m_pCache[index];
                *pDestBuf++ = m_pCache[index + 1];
                *pDestBuf++ = m_pCache[index + 2];
            }
        }
    } else if (m_pAlterCS) {
        m_pAlterCS->TranslateImageLine(pDestBuf, pSrcBuf, pixels, image_width, image_height);
    }
}
class CPDF_IndexedCS : public CPDF_ColorSpace
{
public:
    CPDF_IndexedCS();
    virtual ~CPDF_IndexedCS();
    virtual FX_BOOL		v_Load(CPDF_Document* pDoc, CPDF_Array* pArray);
    void				GetDefaultValue(int iComponent, FX_FLOAT& min, FX_FLOAT& max) const
    {
        min = 0;
        max = (FX_FLOAT)m_MaxIndex;
    }
    virtual FX_BOOL		GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const;
    virtual CPDF_ColorSpace*	GetBaseCS() const
    {
        return m_pBaseCS;
    }
    virtual void		EnableStdConversion(FX_BOOL bEnabled);
    CPDF_ColorSpace*	m_pBaseCS;
    int					m_nBaseComponents;
    int					m_MaxIndex;
    CFX_ByteString		m_Table;
    FX_FLOAT*		m_pCompMinMax;
};
CPDF_IndexedCS::CPDF_IndexedCS()
{
    m_pBaseCS = NULL;
    m_Family = PDFCS_INDEXED;
    m_nComponents = 1;
    m_pCompMinMax = NULL;
}
CPDF_IndexedCS::~CPDF_IndexedCS()
{
    if (m_pCompMinMax) {
        FX_Free(m_pCompMinMax);
    }
    CPDF_ColorSpace* pCS = m_pBaseCS;
    if (pCS && m_pDocument) {
        m_pDocument->GetPageData()->ReleaseColorSpace(pCS->GetArray());
    }
}
FX_BOOL CPDF_IndexedCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
{
    if (pArray->GetCount() < 4) {
        return FALSE;
    }
    CPDF_Object* pBaseObj = pArray->GetElementValue(1);
    if (pBaseObj == m_pArray) {
        return FALSE;
    }
    CPDF_DocPageData* pDocPageData = pDoc->GetPageData();
    m_pBaseCS = pDocPageData->GetColorSpace(pBaseObj, NULL);
    if (m_pBaseCS == NULL) {
        return FALSE;
    }
    m_nBaseComponents = m_pBaseCS->CountComponents();
    m_pCompMinMax = FX_Alloc(FX_FLOAT, m_nBaseComponents * 2);
    FX_FLOAT defvalue;
    for (int i = 0; i < m_nBaseComponents; i ++) {
        m_pBaseCS->GetDefaultValue(i, defvalue, m_pCompMinMax[i * 2], m_pCompMinMax[i * 2 + 1]);
        m_pCompMinMax[i * 2 + 1] -= m_pCompMinMax[i * 2];
    }
    m_MaxIndex = pArray->GetInteger(2);
    CPDF_Object* pTableObj = pArray->GetElementValue(3);
    if (pTableObj == NULL) {
        return FALSE;
    }
    FX_LPCBYTE pTable = NULL;
    FX_DWORD size = 0;
    CPDF_StreamAcc* pStreamAcc = NULL;
    if (pTableObj->GetType() == PDFOBJ_STRING) {
        m_Table = ((CPDF_String*)pTableObj)->GetString();
    } else if (pTableObj->GetType() == PDFOBJ_STREAM) {
        CPDF_StreamAcc acc;
        acc.LoadAllData((CPDF_Stream*)pTableObj, FALSE);
        m_Table = CFX_ByteStringC(acc.GetData(), acc.GetSize());
    }
    return TRUE;
}
FX_BOOL CPDF_IndexedCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
{
    int index = (FX_INT32)(*pBuf);
    if (index < 0 || index > m_MaxIndex) {
        return FALSE;
    }
    if (m_nBaseComponents) {
        if (index == INT_MAX || (index + 1) > INT_MAX / m_nBaseComponents ||
                (index + 1)*m_nBaseComponents > (int)m_Table.GetLength()) {
            R = G = B = 0;
            return FALSE;
        }
    }
    CFX_FixedBufGrow<FX_FLOAT, 16> Comps(m_nBaseComponents);
    FX_FLOAT* comps = Comps;
    FX_LPCBYTE pTable = m_Table;
    for (int i = 0; i < m_nBaseComponents; i ++) {
        comps[i] = m_pCompMinMax[i * 2] + m_pCompMinMax[i * 2 + 1] * pTable[index * m_nBaseComponents + i] / 255;
    }
    m_pBaseCS->GetRGB(comps, R, G, B);
    return TRUE;
}
void CPDF_IndexedCS::EnableStdConversion(FX_BOOL bEnabled)
{
    CPDF_ColorSpace::EnableStdConversion(bEnabled);
    if (m_pBaseCS) {
        m_pBaseCS->EnableStdConversion(bEnabled);
    }
}
#define MAX_PATTERN_COLORCOMPS	16
typedef struct _PatternValue {
    CPDF_Pattern*	m_pPattern;
    int				m_nComps;
    FX_FLOAT		m_Comps[MAX_PATTERN_COLORCOMPS];
} PatternValue;
CPDF_PatternCS::CPDF_PatternCS()
{
    m_Family = PDFCS_PATTERN;
    m_pBaseCS = NULL;
    m_nComponents = 1;
}
CPDF_PatternCS::~CPDF_PatternCS()
{
    CPDF_ColorSpace* pCS = m_pBaseCS;
    if (pCS && m_pDocument) {
        m_pDocument->GetPageData()->ReleaseColorSpace(pCS->GetArray());
    }
}
FX_BOOL CPDF_PatternCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
{
    CPDF_Object* pBaseCS = pArray->GetElementValue(1);
    if (pBaseCS == m_pArray) {
        return FALSE;
    }
    CPDF_DocPageData* pDocPageData = pDoc->GetPageData();
    m_pBaseCS = pDocPageData->GetColorSpace(pBaseCS, NULL);
    if (m_pBaseCS) {
        m_nComponents = m_pBaseCS->CountComponents() + 1;
        if (m_pBaseCS->CountComponents() > MAX_PATTERN_COLORCOMPS) {
            return FALSE;
        }
    } else {
        m_nComponents = 1;
    }
    return TRUE;
}
FX_BOOL CPDF_PatternCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
{
    if (m_pBaseCS) {
        PatternValue* pvalue = (PatternValue*)pBuf;
        m_pBaseCS->GetRGB(pvalue->m_Comps, R, G, B);
        return TRUE;
    }
    R = G = B = 0.75f;
    return FALSE;
}
class CPDF_SeparationCS : public CPDF_ColorSpace
{
public:
    CPDF_SeparationCS();
    virtual ~CPDF_SeparationCS();
    virtual void		GetDefaultValue(int iComponent, FX_FLOAT& value, FX_FLOAT& min, FX_FLOAT& max) const
    {
        value = 1.0f;
        min = 0;
        max = 1.0f;
    }
    virtual FX_BOOL		v_Load(CPDF_Document* pDoc, CPDF_Array* pArray);
    virtual FX_BOOL		GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const;
    virtual void		EnableStdConversion(FX_BOOL bEnabled);
    CPDF_ColorSpace*	m_pAltCS;
    CPDF_Function*		m_pFunc;
    enum {None, All, Colorant}	m_Type;
};
CPDF_SeparationCS::CPDF_SeparationCS()
{
    m_Family = PDFCS_SEPARATION;
    m_pAltCS = NULL;
    m_pFunc = NULL;
    m_nComponents = 1;
}
CPDF_SeparationCS::~CPDF_SeparationCS()
{
    if (m_pAltCS) {
        m_pAltCS->ReleaseCS();
    }
    if (m_pFunc) {
        delete m_pFunc;
    }
}
FX_BOOL CPDF_SeparationCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
{
    CFX_ByteString name = pArray->GetString(1);
    if (name == FX_BSTRC(""None"")) {
        m_Type = None;
    } else {
        m_Type = Colorant;
        CPDF_Object* pAltCS = pArray->GetElementValue(2);
        if (pAltCS == m_pArray) {
            return FALSE;
        }
        m_pAltCS = Load(pDoc, pAltCS);
        CPDF_Object* pFuncObj = pArray->GetElementValue(3);
        if (pFuncObj && pFuncObj->GetType() != PDFOBJ_NAME) {
            m_pFunc = CPDF_Function::Load(pFuncObj);
        }
        if (m_pFunc && m_pAltCS && m_pFunc->CountOutputs() < m_pAltCS->CountComponents()) {
            delete m_pFunc;
            m_pFunc = NULL;
        }
    }
    return TRUE;
}
FX_BOOL CPDF_SeparationCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
{
    if (m_Type == None) {
        return FALSE;
    }
    if (m_pFunc == NULL) {
        if (m_pAltCS == NULL) {
            return FALSE;
        }
        int nComps = m_pAltCS->CountComponents();
        CFX_FixedBufGrow<FX_FLOAT, 16> results(nComps);
        for (int i = 0; i < nComps; i ++) {
            results[i] = *pBuf;
        }
        m_pAltCS->GetRGB(results, R, G, B);
        return TRUE;
    }
    CFX_FixedBufGrow<FX_FLOAT, 16> results(m_pFunc->CountOutputs());
    int nresults = 0;
    m_pFunc->Call(pBuf, 1, results, nresults);
    if (nresults == 0) {
        return FALSE;
    }
    if (m_pAltCS) {
        m_pAltCS->GetRGB(results, R, G, B);
        return TRUE;
    } else {
        R = G = B = 0;
        return FALSE;
    }
}
void CPDF_SeparationCS::EnableStdConversion(FX_BOOL bEnabled)
{
    CPDF_ColorSpace::EnableStdConversion(bEnabled);
    if (m_pAltCS) {
        m_pAltCS->EnableStdConversion(bEnabled);
    }
}
class CPDF_DeviceNCS : public CPDF_ColorSpace
{
public:
    CPDF_DeviceNCS();
    virtual ~CPDF_DeviceNCS();
    virtual void		GetDefaultValue(int iComponent, FX_FLOAT& value, FX_FLOAT& min, FX_FLOAT& max) const
    {
        value = 1.0f;
        min = 0;
        max = 1.0f;
    }
    virtual FX_BOOL	v_Load(CPDF_Document* pDoc, CPDF_Array* pArray);
    virtual FX_BOOL	GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const;
    virtual void	EnableStdConversion(FX_BOOL bEnabled);
    CPDF_ColorSpace*	m_pAltCS;
    CPDF_Function*		m_pFunc;
};
CPDF_DeviceNCS::CPDF_DeviceNCS()
{
    m_Family = PDFCS_DEVICEN;
    m_pAltCS = NULL;
    m_pFunc = NULL;
}
CPDF_DeviceNCS::~CPDF_DeviceNCS()
{
    if (m_pFunc) {
        delete m_pFunc;
    }
    if (m_pAltCS) {
        m_pAltCS->ReleaseCS();
    }
}
FX_BOOL CPDF_DeviceNCS::v_Load(CPDF_Document* pDoc, CPDF_Array* pArray)
{
    CPDF_Object* pObj = pArray->GetElementValue(1);
    if (!pObj) {
        return FALSE;
    }
    if (pObj->GetType() != PDFOBJ_ARRAY) {
        return FALSE;
    }
    m_nComponents = ((CPDF_Array*)pObj)->GetCount();
    CPDF_Object* pAltCS = pArray->GetElementValue(2);
    if (!pAltCS || pAltCS == m_pArray) {
        return FALSE;
    }
    m_pAltCS = Load(pDoc, pAltCS);
    m_pFunc = CPDF_Function::Load(pArray->GetElementValue(3));
    if (m_pAltCS == NULL || m_pFunc == NULL) {
        return FALSE;
    }
    if (m_pFunc->CountOutputs() < m_pAltCS->CountComponents()) {
        return FALSE;
    }
    return TRUE;
}
FX_BOOL CPDF_DeviceNCS::GetRGB(FX_FLOAT* pBuf, FX_FLOAT& R, FX_FLOAT& G, FX_FLOAT& B) const
{
    if (m_pFunc == NULL) {
        return FALSE;
    }
    CFX_FixedBufGrow<FX_FLOAT, 16> results(m_pFunc->CountOutputs());
    int nresults = 0;
    m_pFunc->Call(pBuf, m_nComponents, results, nresults);
    if (nresults == 0) {
        return FALSE;
    }
    m_pAltCS->GetRGB(results, R, G, B);
    return TRUE;
}
void CPDF_DeviceNCS::EnableStdConversion(FX_BOOL bEnabled)
{
    CPDF_ColorSpace::EnableStdConversion(bEnabled);
    if (m_pAltCS) {
        m_pAltCS->EnableStdConversion(bEnabled);
    }
}
CPDF_ColorSpace* CPDF_ColorSpace::GetStockCS(int family)
{
    return CPDF_ModuleMgr::Get()->GetPageModule()->GetStockCS(family);;
}
CPDF_ColorSpace* _CSFromName(const CFX_ByteString& name)
{
    if (name == FX_BSTRC(""DeviceRGB"") || name == FX_BSTRC(""RGB"")) {
        return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICERGB);
    }
    if (name == FX_BSTRC(""DeviceGray"") || name == FX_BSTRC(""G"")) {
        return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICEGRAY);
    }
    if (name == FX_BSTRC(""DeviceCMYK"") || name == FX_BSTRC(""CMYK"")) {
        return CPDF_ColorSpace::GetStockCS(PDFCS_DEVICECMYK);
    }
    if (name == FX_BSTRC(""Pattern"")) {
        return CPDF_ColorSpace::GetStockCS(PDFCS_PATTERN);
    }
    return NULL;
}
CPDF_ColorSpace* CPDF_ColorSpace::Load(CPDF_Document* pDoc, CPDF_Object* pObj)
{
    if (pObj == NULL) {
        return NULL;
    }
    if (pObj->GetType() == PDFOBJ_NAME) {
        return _CSFromName(pObj->GetString());
    }
    if (pObj->GetType() == PDFOBJ_STREAM) {
        CPDF_Dictionary *pDict = ((CPDF_Stream *)pObj)->GetDict();
        if (!pDict) {
            return NULL;
        }
        CPDF_ColorSpace *pRet = NULL;
        FX_POSITION pos = pDict->GetStartPos();
        while (pos) {
            CFX_ByteString bsKey;
            CPDF_Object *pValue = pDict->GetNextElement(pos, bsKey);
            if (pValue && pValue->GetType() == PDFOBJ_NAME) {
                pRet = _CSFromName(pValue->GetString());
            }
            if (pRet) {
                return pRet;
            }
        }
        return NULL;
    }
    if (pObj->GetType() != PDFOBJ_ARRAY) {
        return NULL;
    }
    CPDF_Array* pArray = (CPDF_Array*)pObj;
    if (pArray->GetCount() == 0) {
        return NULL;
    }
    CFX_ByteString familyname = pArray->GetElementValue(0)->GetString();
    if (pArray->GetCount() == 1) {
        return _CSFromName(familyname);
    }
    CPDF_ColorSpace* pCS = NULL;
    FX_DWORD id = familyname.GetID();
    if (id == FXBSTR_ID('C', 'a', 'l', 'G')) {
        pCS = FX_NEW CPDF_CalGray();
    } else if (id == FXBSTR_ID('C', 'a', 'l', 'R')) {
        pCS = FX_NEW CPDF_CalRGB();
    } else if (id == FXBSTR_ID('L', 'a', 'b', 0)) {
        pCS = FX_NEW CPDF_LabCS();
    } else if (id == FXBSTR_ID('I', 'C', 'C', 'B')) {
        pCS = FX_NEW CPDF_ICCBasedCS();
    } else if (id == FXBSTR_ID('I', 'n', 'd', 'e') || id == FXBSTR_ID('I', 0, 0, 0)) {
        pCS = FX_NEW CPDF_IndexedCS();
    } else if (id == FXBSTR_ID('S', 'e', 'p', 'a')) {
        pCS = FX_NEW CPDF_SeparationCS();
    } else if (id == FXBSTR_ID('D', 'e', 'v', 'i')) {
        pCS = FX_NEW CPDF_DeviceNCS();
    } else if (id == FXBSTR_ID('P', 'a', 't', 't')) {
        pCS = FX_NEW CPDF_PatternCS();
    } else {
        return NULL;
    }
    pCS->m_pDocument = pDoc;
    pCS->m_pArray = pArray;
    if (!pCS->v_Load(pDoc, pArray)) {
        pCS->ReleaseCS();
        return NULL;
    }
    return pCS;
}
CPDF_ColorSpace::CPDF_ColorSpace()
{
    m_Family = 0;
    m_pArray = NULL;
    m_dwStdConversion = 0;
    m_pDocument = NULL;
}
void CPDF_ColorSpace::ReleaseCS()
{
    if (this == GetStockCS(PDFCS_DEVICERGB)) {
        return;
    }
    if (this == GetStockCS(PDFCS_DEVICEGRAY)) {
        return;
    }
    if (this == GetStockCS(PDFCS_DEVICECMYK)) {
        return;
    }
    if (this == GetStockCS(PDFCS_PATTERN)) {
        return;
    }
    delete this;
}
int CPDF_ColorSpace::GetBufSize() const
{
    if (m_Family == PDFCS_PATTERN) {
        return sizeof(PatternValue);
    }
    return m_nComponents * sizeof(FX_FLOAT);
}
FX_FLOAT* CPDF_ColorSpace::CreateBuf()
{
    int size = GetBufSize();
    FX_BYTE* pBuf = FX_Alloc(FX_BYTE, size);
    return (FX_FLOAT*)pBuf;
}
FX_BOOL CPDF_ColorSpace::sRGB() const
{
    if (m_Family == PDFCS_DEVICERGB) {
        return TRUE;
    }
    if (m_Family != PDFCS_ICCBASED) {
        return FALSE;
    }
    CPDF_ICCBasedCS* pCS = (CPDF_ICCBasedCS*)this;
    return pCS->m_pProfile->m_bsRGB;
}
FX_BOOL CPDF_ColorSpace::GetCMYK(FX_FLOAT* pBuf, FX_FLOAT& c, FX_FLOAT& m, FX_FLOAT& y, FX_FLOAT& k) const
{
    if (v_GetCMYK(pBuf, c, m, y, k)) {
        return TRUE;
    }
    FX_FLOAT R, G, B;
    if (!GetRGB(pBuf, R, G, B)) {
        return FALSE;
    }
    sRGB_to_AdobeCMYK(R, G, B, c, m, y, k);
    return TRUE;
}
FX_BOOL CPDF_ColorSpace::SetCMYK(FX_FLOAT* pBuf, FX_FLOAT c, FX_FLOAT m, FX_FLOAT y, FX_FLOAT k) const
{
    if (v_SetCMYK(pBuf, c, m, y, k)) {
        return TRUE;
    }
    FX_FLOAT R, G, B;
    AdobeCMYK_to_sRGB(c, m, y, k, R, G, B);
    return SetRGB(pBuf, R, G, B);
}
void CPDF_ColorSpace::GetDefaultColor(FX_FLOAT* buf) const
{
    if (buf == NULL || m_Family == PDFCS_PATTERN) {
        return;
    }
    FX_FLOAT min, max;
    for (int i = 0; i < m_nComponents; i ++) {
        GetDefaultValue(i, buf[i], min, max);
    }
}
int CPDF_ColorSpace::GetMaxIndex() const
{
    if (m_Family != PDFCS_INDEXED) {
        return 0;
    }
    CPDF_IndexedCS* pCS = (CPDF_IndexedCS*)this;
    return pCS->m_MaxIndex;
}
void CPDF_ColorSpace::TranslateImageLine(FX_LPBYTE dest_buf, FX_LPCBYTE src_buf, int pixels, int image_width, int image_height, FX_BOOL bTransMask) const
{
    CFX_FixedBufGrow<FX_FLOAT, 16> srcbuf(m_nComponents);
    FX_FLOAT* src = srcbuf;
    FX_FLOAT R, G, B;
    for (int i = 0; i < pixels; i ++) {
        for (int j = 0; j < m_nComponents; j ++)
            if (m_Family == PDFCS_INDEXED) {
                src[j] = (FX_FLOAT)(*src_buf ++);
            } else {
                src[j] = (FX_FLOAT)(*src_buf ++) / 255;
            }
        GetRGB(src, R, G, B);
        *dest_buf ++ = (FX_INT32)(B * 255);
        *dest_buf ++ = (FX_INT32)(G * 255);
        *dest_buf ++ = (FX_INT32)(R * 255);
    }
}
void CPDF_ColorSpace::EnableStdConversion(FX_BOOL bEnabled)
{
    if (bEnabled) {
        m_dwStdConversion ++;
    } else if (m_dwStdConversion) {
        m_dwStdConversion --;
    }
}
CPDF_Color::CPDF_Color(int family)
{
    m_pCS = CPDF_ColorSpace::GetStockCS(family);
    int nComps = 3;
    if (family == PDFCS_DEVICEGRAY) {
        nComps = 1;
    } else if (family == PDFCS_DEVICECMYK) {
        nComps = 4;
    }
    m_pBuffer = FX_Alloc(FX_FLOAT, nComps);
    for (int i = 0; i < nComps; i ++) {
        m_pBuffer[i] = 0;
    }
}
CPDF_Color::~CPDF_Color()
{
    ReleaseBuffer();
    ReleaseColorSpace();
}
void CPDF_Color::ReleaseBuffer()
{
    if (!m_pBuffer) {
        return;
    }
    if (m_pCS->GetFamily() == PDFCS_PATTERN) {
        PatternValue* pvalue = (PatternValue*)m_pBuffer;
        CPDF_Pattern* pPattern = pvalue->m_pPattern;
        if (pPattern && pPattern->m_pDocument) {
            pPattern->m_pDocument->GetPageData()->ReleasePattern(pPattern->m_pPatternObj);
        }
    }
    FX_Free(m_pBuffer);
    m_pBuffer = NULL;
}
void CPDF_Color::ReleaseColorSpace()
{
    if (m_pCS && m_pCS->m_pDocument && m_pCS->GetArray()) {
        m_pCS->m_pDocument->GetPageData()->ReleaseColorSpace(m_pCS->GetArray());
        m_pCS = NULL;
    }
}
void CPDF_Color::SetColorSpace(CPDF_ColorSpace* pCS)
{
    if (m_pCS == pCS) {
        if (m_pBuffer == NULL) {
            m_pBuffer = pCS->CreateBuf();
        }
        ReleaseColorSpace();
        m_pCS = pCS;
        return;
    }
    ReleaseBuffer();
    ReleaseColorSpace();
    m_pCS = pCS;
    if (m_pCS) {
        m_pBuffer = pCS->CreateBuf();
        pCS->GetDefaultColor(m_pBuffer);
    }
}
void CPDF_Color::SetValue(FX_FLOAT* comps)
{
    if (m_pBuffer == NULL) {
        return;
    }
    if (m_pCS->GetFamily() != PDFCS_PATTERN) {
        FXSYS_memcpy32(m_pBuffer, comps, m_pCS->CountComponents() * sizeof(FX_FLOAT));
    }
}
void CPDF_Color::SetValue(CPDF_Pattern* pPattern, FX_FLOAT* comps, int ncomps)
{
    if (ncomps > MAX_PATTERN_COLORCOMPS) {
        return;
    }
    if (m_pCS == NULL || m_pCS->GetFamily() != PDFCS_PATTERN) {
        if (m_pBuffer) {
            FX_Free(m_pBuffer);
        }
        m_pCS = CPDF_ColorSpace::GetStockCS(PDFCS_PATTERN);
        m_pBuffer = m_pCS->CreateBuf();
    }
    CPDF_DocPageData* pDocPageData = NULL;
    PatternValue* pvalue = (PatternValue*)m_pBuffer;
    if (pvalue->m_pPattern && pvalue->m_pPattern->m_pDocument) {
        pDocPageData = pvalue->m_pPattern->m_pDocument->GetPageData();
        pDocPageData->ReleasePattern(pvalue->m_pPattern->m_pPatternObj);
    }
    pvalue->m_nComps = ncomps;
    pvalue->m_pPattern = pPattern;
    if (ncomps) {
        FXSYS_memcpy32(pvalue->m_Comps, comps, ncomps * sizeof(FX_FLOAT));
    }
}
void CPDF_Color::Copy(const CPDF_Color* pSrc)
{
    ReleaseBuffer();
    ReleaseColorSpace();
    m_pCS = pSrc->m_pCS;
    if (m_pCS && m_pCS->m_pDocument) {
        CPDF_Array* pArray = m_pCS->GetArray();
        if (pArray) {
            m_pCS = m_pCS->m_pDocument->GetPageData()->GetCopiedColorSpace(pArray);
        }
    }
    if (m_pCS == NULL) {
        return;
    }
    m_pBuffer = m_pCS->CreateBuf();
    FXSYS_memcpy32(m_pBuffer, pSrc->m_pBuffer, m_pCS->GetBufSize());
    if (m_pCS->GetFamily() == PDFCS_PATTERN) {
        PatternValue* pvalue = (PatternValue*)m_pBuffer;
        if (pvalue->m_pPattern && pvalue->m_pPattern->m_pDocument) {
            pvalue->m_pPattern = pvalue->m_pPattern->m_pDocument->GetPageData()->GetPattern(pvalue->m_pPattern->m_pPatternObj, FALSE, &pvalue->m_pPattern->m_ParentMatrix);
        }
    }
}
FX_BOOL CPDF_Color::GetRGB(int& R, int& G, int& B) const
{
    if (m_pCS == NULL || m_pBuffer == NULL) {
        return FALSE;
    }
    FX_FLOAT r=0.0f, g=0.0f, b=0.0f;
    if (!m_pCS->GetRGB(m_pBuffer, r, g, b)) {
        return FALSE;
    }
    R = (FX_INT32)(r * 255 + 0.5f);
    G = (FX_INT32)(g * 255 + 0.5f);
    B = (FX_INT32)(b * 255 + 0.5f);
    return TRUE;
}
CPDF_Pattern* CPDF_Color::GetPattern() const
{
    if (m_pBuffer == NULL || m_pCS->GetFamily() != PDFCS_PATTERN) {
        return NULL;
    }
    PatternValue* pvalue = (PatternValue*)m_pBuffer;
    return pvalue->m_pPattern;
}
CPDF_ColorSpace* CPDF_Color::GetPatternCS() const
{
    if (m_pBuffer == NULL || m_pCS->GetFamily() != PDFCS_PATTERN) {
        return NULL;
    }
    return m_pCS->GetBaseCS();
}
FX_FLOAT* CPDF_Color::GetPatternColor() const
{
    if (m_pBuffer == NULL || m_pCS->GetFamily() != PDFCS_PATTERN) {
        return NULL;
    }
    PatternValue* pvalue = (PatternValue*)m_pBuffer;
    return pvalue->m_nComps ? pvalue->m_Comps : NULL;
}
FX_BOOL CPDF_Color::IsEqual(const CPDF_Color& other) const
{
    if (m_pCS != other.m_pCS || m_pCS == NULL) {
        return FALSE;
    }
    return FXSYS_memcmp32(m_pBuffer, other.m_pBuffer, m_pCS->GetBufSize()) == 0;
}
",16169,True,2893.9908095407927,median
"= v1.Template
{product-author}
{product-version}
:data-uri:
:icons:
:toc: macro
:toc-title:
:toclevels: 2

toc::[]

== Description
[%hardbreaks]
Template contains the inputs needed to produce a Config.

== Object Schema
Expand or mouse-over a field for more information about it.

++++
<pre>
<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=""(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><summary><span title=""(object) labels is a optional set of labels that are applied to every object during the Template to Config transformation."">labels</span>:
</summary><div style=""margin-left:13px;"">  <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;""><span title=""(string) message is an optional instructional message that will be displayed when this template is instantiated. This field should inform the user how to utilize the newly created resources. Parameter substitution will be performed on the message before being displayed so that generated credentials and other parameters can be included in the output."">message</span>:
</div><details open><summary><span title=""(v1.ObjectMeta) Standard object&#39;s 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><details><summary><span title=""(array) objects is an array of resources to include in this template. If a namespace value is hardcoded in the object, it will be removed during template instantiation, however if the namespace value is, or contains, a ${PARAMETER_REFERENCE}, the resolved value after parameter substitution will be respected and the object will be created in that namespace."">objects</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string) Raw is the underlying serialization of this object."">Raw</span>:
</div></details><details><summary><span title=""(array) parameters is an optional array of Parameters used during the Template to Config transformation."">parameters</span>:
</summary><div style=""margin-left:13px;"">- <span title=""(string) Description of a parameter. Optional."">description</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) Optional: The name that will show in UI instead of parameter &#39;Name&#39;"">displayName</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) From is an input value for the generator. Optional."">from</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) generate specifies the generator to be used to generate random string from an input value specified by From field. The result string is stored into Value field. If empty, no generator is being used, leaving the result Value untouched. Optional.

The only supported generator is &#34;expression&#34;, which accepts a &#34;from&#34; value in the form of a simple regular expression containing the range expression &#34;[a-zA-Z0-9]&#34;, and the length expression &#34;a{length}&#34;.

Examples:

from             | value ----------------------------- &#34;test[0-9]{1}x&#34;  | &#34;test7x&#34; &#34;[0-1]{8}&#34;       | &#34;01001100&#34; &#34;0x[A-F0-9]{4}&#34;  | &#34;0xB3AF&#34; &#34;[a-zA-Z0-9]{8}&#34; | &#34;hW4yQU5i&#34;"">generate</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) Name must be set and it can be referenced in Template Items using ${PARAMETER_NAME}. Required."">name</span>:
</div><div style=""margin-left:13px;"">  <span title=""(boolean) Optional: Indicates the parameter must have a value.  Defaults to false."">required</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) Value holds the Parameter data. If specified, the generator will be ignored. The value replaces all occurrences of the Parameter ${Name} expression during the Template to Config transformation. Optional."">value</span>:
</div></details>
</pre>
++++

== Operations

[[Post-oapi-v1-namespaces-namespace-templates]]
=== Create a Template in a namespace
Create a Template

==== HTTP request
----
POST /oapi/v1/namespaces/$NAMESPACE/templates HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json'

{
  ""kind"": ""ProcessedTemplate"",
  ""apiVersion"": ""v1"",
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X POST \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json' \\
    https://$ENDPOINT/oapi/v1/namespaces/$NAMESPACE/templates <<'EOF'
{
  ""kind"": ""ProcessedTemplate"",
  ""apiVersion"": ""v1"",
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.Template
|===

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|namespace|object name and auth scope, such as for teams and projects
|===

==== 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.Template
|201 Created|v1.Template
|202 Accepted|v1.Template
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Get-oapi-v1-namespaces-namespace-templates-name]]
=== Get a Template in a namespace
Read the specified Template

==== HTTP request
----
GET /oapi/v1/namespaces/$NAMESPACE/templates/$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/oapi/v1/namespaces/$NAMESPACE/templates/$NAME
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the Template
|namespace|object name and auth scope, such as for teams and projects
|===

==== 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.Template
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Get-oapi-v1-templates]]
=== Get all Templates
List or watch objects of kind Template

==== HTTP request
----
GET /oapi/v1/templates 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/oapi/v1/templates
----

==== 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.TemplateList
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Get-oapi-v1-namespaces-namespace-templates]]
=== Get all Templates in a namespace
List or watch objects of kind Template

==== HTTP request
----
GET /oapi/v1/namespaces/$NAMESPACE/templates 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/oapi/v1/namespaces/$NAMESPACE/templates
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|namespace|object name and auth scope, such as for teams and projects
|===

==== 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.TemplateList
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Get-oapi-v1-watch-namespaces-namespace-templates-name]]
=== Watch a Template in a namespace
Watch changes to an object of kind Template

==== HTTP request
----
GET /oapi/v1/watch/namespaces/$NAMESPACE/templates/$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/oapi/v1/watch/namespaces/$NAMESPACE/templates/$NAME
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the Template
|namespace|object name and auth scope, such as for teams and projects
|===

==== 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-oapi-v1-watch-templates]]
=== Watch all Templates
Watch individual changes to a list of Template

==== HTTP request
----
GET /oapi/v1/watch/templates 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/oapi/v1/watch/templates
----

==== 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-oapi-v1-watch-namespaces-namespace-templates]]
=== Watch all Templates in a namespace
Watch individual changes to a list of Template

==== HTTP request
----
GET /oapi/v1/watch/namespaces/$NAMESPACE/templates 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/oapi/v1/watch/namespaces/$NAMESPACE/templates
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|namespace|object name and auth scope, such as for teams and projects
|===

==== 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-oapi-v1-namespaces-namespace-templates-name]]
=== Update a Template in a namespace
Replace the specified Template

==== HTTP request
----
PUT /oapi/v1/namespaces/$NAMESPACE/templates/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json'

{
  ""kind"": ""ProcessedTemplate"",
  ""apiVersion"": ""v1"",
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X PUT \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json' \\
    https://$ENDPOINT/oapi/v1/namespaces/$NAMESPACE/templates/$NAME <<'EOF'
{
  ""kind"": ""ProcessedTemplate"",
  ""apiVersion"": ""v1"",
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1.Template
|===

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the Template
|namespace|object name and auth scope, such as for teams and projects
|===

==== 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.Template
|201 Created|v1.Template
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Patch-oapi-v1-namespaces-namespace-templates-name]]
=== Patch a Template in a namespace
Partially update the specified Template

==== HTTP request
----
PATCH /oapi/v1/namespaces/$NAMESPACE/templates/$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/oapi/v1/namespaces/$NAMESPACE/templates/$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 Template
|namespace|object name and auth scope, such as for teams and projects
|===

==== 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.Template
|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-oapi-v1-namespaces-namespace-templates-name]]
=== Delete a Template in a namespace
Delete a Template

==== HTTP request
----
DELETE /oapi/v1/namespaces/$NAMESPACE/templates/$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/oapi/v1/namespaces/$NAMESPACE/templates/$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 Template
|namespace|object name and auth scope, such as for teams and projects
|===

==== 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-oapi-v1-namespaces-namespace-templates]]
=== Delete all Templates in a namespace
Delete collection of Template

==== HTTP request
----
DELETE /oapi/v1/namespaces/$NAMESPACE/templates 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/oapi/v1/namespaces/$NAMESPACE/templates
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|namespace|object name and auth scope, such as for teams and projects
|===

==== 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



",12289,False,2274.195269964761,median
"// Copyright (c) 2009-2019 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <chain.h>
#include <core_io.h>
#include <interfaces/chain.h>
#include <key_io.h>
#include <merkleblock.h>
#include <rpc/util.h>
#include <script/descriptor.h>
#include <script/script.h>
#include <script/standard.h>
#include <sync.h>
#include <util/bip32.h>
#include <util/system.h>
#include <util/time.h>
#include <util/translation.h>
#include <wallet/rpcwallet.h>
#include <wallet/wallet.h>

#include <stdint.h>
#include <tuple>

#include <boost/algorithm/string.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>

#include <univalue.h>


int64_t static DecodeDumpTime(const std::string &str) {
    static const boost::posix_time::ptime epoch = boost::posix_time::from_time_t(0);
    static const std::locale loc(std::locale::classic(),
        new boost::posix_time::time_input_facet(""%Y-%m-%dT%H:%M:%SZ""));
    std::istringstream iss(str);
    iss.imbue(loc);
    boost::posix_time::ptime ptime(boost::date_time::not_a_date_time);
    iss >> ptime;
    if (ptime.is_not_a_date_time())
        return 0;
    return (ptime - epoch).total_seconds();
}

std::string static EncodeDumpString(const std::string &str) {
    std::stringstream ret;
    for (const unsigned char c : str) {
        if (c <= 32 || c >= 128 || c == '%') {
            ret << '%' << HexStr(&c, &c + 1);
        } else {
            ret << c;
        }
    }
    return ret.str();
}

static std::string DecodeDumpString(const std::string &str) {
    std::stringstream ret;
    for (unsigned int pos = 0; pos < str.length(); pos++) {
        unsigned char c = str[pos];
        if (c == '%' && pos+2 < str.length()) {
            c = (((str[pos+1]>>6)*9+((str[pos+1]-'0')&15)) << 4) |
                ((str[pos+2]>>6)*9+((str[pos+2]-'0')&15));
            pos += 2;
        }
        ret << c;
    }
    return ret.str();
}

static bool GetWalletAddressesForKey(CWallet* const pwallet, const CKeyID& keyid, std::string& strAddr, std::string& strLabel) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
{
    bool fLabelFound = false;
    CKey key;
    pwallet->GetKey(keyid, key);
    for (const auto& dest : GetAllDestinationsForKey(key.GetPubKey())) {
        if (pwallet->mapAddressBook.count(dest)) {
            if (!strAddr.empty()) {
                strAddr += "","";
            }
            strAddr += EncodeDestination(dest);
            strLabel = EncodeDumpString(pwallet->mapAddressBook[dest].name);
            fLabelFound = true;
        }
    }
    if (!fLabelFound) {
        strAddr = EncodeDestination(GetDestinationForKey(key.GetPubKey(), pwallet->m_default_address_type));
    }
    return fLabelFound;
}

static const int64_t TIMESTAMP_MIN = 0;

static void RescanWallet(CWallet& wallet, const WalletRescanReserver& reserver, int64_t time_begin = TIMESTAMP_MIN, bool update = true)
{
    int64_t scanned_time = wallet.RescanFromTime(time_begin, reserver, update);
    if (wallet.IsAbortingRescan()) {
        throw JSONRPCError(RPC_MISC_ERROR, ""Rescan aborted by user."");
    } else if (scanned_time > time_begin) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Rescan was unable to fully rescan the blockchain. Some transactions may be missing."");
    }
}

UniValue importprivkey(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importprivkey"",
                ""\\nAdds a private key (as returned by dumpprivkey) to your wallet. Requires a new wallet backup.\\n""
                ""Hint: use importmulti to import more than one private key.\\n""
            ""\\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\\n""
            ""may report that the imported key exists but related transactions are still missing, leading to temporarily incorrect/bogus balances and unspent outputs until rescan completes.\\n""
            ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {
                    {""privkey"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The private key (see dumpprivkey)""},
                    {""label"", RPCArg::Type::STR, /* default */ ""current label if address exists, otherwise \\""\\"""", ""An optional label""},
                    {""rescan"", RPCArg::Type::BOOL, /* default */ ""true"", ""Rescan the wallet for transactions""},
                },
                RPCResults{},
                RPCExamples{
            ""\\nDump a private key\\n""
            + HelpExampleCli(""dumpprivkey"", ""\\""myaddress\\"""") +
            ""\\nImport the private key with rescan\\n""
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"""") +
            ""\\nImport using a label and without rescan\\n""
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"" \\""testing\\"" false"") +
            ""\\nImport using default blank label and without rescan\\n""
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"" \\""\\"" false"") +
            ""\\nAs a JSON-RPC call\\n""
            + HelpExampleRpc(""importprivkey"", ""\\""mykey\\"", \\""testing\\"", false"")
                },
            }.Check(request);

    if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Cannot import private keys to a wallet with private keys disabled"");
    }

    WalletRescanReserver reserver(pwallet);
    bool fRescan = true;
    {
        auto locked_chain = pwallet->chain().lock();
        LOCK(pwallet->cs_wallet);

        EnsureWalletIsUnlocked(pwallet);

        std::string strSecret = request.params[0].get_str();
        std::string strLabel = """";
        if (!request.params[1].isNull())
            strLabel = request.params[1].get_str();

        // Whether to perform rescan after import
        if (!request.params[2].isNull())
            fRescan = request.params[2].get_bool();

        if (fRescan && pwallet->chain().havePruned()) {
            // Exit early and print an error.
            // If a block is pruned after this check, we will import the key(s),
            // but fail the rescan with a generic error.
            throw JSONRPCError(RPC_WALLET_ERROR, ""Rescan is disabled when blocks are pruned"");
        }

        if (fRescan && !reserver.reserve()) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Wallet is currently rescanning. Abort existing rescan or wait."");
        }

        CKey key = DecodeSecret(strSecret);
        if (!key.IsValid()) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid private key encoding"");

        CPubKey pubkey = key.GetPubKey();
        assert(key.VerifyPubKey(pubkey));
        CKeyID vchAddress = pubkey.GetID();
        {
            pwallet->MarkDirty();

            // We don't know which corresponding address will be used;
            // label all new addresses, and label existing addresses if a
            // label was passed.
            for (const auto& dest : GetAllDestinationsForKey(pubkey)) {
                if (!request.params[1].isNull() || pwallet->mapAddressBook.count(dest) == 0) {
                    pwallet->SetAddressBook(dest, strLabel, ""receive"");
                }
            }

            // Use timestamp of 1 to scan the whole chain
            if (!pwallet->ImportPrivKeys({{vchAddress, key}}, 1)) {
                throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding key to wallet"");
            }

            // Add the wpkh script for this key if possible
            if (pubkey.IsCompressed()) {
                pwallet->ImportScripts({GetScriptForDestination(WitnessV0KeyHash(vchAddress))}, 0 /* timestamp */);
            }
        }
    }
    if (fRescan) {
        RescanWallet(*pwallet, reserver);
    }

    return NullUniValue;
}

UniValue abortrescan(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""abortrescan"",
                ""\\nStops current wallet rescan triggered by an RPC call, e.g. by an importprivkey call.\\n""
                ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {},
                RPCResults{},
                RPCExamples{
            ""\\nImport a private key\\n""
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"""") +
            ""\\nAbort the running wallet rescan\\n""
            + HelpExampleCli(""abortrescan"", """") +
            ""\\nAs a JSON-RPC call\\n""
            + HelpExampleRpc(""abortrescan"", """")
                },
            }.Check(request);

    if (!pwallet->IsScanning() || pwallet->IsAbortingRescan()) return false;
    pwallet->AbortRescan();
    return true;
}

UniValue importaddress(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importaddress"",
                ""\\nAdds an address or script (in hex) that can be watched as if it were in your wallet but cannot be used to spend. Requires a new wallet backup.\\n""
            ""\\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\\n""
            ""may report that the imported address exists but related transactions are still missing, leading to temporarily incorrect/bogus balances and unspent outputs until rescan completes.\\n""
            ""If you have the full public key, you should call importpubkey instead of this.\\n""
            ""Hint: use importmulti to import more than one address.\\n""
            ""\\nNote: If you import a non-standard raw script in hex form, outputs sending to it will be treated\\n""
            ""as change, and not show up in many RPCs.\\n""
            ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {
                    {""address"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The Bitcoin address (or hex-encoded script)""},
                    {""label"", RPCArg::Type::STR, /* default */ ""\\""\\"""", ""An optional label""},
                    {""rescan"", RPCArg::Type::BOOL, /* default */ ""true"", ""Rescan the wallet for transactions""},
                    {""p2sh"", RPCArg::Type::BOOL, /* default */ ""false"", ""Add the P2SH version of the script as well""},
                },
                RPCResults{},
                RPCExamples{
            ""\\nImport an address with rescan\\n""
            + HelpExampleCli(""importaddress"", ""\\""myaddress\\"""") +
            ""\\nImport using a label without rescan\\n""
            + HelpExampleCli(""importaddress"", ""\\""myaddress\\"" \\""testing\\"" false"") +
            ""\\nAs a JSON-RPC call\\n""
            + HelpExampleRpc(""importaddress"", ""\\""myaddress\\"", \\""testing\\"", false"")
                },
            }.Check(request);


    std::string strLabel;
    if (!request.params[1].isNull())
        strLabel = request.params[1].get_str();

    // Whether to perform rescan after import
    bool fRescan = true;
    if (!request.params[2].isNull())
        fRescan = request.params[2].get_bool();

    if (fRescan && pwallet->chain().havePruned()) {
        // Exit early and print an error.
        // If a block is pruned after this check, we will import the key(s),
        // but fail the rescan with a generic error.
        throw JSONRPCError(RPC_WALLET_ERROR, ""Rescan is disabled when blocks are pruned"");
    }

    WalletRescanReserver reserver(pwallet);
    if (fRescan && !reserver.reserve()) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Wallet is currently rescanning. Abort existing rescan or wait."");
    }

    // Whether to import a p2sh version, too
    bool fP2SH = false;
    if (!request.params[3].isNull())
        fP2SH = request.params[3].get_bool();

    {
        auto locked_chain = pwallet->chain().lock();
        LOCK(pwallet->cs_wallet);

        CTxDestination dest = DecodeDestination(request.params[0].get_str());
        if (IsValidDestination(dest)) {
            if (fP2SH) {
                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Cannot use the p2sh flag with an address - use a script instead"");
            }

            pwallet->MarkDirty();

            pwallet->ImportScriptPubKeys(strLabel, {GetScriptForDestination(dest)}, false /* have_solving_data */, true /* apply_label */, 1 /* timestamp */);
        } else if (IsHex(request.params[0].get_str())) {
            std::vector<unsigned char> data(ParseHex(request.params[0].get_str()));
            CScript redeem_script(data.begin(), data.end());

            std::set<CScript> scripts = {redeem_script};
            pwallet->ImportScripts(scripts, 0 /* timestamp */);

            if (fP2SH) {
                scripts.insert(GetScriptForDestination(ScriptHash(CScriptID(redeem_script))));
            }

            pwallet->ImportScriptPubKeys(strLabel, scripts, false /* have_solving_data */, true /* apply_label */, 1 /* timestamp */);
        } else {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid Bitcoin address or script"");
        }
    }
    if (fRescan)
    {
        RescanWallet(*pwallet, reserver);
        {
            auto locked_chain = pwallet->chain().lock();
            LOCK(pwallet->cs_wallet);
            pwallet->ReacceptWalletTransactions(*locked_chain);
        }
    }

    return NullUniValue;
}

UniValue importprunedfunds(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importprunedfunds"",
                ""\\nImports funds without rescan. Corresponding address or script must previously be included in wallet. Aimed towards pruned wallets. The end-user is responsible to import additional transactions that subsequently spend the imported outputs or rescan after the point in the blockchain the transaction is included.\\n"",
                {
                    {""rawtransaction"", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, ""A raw transaction in hex funding an already-existing address in wallet""},
                    {""txoutproof"", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, ""The hex output from gettxoutproof that contains the transaction""},
                },
                RPCResults{},
                RPCExamples{""""},
            }.Check(request);

    CMutableTransaction tx;
    if (!DecodeHexTx(tx, request.params[0].get_str()))
        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, ""TX decode failed"");
    uint256 hashTx = tx.GetHash();
    CWalletTx wtx(pwallet, MakeTransactionRef(std::move(tx)));

    CDataStream ssMB(ParseHexV(request.params[1], ""proof""), SER_NETWORK, PROTOCOL_VERSION);
    CMerkleBlock merkleBlock;
    ssMB >> merkleBlock;

    //Search partial merkle tree in proof for our transaction and index in valid block
    std::vector<uint256> vMatch;
    std::vector<unsigned int> vIndex;
    unsigned int txnIndex = 0;
    if (merkleBlock.txn.ExtractMatches(vMatch, vIndex) == merkleBlock.header.hashMerkleRoot) {

        auto locked_chain = pwallet->chain().lock();
        if (locked_chain->getBlockHeight(merkleBlock.header.GetHash()) == nullopt) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Block not found in chain"");
        }

        std::vector<uint256>::const_iterator it;
        if ((it = std::find(vMatch.begin(), vMatch.end(), hashTx))==vMatch.end()) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Transaction given doesn't exist in proof"");
        }

        txnIndex = vIndex[it - vMatch.begin()];
    }
    else {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Something wrong with merkleblock"");
    }

    wtx.SetConf(CWalletTx::Status::CONFIRMED, merkleBlock.header.GetHash(), txnIndex);

    auto locked_chain = pwallet->chain().lock();
    LOCK(pwallet->cs_wallet);

    if (pwallet->IsMine(*wtx.tx)) {
        pwallet->AddToWallet(wtx, false);
        return NullUniValue;
    }

    throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""No addresses in wallet correspond to included transaction"");
}

UniValue removeprunedfunds(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""removeprunedfunds"",
                ""\\nDeletes the specified transaction from the wallet. Meant for use with pruned wallets and as a companion to importprunedfunds. This will affect wallet balances.\\n"",
                {
                    {""txid"", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, ""The hex-encoded id of the transaction you are deleting""},
                },
                RPCResults{},
                RPCExamples{
                    HelpExampleCli(""removeprunedfunds"", ""\\""a8d0c0184dde994a09ec054286f1ce581bebf46446a512166eae7628734ea0a5\\"""") +
            ""\\nAs a JSON-RPC call\\n""
            + HelpExampleRpc(""removeprunedfunds"", ""\\""a8d0c0184dde994a09ec054286f1ce581bebf46446a512166eae7628734ea0a5\\"""")
                },
            }.Check(request);

    auto locked_chain = pwallet->chain().lock();
    LOCK(pwallet->cs_wallet);

    uint256 hash(ParseHashV(request.params[0], ""txid""));
    std::vector<uint256> vHash;
    vHash.push_back(hash);
    std::vector<uint256> vHashOut;

    if (pwallet->ZapSelectTx(vHash, vHashOut) != DBErrors::LOAD_OK) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Could not properly delete the transaction."");
    }

    if(vHashOut.empty()) {
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""Transaction does not exist in wallet."");
    }

    return NullUniValue;
}

UniValue importpubkey(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importpubkey"",
                ""\\nAdds a public key (in hex) that can be watched as if it were in your wallet but cannot be used to spend. Requires a new wallet backup.\\n""
                ""Hint: use importmulti to import more than one public key.\\n""
            ""\\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\\n""
            ""may report that the imported pubkey exists but related transactions are still missing, leading to temporarily incorrect/bogus balances and unspent outputs until rescan completes.\\n""
            ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {
                    {""pubkey"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The hex-encoded public key""},
                    {""label"", RPCArg::Type::STR, /* default */ ""\\""\\"""", ""An optional label""},
                    {""rescan"", RPCArg::Type::BOOL, /* default */ ""true"", ""Rescan the wallet for transactions""},
                },
                RPCResults{},
                RPCExamples{
            ""\\nImport a public key with rescan\\n""
            + HelpExampleCli(""importpubkey"", ""\\""mypubkey\\"""") +
            ""\\nImport using a label without rescan\\n""
            + HelpExampleCli(""importpubkey"", ""\\""mypubkey\\"" \\""testing\\"" false"") +
            ""\\nAs a JSON-RPC call\\n""
            + HelpExampleRpc(""importpubkey"", ""\\""mypubkey\\"", \\""testing\\"", false"")
                },
            }.Check(request);


    std::string strLabel;
    if (!request.params[1].isNull())
        strLabel = request.params[1].get_str();

    // Whether to perform rescan after import
    bool fRescan = true;
    if (!request.params[2].isNull())
        fRescan = request.params[2].get_bool();

    if (fRescan && pwallet->chain().havePruned()) {
        // Exit early and print an error.
        // If a block is pruned after this check, we will import the key(s),
        // but fail the rescan with a generic error.
        throw JSONRPCError(RPC_WALLET_ERROR, ""Rescan is disabled when blocks are pruned"");
    }

    WalletRescanReserver reserver(pwallet);
    if (fRescan && !reserver.reserve()) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Wallet is currently rescanning. Abort existing rescan or wait."");
    }

    if (!IsHex(request.params[0].get_str()))
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Pubkey must be a hex string"");
    std::vector<unsigned char> data(ParseHex(request.params[0].get_str()));
    CPubKey pubKey(data.begin(), data.end());
    if (!pubKey.IsFullyValid())
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Pubkey is not a valid public key"");

    {
        auto locked_chain = pwallet->chain().lock();
        LOCK(pwallet->cs_wallet);

        std::set<CScript> script_pub_keys;
        for (const auto& dest : GetAllDestinationsForKey(pubKey)) {
            script_pub_keys.insert(GetScriptForDestination(dest));
        }

        pwallet->MarkDirty();

        pwallet->ImportScriptPubKeys(strLabel, script_pub_keys, true /* have_solving_data */, true /* apply_label */, 1 /* timestamp */);

        pwallet->ImportPubKeys({pubKey.GetID()}, {{pubKey.GetID(), pubKey}} , {} /* key_origins */, false /* add_keypool */, false /* internal */, 1 /* timestamp */);
    }
    if (fRescan)
    {
        RescanWallet(*pwallet, reserver);
        {
            auto locked_chain = pwallet->chain().lock();
            LOCK(pwallet->cs_wallet);
            pwallet->ReacceptWalletTransactions(*locked_chain);
        }
    }

    return NullUniValue;
}


UniValue importwallet(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importwallet"",
                ""\\nImports keys from a wallet dump file (see dumpwallet). Requires a new wallet backup to include imported keys.\\n""
                ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {
                    {""filename"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The wallet file""},
                },
                RPCResults{},
                RPCExamples{
            ""\\nDump the wallet\\n""
            + HelpExampleCli(""dumpwallet"", ""\\""test\\"""") +
            ""\\nImport the wallet\\n""
            + HelpExampleCli(""importwallet"", ""\\""test\\"""") +
            ""\\nImport using the json rpc call\\n""
            + HelpExampleRpc(""importwallet"", ""\\""test\\"""")
                },
            }.Check(request);

    if (pwallet->chain().havePruned()) {
        // Exit early and print an error.
        // If a block is pruned after this check, we will import the key(s),
        // but fail the rescan with a generic error.
        throw JSONRPCError(RPC_WALLET_ERROR, ""Importing wallets is disabled when blocks are pruned"");
    }

    WalletRescanReserver reserver(pwallet);
    if (!reserver.reserve()) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Wallet is currently rescanning. Abort existing rescan or wait."");
    }

    int64_t nTimeBegin = 0;
    bool fGood = true;
    {
        auto locked_chain = pwallet->chain().lock();
        LOCK(pwallet->cs_wallet);

        EnsureWalletIsUnlocked(pwallet);

        fsbridge::ifstream file;
        file.open(request.params[0].get_str(), std::ios::in | std::ios::ate);
        if (!file.is_open()) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Cannot open wallet dump file"");
        }
        Optional<int> tip_height = locked_chain->getHeight();
        nTimeBegin = tip_height ? locked_chain->getBlockTime(*tip_height) : 0;

        int64_t nFilesize = std::max((int64_t)1, (int64_t)file.tellg());
        file.seekg(0, file.beg);

        // Use uiInterface.ShowProgress instead of pwallet.ShowProgress because pwallet.ShowProgress has a cancel button tied to AbortRescan which
        // we don't want for this progress bar showing the import progress. uiInterface.ShowProgress does not have a cancel button.
        pwallet->chain().showProgress(strprintf(""%s "" + _(""Importing..."").translated, pwallet->GetDisplayName()), 0, false); // show progress dialog in GUI
        std::vector<std::tuple<CKey, int64_t, bool, std::string>> keys;
        std::vector<std::pair<CScript, int64_t>> scripts;
        while (file.good()) {
            pwallet->chain().showProgress("""", std::max(1, std::min(50, (int)(((double)file.tellg() / (double)nFilesize) * 100))), false);
            std::string line;
            std::getline(file, line);
            if (line.empty() || line[0] == '#')
                continue;

            std::vector<std::string> vstr;
            boost::split(vstr, line, boost::is_any_of("" ""));
            if (vstr.size() < 2)
                continue;
            CKey key = DecodeSecret(vstr[0]);
            if (key.IsValid()) {
                int64_t nTime = DecodeDumpTime(vstr[1]);
                std::string strLabel;
                bool fLabel = true;
                for (unsigned int nStr = 2; nStr < vstr.size(); nStr++) {
                    if (vstr[nStr].front() == '#')
                        break;
                    if (vstr[nStr] == ""change=1"")
                        fLabel = false;
                    if (vstr[nStr] == ""reserve=1"")
                        fLabel = false;
                    if (vstr[nStr].substr(0,6) == ""label="") {
                        strLabel = DecodeDumpString(vstr[nStr].substr(6));
                        fLabel = true;
                    }
                }
                keys.push_back(std::make_tuple(key, nTime, fLabel, strLabel));
            } else if(IsHex(vstr[0])) {
                std::vector<unsigned char> vData(ParseHex(vstr[0]));
                CScript script = CScript(vData.begin(), vData.end());
                int64_t birth_time = DecodeDumpTime(vstr[1]);
                scripts.push_back(std::pair<CScript, int64_t>(script, birth_time));
            }
        }
        file.close();
        // We now know whether we are importing private keys, so we can error if private keys are disabled
        if (keys.size() > 0 && pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
            pwallet->chain().showProgress("""", 100, false); // hide progress dialog in GUI
            throw JSONRPCError(RPC_WALLET_ERROR, ""Importing wallets is disabled when private keys are disabled"");
        }
        double total = (double)(keys.size() + scripts.size());
        double progress = 0;
        for (const auto& key_tuple : keys) {
            pwallet->chain().showProgress("""", std::max(50, std::min(75, (int)((progress / total) * 100) + 50)), false);
            const CKey& key = std::get<0>(key_tuple);
            int64_t time = std::get<1>(key_tuple);
            bool has_label = std::get<2>(key_tuple);
            std::string label = std::get<3>(key_tuple);

            CPubKey pubkey = key.GetPubKey();
            assert(key.VerifyPubKey(pubkey));
            CKeyID keyid = pubkey.GetID();

            pwallet->WalletLogPrintf(""Importing %s...\\n"", EncodeDestination(PKHash(keyid)));

            if (!pwallet->ImportPrivKeys({{keyid, key}}, time)) {
                pwallet->WalletLogPrintf(""Error importing key for %s\\n"", EncodeDestination(PKHash(keyid)));
                fGood = false;
                continue;
            }

            if (has_label)
                pwallet->SetAddressBook(PKHash(keyid), label, ""receive"");

            nTimeBegin = std::min(nTimeBegin, time);
            progress++;
        }
        for (const auto& script_pair : scripts) {
            pwallet->chain().showProgress("""", std::max(50, std::min(75, (int)((progress / total) * 100) + 50)), false);
            const CScript& script = script_pair.first;
            int64_t time = script_pair.second;

            if (!pwallet->ImportScripts({script}, time)) {
                pwallet->WalletLogPrintf(""Error importing script %s\\n"", HexStr(script));
                fGood = false;
                continue;
            }
            if (time > 0) {
                nTimeBegin = std::min(nTimeBegin, time);
            }

            progress++;
        }
        pwallet->chain().showProgress("""", 100, false); // hide progress dialog in GUI
    }
    pwallet->chain().showProgress("""", 100, false); // hide progress dialog in GUI
    RescanWallet(*pwallet, reserver, nTimeBegin, false /* update */);
    pwallet->MarkDirty();

    if (!fGood)
        throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding some keys/scripts to wallet"");

    return NullUniValue;
}

UniValue dumpprivkey(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""dumpprivkey"",
                ""\\nReveals the private key corresponding to 'address'.\\n""
                ""Then the importprivkey can be used with this output\\n"",
                {
                    {""address"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The bitcoin address for the private key""},
                },
                RPCResult{
            ""\\""key\\""                (string) The private key\\n""
                },
                RPCExamples{
                    HelpExampleCli(""dumpprivkey"", ""\\""myaddress\\"""")
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"""")
            + HelpExampleRpc(""dumpprivkey"", ""\\""myaddress\\"""")
                },
            }.Check(request);

    auto locked_chain = pwallet->chain().lock();
    LOCK(pwallet->cs_wallet);

    EnsureWalletIsUnlocked(pwallet);

    std::string strAddress = request.params[0].get_str();
    CTxDestination dest = DecodeDestination(strAddress);
    if (!IsValidDestination(dest)) {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid Bitcoin address"");
    }
    auto keyid = GetKeyForDestination(*pwallet, dest);
    if (keyid.IsNull()) {
        throw JSONRPCError(RPC_TYPE_ERROR, ""Address does not refer to a key"");
    }
    CKey vchSecret;
    if (!pwallet->GetKey(keyid, vchSecret)) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Private key for address "" + strAddress + "" is not known"");
    }
    return EncodeSecret(vchSecret);
}


UniValue dumpwallet(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""dumpwallet"",
                ""\\nDumps all wallet keys in a human-readable format to a server-side file. This does not allow overwriting existing files.\\n""
                ""Imported scripts are included in the dumpfile, but corresponding BIP173 addresses, etc. may not be added automatically by importwallet.\\n""
                ""Note that if your wallet contains keys which are not derived from your HD seed (e.g. imported keys), these are not covered by\\n""
                ""only backing up the seed itself, and must be backed up too (e.g. ensure you back up the whole dumpfile).\\n"",
                {
                    {""filename"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The filename with path (either absolute or relative to bitcoind)""},
                },
                RPCResult{
            ""{                           (json object)\\n""
            ""  \\""filename\\"" : {        (string) The filename with full absolute path\\n""
            ""}\\n""
                },
                RPCExamples{
                    HelpExampleCli(""dumpwallet"", ""\\""test\\"""")
            + HelpExampleRpc(""dumpwallet"", ""\\""test\\"""")
                },
            }.Check(request);

    auto locked_chain = pwallet->chain().lock();
    LOCK(pwallet->cs_wallet);

    EnsureWalletIsUnlocked(pwallet);

    fs::path filepath = request.params[0].get_str();
    filepath = fs::absolute(filepath);

    /* Prevent arbitrary files from being overwritten. There have been reports
     * that users have overwritten wallet files this way:
     * https://github.com/bitcoin/bitcoin/issues/9934
     * It may also avoid other security issues.
     */
    if (fs::exists(filepath)) {
        throw JSONRPCError(RPC_INVALID_PARAMETER, filepath.string() + "" already exists. If you are sure this is what you want, move it out of the way first"");
    }

    fsbridge::ofstream file;
    file.open(filepath);
    if (!file.is_open())
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""Cannot open wallet dump file"");

    std::map<CKeyID, int64_t> mapKeyBirth;
    const std::map<CKeyID, int64_t>& mapKeyPool = pwallet->GetAllReserveKeys();
    pwallet->GetKeyBirthTimes(*locked_chain, mapKeyBirth);

    std::set<CScriptID> scripts = pwallet->GetCScripts();

    // sort time/key pairs
    std::vector<std::pair<int64_t, CKeyID> > vKeyBirth;
    for (const auto& entry : mapKeyBirth) {
        vKeyBirth.push_back(std::make_pair(entry.second, entry.first));
    }
    mapKeyBirth.clear();
    std::sort(vKeyBirth.begin(), vKeyBirth.end());

    // produce output
    file << strprintf(""# Wallet dump created by Bitcoin %s\\n"", CLIENT_BUILD);
    file << strprintf(""# * Created on %s\\n"", FormatISO8601DateTime(GetTime()));
    const Optional<int> tip_height = locked_chain->getHeight();
    file << strprintf(""# * Best block at time of backup was %i (%s),\\n"", tip_height.get_value_or(-1), tip_height ? locked_chain->getBlockHash(*tip_height).ToString() : ""(missing block hash)"");
    file << strprintf(""#   mined on %s\\n"", tip_height ? FormatISO8601DateTime(locked_chain->getBlockTime(*tip_height)) : ""(missing block time)"");
    file << ""\\n"";

    // add the base58check encoded extended master if the wallet uses HD
    CKeyID seed_id = pwallet->GetHDChain().seed_id;
    if (!seed_id.IsNull())
    {
        CKey seed;
        if (pwallet->GetKey(seed_id, seed)) {
            CExtKey masterKey;
            masterKey.SetSeed(seed.begin(), seed.size());

            file << ""# extended private masterkey: "" << EncodeExtKey(masterKey) << ""\\n\\n"";
        }
    }
    for (std::vector<std::pair<int64_t, CKeyID> >::const_iterator it = vKeyBirth.begin(); it != vKeyBirth.end(); it++) {
        const CKeyID &keyid = it->second;
        std::string strTime = FormatISO8601DateTime(it->first);
        std::string strAddr;
        std::string strLabel;
        CKey key;
        if (pwallet->GetKey(keyid, key)) {
            file << strprintf(""%s %s "", EncodeSecret(key), strTime);
            if (GetWalletAddressesForKey(pwallet, keyid, strAddr, strLabel)) {
               file << strprintf(""label=%s"", strLabel);
            } else if (keyid == seed_id) {
                file << ""hdseed=1"";
            } else if (mapKeyPool.count(keyid)) {
                file << ""reserve=1"";
            } else if (pwallet->mapKeyMetadata[keyid].hdKeypath == ""s"") {
                file << ""inactivehdseed=1"";
            } else {
                file << ""change=1"";
            }
            file << strprintf("" # addr=%s%s\\n"", strAddr, (pwallet->mapKeyMetadata[keyid].has_key_origin ? "" hdkeypath=""+WriteHDKeypath(pwallet->mapKeyMetadata[keyid].key_origin.path) : """"));
        }
    }
    file << ""\\n"";
    for (const CScriptID &scriptid : scripts) {
        CScript script;
        std::string create_time = ""0"";
        std::string address = EncodeDestination(ScriptHash(scriptid));
        // get birth times for scripts with metadata
        auto it = pwallet->m_script_metadata.find(scriptid);
        if (it != pwallet->m_script_metadata.end()) {
            create_time = FormatISO8601DateTime(it->second.nCreateTime);
        }
        if(pwallet->GetCScript(scriptid, script)) {
            file << strprintf(""%s %s script=1"", HexStr(script.begin(), script.end()), create_time);
            file << strprintf("" # addr=%s\\n"", address);
        }
    }
    file << ""\\n"";
    file << ""# End of dump\\n"";
    file.close();

    UniValue reply(UniValue::VOBJ);
    reply.pushKV(""filename"", filepath.string());

    return reply;
}

struct ImportData
{
    // Input data
    std::unique_ptr<CScript> redeemscript; //!< Provided redeemScript; will be moved to `import_scripts` if relevant.
    std::unique_ptr<CScript> witnessscript; //!< Provided witnessScript; will be moved to `import_scripts` if relevant.

    // Output data
    std::set<CScript> import_scripts;
    std::map<CKeyID, bool> used_keys; //!< Import these private keys if available (the value indicates whether if the key is required for solvability)
    std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>> key_origins;
};

enum class ScriptContext
{
    TOP, //!< Top-level scriptPubKey
    P2SH, //!< P2SH redeemScript
    WITNESS_V0, //!< P2WSH witnessScript
};

// Analyse the provided scriptPubKey, determining which keys and which redeem scripts from the ImportData struct are needed to spend it, and mark them as used.
// Returns an error string, or the empty string for success.
static std::string RecurseImportData(const CScript& script, ImportData& import_data, const ScriptContext script_ctx)
{
    // Use Solver to obtain script type and parsed pubkeys or hashes:
    std::vector<std::vector<unsigned char>> solverdata;
    txnouttype script_type = Solver(script, solverdata);

    switch (script_type) {
    case TX_PUBKEY: {
        CPubKey pubkey(solverdata[0].begin(), solverdata[0].end());
        import_data.used_keys.emplace(pubkey.GetID(), false);
        return """";
    }
    case TX_PUBKEYHASH: {
        CKeyID id = CKeyID(uint160(solverdata[0]));
        import_data.used_keys[id] = true;
        return """";
    }
    case TX_SCRIPTHASH: {
        if (script_ctx == ScriptContext::P2SH) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Trying to nest P2SH inside another P2SH"");
        if (script_ctx == ScriptContext::WITNESS_V0) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Trying to nest P2SH inside a P2WSH"");
        assert(script_ctx == ScriptContext::TOP);
        CScriptID id = CScriptID(uint160(solverdata[0]));
        auto subscript = std::move(import_data.redeemscript); // Remove redeemscript from import_data to check for superfluous script later.
        if (!subscript) return ""missing redeemscript"";
        if (CScriptID(*subscript) != id) return ""redeemScript does not match the scriptPubKey"";
        import_data.import_scripts.emplace(*subscript);
        return RecurseImportData(*subscript, import_data, ScriptContext::P2SH);
    }
    case TX_MULTISIG: {
        for (size_t i = 1; i + 1< solverdata.size(); ++i) {
            CPubKey pubkey(solverdata[i].begin(), solverdata[i].end());
            import_data.used_keys.emplace(pubkey.GetID(), false);
        }
        return """";
    }
    case TX_WITNESS_V0_SCRIPTHASH: {
        if (script_ctx == ScriptContext::WITNESS_V0) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Trying to nest P2WSH inside another P2WSH"");
        uint256 fullid(solverdata[0]);
        CScriptID id;
        CRIPEMD160().Write(fullid.begin(), fullid.size()).Finalize(id.begin());
        auto subscript = std::move(import_data.witnessscript); // Remove redeemscript from import_data to check for superfluous script later.
        if (!subscript) return ""missing witnessscript"";
        if (CScriptID(*subscript) != id) return ""witnessScript does not match the scriptPubKey or redeemScript"";
        if (script_ctx == ScriptContext::TOP) {
            import_data.import_scripts.emplace(script); // Special rule for IsMine: native P2WSH requires the TOP script imported (see script/ismine.cpp)
        }
        import_data.import_scripts.emplace(*subscript);
        return RecurseImportData(*subscript, import_data, ScriptContext::WITNESS_V0);
    }
    case TX_WITNESS_V0_KEYHASH: {
        if (script_ctx == ScriptContext::WITNESS_V0) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Trying to nest P2WPKH inside P2WSH"");
        CKeyID id = CKeyID(uint160(solverdata[0]));
        import_data.used_keys[id] = true;
        if (script_ctx == ScriptContext::TOP) {
            import_data.import_scripts.emplace(script); // Special rule for IsMine: native P2WPKH requires the TOP script imported (see script/ismine.cpp)
        }
        return """";
    }
    case TX_NULL_DATA:
        return ""unspendable script"";
    case TX_NONSTANDARD:
    case TX_WITNESS_UNKNOWN:
    default:
        return ""unrecognized script"";
    }
}

static UniValue ProcessImportLegacy(ImportData& import_data, std::map<CKeyID, CPubKey>& pubkey_map, std::map<CKeyID, CKey>& privkey_map, std::set<CScript>& script_pub_keys, bool& have_solving_data, const UniValue& data, std::vector<CKeyID>& ordered_pubkeys)
{
    UniValue warnings(UniValue::VARR);

    // First ensure scriptPubKey has either a script or JSON with ""address"" string
    const UniValue& scriptPubKey = data[""scriptPubKey""];
    bool isScript = scriptPubKey.getType() == UniValue::VSTR;
    if (!isScript && !(scriptPubKey.getType() == UniValue::VOBJ && scriptPubKey.exists(""address""))) {
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""scriptPubKey must be string with script or JSON with address string"");
    }
    const std::string& output = isScript ? scriptPubKey.get_str() : scriptPubKey[""address""].get_str();

    // Optional fields.
    const std::string& strRedeemScript = data.exists(""redeemscript"") ? data[""redeemscript""].get_str() : """";
    const std::string& witness_script_hex = data.exists(""witnessscript"") ? data[""witnessscript""].get_str() : """";
    const UniValue& pubKeys = data.exists(""pubkeys"") ? data[""pubkeys""].get_array() : UniValue();
    const UniValue& keys = data.exists(""keys"") ? data[""keys""].get_array() : UniValue();
    const bool internal = data.exists(""internal"") ? data[""internal""].get_bool() : false;
    const bool watchOnly = data.exists(""watchonly"") ? data[""watchonly""].get_bool() : false;

    if (data.exists(""range"")) {
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""Range should not be specified for a non-descriptor import"");
    }

    // Generate the script and destination for the scriptPubKey provided
    CScript script;
    if (!isScript) {
        CTxDestination dest = DecodeDestination(output);
        if (!IsValidDestination(dest)) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid address \\"""" + output + ""\\"""");
        }
        script = GetScriptForDestination(dest);
    } else {
        if (!IsHex(output)) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid scriptPubKey \\"""" + output + ""\\"""");
        }
        std::vector<unsigned char> vData(ParseHex(output));
        script = CScript(vData.begin(), vData.end());
        CTxDestination dest;
        if (!ExtractDestination(script, dest) && !internal) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Internal must be set to true for nonstandard scriptPubKey imports."");
        }
    }
    script_pub_keys.emplace(script);

    // Parse all arguments
    if (strRedeemScript.size()) {
        if (!IsHex(strRedeemScript)) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid redeem script \\"""" + strRedeemScript + ""\\"": must be hex string"");
        }
        auto parsed_redeemscript = ParseHex(strRedeemScript);
        import_data.redeemscript = MakeUnique<CScript>(parsed_redeemscript.begin(), parsed_redeemscript.end());
    }
    if (witness_script_hex.size()) {
        if (!IsHex(witness_script_hex)) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid witness script \\"""" + witness_script_hex + ""\\"": must be hex string"");
        }
        auto parsed_witnessscript = ParseHex(witness_script_hex);
        import_data.witnessscript = MakeUnique<CScript>(parsed_witnessscript.begin(), parsed_witnessscript.end());
    }
    for (size_t i = 0; i < pubKeys.size(); ++i) {
        const auto& str = pubKeys[i].get_str();
        if (!IsHex(str)) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Pubkey \\"""" + str + ""\\"" must be a hex string"");
        }
        auto parsed_pubkey = ParseHex(str);
        CPubKey pubkey(parsed_pubkey.begin(), parsed_pubkey.end());
        if (!pubkey.IsFullyValid()) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Pubkey \\"""" + str + ""\\"" is not a valid public key"");
        }
        pubkey_map.emplace(pubkey.GetID(), pubkey);
        ordered_pubkeys.push_back(pubkey.GetID());
    }
    for (size_t i = 0; i < keys.size(); ++i) {
        const auto& str = keys[i].get_str();
        CKey key = DecodeSecret(str);
        if (!key.IsValid()) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid private key encoding"");
        }
        CPubKey pubkey = key.GetPubKey();
        CKeyID id = pubkey.GetID();
        if (pubkey_map.count(id)) {
            pubkey_map.erase(id);
        }
        privkey_map.emplace(id, key);
    }


    // Verify and process input data
    have_solving_data = import_data.redeemscript || import_data.witnessscript || pubkey_map.size() || privkey_map.size();
    if (have_solving_data) {
        // Match up data in import_data with the scriptPubKey in script.
        auto error = RecurseImportData(script, import_data, ScriptContext::TOP);

        // Verify whether the watchonly option corresponds to the availability of private keys.
        bool spendable = std::all_of(import_data.used_keys.begin(), import_data.used_keys.end(), [&](const std::pair<CKeyID, bool>& used_key){ return privkey_map.count(used_key.first) > 0; });
        if (!watchOnly && !spendable) {
            warnings.push_back(""Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."");
        }
        if (watchOnly && spendable) {
            warnings.push_back(""All private keys are provided, outputs will be considered spendable. If this is intentional, do not specify the watchonly flag."");
        }

        // Check that all required keys for solvability are provided.
        if (error.empty()) {
            for (const auto& require_key : import_data.used_keys) {
                if (!require_key.second) continue; // Not a required key
                if (pubkey_map.count(require_key.first) == 0 && privkey_map.count(require_key.first) == 0) {
                    error = ""some required keys are missing"";
                }
            }
        }

        if (!error.empty()) {
            warnings.push_back(""Importing as non-solvable: "" + error + "". If this is intentional, don't provide any keys, pubkeys, witnessscript, or redeemscript."");
            import_data = ImportData();
            pubkey_map.clear();
            privkey_map.clear();
            have_solving_data = false;
        } else {
            // RecurseImportData() removes any relevant redeemscript/witnessscript from import_data, so we can use that to discover if a superfluous one was provided.
            if (import_data.redeemscript) warnings.push_back(""Ignoring redeemscript as this is not a P2SH script."");
            if (import_data.witnessscript) warnings.push_back(""Ignoring witnessscript as this is not a (P2SH-)P2WSH script."");
            for (auto it = privkey_map.begin(); it != privkey_map.end(); ) {
                auto oldit = it++;
                if (import_data.used_keys.count(oldit->first) == 0) {
                    warnings.push_back(""Ignoring irrelevant private key."");
                    privkey_map.erase(oldit);
                }
            }
            for (auto it = pubkey_map.begin(); it != pubkey_map.end(); ) {
                auto oldit = it++;
                auto key_data_it = import_data.used_keys.find(oldit->first);
                if (key_data_it == import_data.used_keys.end() || !key_data_it->second) {
                    warnings.push_back(""Ignoring public key \\"""" + HexStr(oldit->first) + ""\\"" as it doesn't appear inside P2PKH or P2WPKH."");
                    pubkey_map.erase(oldit);
                }
            }
        }
    }

    return warnings;
}

static UniValue ProcessImportDescriptor(ImportData& import_data, std::map<CKeyID, CPubKey>& pubkey_map, std::map<CKeyID, CKey>& privkey_map, std::set<CScript>& script_pub_keys, bool& have_solving_data, const UniValue& data, std::vector<CKeyID>& ordered_pubkeys)
{
    UniValue warnings(UniValue::VARR);

    const std::string& descriptor = data[""desc""].get_str();
    FlatSigningProvider keys;
    std::string error;
    auto parsed_desc = Parse(descriptor, keys, error, /* require_checksum = */ true);
    if (!parsed_desc) {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
    }

    have_solving_data = parsed_desc->IsSolvable();
    const bool watch_only = data.exists(""watchonly"") ? data[""watchonly""].get_bool() : false;

    int64_t range_start = 0, range_end = 0;
    if (!parsed_desc->IsRange() && data.exists(""range"")) {
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""Range should not be specified for an un-ranged descriptor"");
    } else if (parsed_desc->IsRange()) {
        if (!data.exists(""range"")) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Descriptor is ranged, please specify the range"");
        }
        std::tie(range_start, range_end) = ParseDescriptorRange(data[""range""]);
    }

    const UniValue& priv_keys = data.exists(""keys"") ? data[""keys""].get_array() : UniValue();

    // Expand all descriptors to get public keys and scripts, and private keys if available.
    for (int i = range_start; i <= range_end; ++i) {
        FlatSigningProvider out_keys;
        std::vector<CScript> scripts_temp;
        parsed_desc->Expand(i, keys, scripts_temp, out_keys);
        std::copy(scripts_temp.begin(), scripts_temp.end(), std::inserter(script_pub_keys, script_pub_keys.end()));
        for (const auto& key_pair : out_keys.pubkeys) {
            ordered_pubkeys.push_back(key_pair.first);
        }

        for (const auto& x : out_keys.scripts) {
            import_data.import_scripts.emplace(x.second);
        }

        parsed_desc->ExpandPrivate(i, keys, out_keys);

        std::copy(out_keys.pubkeys.begin(), out_keys.pubkeys.end(), std::inserter(pubkey_map, pubkey_map.end()));
        std::copy(out_keys.keys.begin(), out_keys.keys.end(), std::inserter(privkey_map, privkey_map.end()));
        import_data.key_origins.insert(out_keys.origins.begin(), out_keys.origins.end());
    }

    for (size_t i = 0; i < priv_keys.size(); ++i) {
        const auto& str = priv_keys[i].get_str();
        CKey key = DecodeSecret(str);
        if (!key.IsValid()) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid private key encoding"");
        }
        CPubKey pubkey = key.GetPubKey();
        CKeyID id = pubkey.GetID();

        // Check if this private key corresponds to a public key from the descriptor
        if (!pubkey_map.count(id)) {
            warnings.push_back(""Ignoring irrelevant private key."");
        } else {
            privkey_map.emplace(id, key);
        }
    }

    // Check if all the public keys have corresponding private keys in the import for spendability.
    // This does not take into account threshold multisigs which could be spendable without all keys.
    // Thus, threshold multisigs without all keys will be considered not spendable here, even if they are,
    // perhaps triggering a false warning message. This is consistent with the current wallet IsMine check.
    bool spendable = std::all_of(pubkey_map.begin(), pubkey_map.end(),
        [&](const std::pair<CKeyID, CPubKey>& used_key) {
            return privkey_map.count(used_key.first) > 0;
        }) && std::all_of(import_data.key_origins.begin(), import_data.key_origins.end(),
        [&](const std::pair<CKeyID, std::pair<CPubKey, KeyOriginInfo>>& entry) {
            return privkey_map.count(entry.first) > 0;
        });
    if (!watch_only && !spendable) {
        warnings.push_back(""Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."");
    }
    if (watch_only && spendable) {
        warnings.push_back(""All private keys are provided, outputs will be considered spendable. If this is intentional, do not specify the watchonly flag."");
    }

    return warnings;
}

static UniValue ProcessImport(CWallet * const pwallet, const UniValue& data, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
{
    UniValue warnings(UniValue::VARR);
    UniValue result(UniValue::VOBJ);

    try {
        const bool internal = data.exists(""internal"") ? data[""internal""].get_bool() : false;
        // Internal addresses should not have a label
        if (internal && data.exists(""label"")) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Internal addresses should not have a label"");
        }
        const std::string& label = data.exists(""label"") ? data[""label""].get_str() : """";
        const bool add_keypool = data.exists(""keypool"") ? data[""keypool""].get_bool() : false;

        // Add to keypool only works with privkeys disabled
        if (add_keypool && !pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Keys can only be imported to the keypool when private keys are disabled"");
        }

        ImportData import_data;
        std::map<CKeyID, CPubKey> pubkey_map;
        std::map<CKeyID, CKey> privkey_map;
        std::set<CScript> script_pub_keys;
        std::vector<CKeyID> ordered_pubkeys;
        bool have_solving_data;

        if (data.exists(""scriptPubKey"") && data.exists(""desc"")) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Both a descriptor and a scriptPubKey should not be provided."");
        } else if (data.exists(""scriptPubKey"")) {
            warnings = ProcessImportLegacy(import_data, pubkey_map, privkey_map, script_pub_keys, have_solving_data, data, ordered_pubkeys);
        } else if (data.exists(""desc"")) {
            warnings = ProcessImportDescriptor(import_data, pubkey_map, privkey_map, script_pub_keys, have_solving_data, data, ordered_pubkeys);
        } else {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Either a descriptor or scriptPubKey must be provided."");
        }

        // If private keys are disabled, abort if private keys are being imported
        if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) && !privkey_map.empty()) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Cannot import private keys to a wallet with private keys disabled"");
        }

        // Check whether we have any work to do
        for (const CScript& script : script_pub_keys) {
            if (::IsMine(*pwallet, script) & ISMINE_SPENDABLE) {
                throw JSONRPCError(RPC_WALLET_ERROR, ""The wallet already contains the private key for this address or script (\\"""" + HexStr(script.begin(), script.end()) + ""\\"")"");
            }
        }

        // All good, time to import
        pwallet->MarkDirty();
        if (!pwallet->ImportScripts(import_data.import_scripts, timestamp)) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding script to wallet"");
        }
        if (!pwallet->ImportPrivKeys(privkey_map, timestamp)) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding key to wallet"");
        }
        if (!pwallet->ImportPubKeys(ordered_pubkeys, pubkey_map, import_data.key_origins, add_keypool, internal, timestamp)) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding address to wallet"");
        }
        if (!pwallet->ImportScriptPubKeys(label, script_pub_keys, have_solving_data, !internal, timestamp)) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding address to wallet"");
        }

        result.pushKV(""success"", UniValue(true));
    } catch (const UniValue& e) {
        result.pushKV(""success"", UniValue(false));
        result.pushKV(""error"", e);
    } catch (...) {
        result.pushKV(""success"", UniValue(false));

        result.pushKV(""error"", JSONRPCError(RPC_MISC_ERROR, ""Missing required fields""));
    }
    if (warnings.size()) result.pushKV(""warnings"", warnings);
    return result;
}

static int64_t GetImportTimestamp(const UniValue& data, int64_t now)
{
    if (data.exists(""timestamp"")) {
        const UniValue& timestamp = data[""timestamp""];
        if (timestamp.isNum()) {
            return timestamp.get_int64();
        } else if (timestamp.isStr() && timestamp.get_str() == ""now"") {
            return now;
        }
        throw JSONRPCError(RPC_TYPE_ERROR, strprintf(""Expected number or \\""now\\"" timestamp value for key. got type %s"", uvTypeName(timestamp.type())));
    }
    throw JSONRPCError(RPC_TYPE_ERROR, ""Missing required timestamp field for key"");
}

UniValue importmulti(const JSONRPCRequest& mainRequest)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(mainRequest);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, mainRequest.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importmulti"",
                ""\\nImport addresses/scripts (with private or public keys, redeem script (P2SH)), optionally rescanning the blockchain from the earliest creation time of the imported scripts. Requires a new wallet backup.\\n""
                ""If an address/script is imported without all of the private keys required to spend from that address, it will be watchonly. The 'watchonly' option must be set to true in this case or a warning will be returned.\\n""
                ""Conversely, if all the private keys are provided and the address/script is spendable, the watchonly option must be set to false, or a warning will be returned.\\n""
            ""\\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\\n""
            ""may report that the imported keys, addresses or scripts exist but related transactions are still missing.\\n""
            ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {
                    {""requests"", RPCArg::Type::ARR, RPCArg::Optional::NO, ""Data to be imported"",
                        {
                            {"""", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, """",
                                {
                                    {""desc"", RPCArg::Type::STR, RPCArg::Optional::OMITTED, ""Descriptor to import. If using descriptor, do not also provide address/scriptPubKey, scripts, or pubkeys""},
                                    {""scriptPubKey"", RPCArg::Type::STR, RPCArg::Optional::NO, ""Type of scriptPubKey (string for script, json for address). Should not be provided if using a descriptor"",
                                        /* oneline_description */ """", {""\\""<script>\\"" | { \\""address\\"":\\""<address>\\"" }"", ""string / json""}
                                    },
                                    {""timestamp"", RPCArg::Type::NUM, RPCArg::Optional::NO, ""Creation time of the key in seconds since epoch (Jan 1 1970 GMT),\\n""
        ""                                                              or the string \\""now\\"" to substitute the current synced blockchain time. The timestamp of the oldest\\n""
        ""                                                              key will determine how far back blockchain rescans need to begin for missing wallet transactions.\\n""
        ""                                                              \\""now\\"" can be specified to bypass scanning, for keys which are known to never have been used, and\\n""
        ""                                                              0 can be specified to scan the entire blockchain. Blocks up to 2 hours before the earliest key\\n""
        ""                                                              creation time of all keys being imported by the importmulti call will be scanned."",
                                        /* oneline_description */ """", {""timestamp | \\""now\\"""", ""integer / string""}
                                    },
                                    {""redeemscript"", RPCArg::Type::STR, RPCArg::Optional::OMITTED, ""Allowed only if the scriptPubKey is a P2SH or P2SH-P2WSH address/scriptPubKey""},
                                    {""witnessscript"", RPCArg::Type::STR, RPCArg::Optional::OMITTED, ""Allowed only if the scriptPubKey is a P2SH-P2WSH or P2WSH address/scriptPubKey""},
                                    {""pubkeys"", RPCArg::Type::ARR, /* default */ ""empty array"", ""Array of strings giving pubkeys to import. They must occur in P2PKH or P2WPKH scripts. They are not required when the private key is also provided (see the \\""keys\\"" argument)."",
                                        {
                                            {""pubKey"", RPCArg::Type::STR, RPCArg::Optional::OMITTED, """"},
                                        }
                                    },
                                    {""keys"", RPCArg::Type::ARR, /* default */ ""empty array"", ""Array of strings giving private keys to import. The corresponding public keys must occur in the output or redeemscript."",
                                        {
                                            {""key"", RPCArg::Type::STR, RPCArg::Optional::OMITTED, """"},
                                        }
                                    },
                                    {""range"", RPCArg::Type::RANGE, RPCArg::Optional::OMITTED, ""If a ranged descriptor is used, this specifies the end or the range (in the form [begin,end]) to import""},
                                    {""internal"", RPCArg::Type::BOOL, /* default */ ""false"", ""Stating whether matching outputs should be treated as not incoming payments (also known as change)""},
                                    {""watchonly"", RPCArg::Type::BOOL, /* default */ ""false"", ""Stating whether matching outputs should be considered watchonly.""},
                                    {""label"", RPCArg::Type::STR, /* default */ ""''"", ""Label to assign to the address, only allowed with internal=false""},
                                    {""keypool"", RPCArg::Type::BOOL, /* default */ ""false"", ""Stating whether imported public keys should be added to the keypool for when users request new addresses. Only allowed when wallet private keys are disabled""},
                                },
                            },
                        },
                        ""\\""requests\\""""},
                    {""options"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED_NAMED_ARG, """",
                        {
                            {""rescan"", RPCArg::Type::BOOL, /* default */ ""true"", ""Stating if should rescan the blockchain after all imports""},
                        },
                        ""\\""options\\""""},
                },
                RPCResult{
            ""\\nResponse is an array with the same size as the input that has the execution result :\\n""
            ""  [{\\""success\\"": true}, {\\""success\\"": true, \\""warnings\\"": [\\""Ignoring irrelevant private key\\""]}, {\\""success\\"": false, \\""error\\"": {\\""code\\"": -1, \\""message\\"": \\""Internal Server Error\\""}}, ...]\\n""
                },
                RPCExamples{
                    HelpExampleCli(""importmulti"", ""'[{ \\""scriptPubKey\\"": { \\""address\\"": \\""<my address>\\"" }, \\""timestamp\\"":1455191478 }, ""
                                          ""{ \\""scriptPubKey\\"": { \\""address\\"": \\""<my 2nd address>\\"" }, \\""label\\"": \\""example 2\\"", \\""timestamp\\"": 1455191480 }]'"") +
                    HelpExampleCli(""importmulti"", ""'[{ \\""scriptPubKey\\"": { \\""address\\"": \\""<my address>\\"" }, \\""timestamp\\"":1455191478 }]' '{ \\""rescan\\"": false}'"")
                },
            }.Check(mainRequest);


    RPCTypeCheck(mainRequest.params, {UniValue::VARR, UniValue::VOBJ});

    const UniValue& requests = mainRequest.params[0];

    //Default options
    bool fRescan = true;

    if (!mainRequest.params[1].isNull()) {
        const UniValue& options = mainRequest.params[1];

        if (options.exists(""rescan"")) {
            fRescan = options[""rescan""].get_bool();
        }
    }

    WalletRescanReserver reserver(pwallet);
    if (fRescan && !reserver.reserve()) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Wallet is currently rescanning. Abort existing rescan or wait."");
    }

    int64_t now = 0;
    bool fRunScan = false;
    int64_t nLowestTimestamp = 0;
    UniValue response(UniValue::VARR);
    {
        auto locked_chain = pwallet->chain().lock();
        LOCK(pwallet->cs_wallet);
        EnsureWalletIsUnlocked(pwallet);

        // Verify all timestamps are present before importing any keys.
        const Optional<int> tip_height = locked_chain->getHeight();
        now = tip_height ? locked_chain->getBlockMedianTimePast(*tip_height) : 0;
        for (const UniValue& data : requests.getValues()) {
            GetImportTimestamp(data, now);
        }

        const int64_t minimumTimestamp = 1;

        if (fRescan && tip_height) {
            nLowestTimestamp = locked_chain->getBlockTime(*tip_height);
        } else {
            fRescan = false;
        }

        for (const UniValue& data : requests.getValues()) {
            const int64_t timestamp = std::max(GetImportTimestamp(data, now), minimumTimestamp);
            const UniValue result = ProcessImport(pwallet, data, timestamp);
            response.push_back(result);

            if (!fRescan) {
                continue;
            }

            // If at least one request was successful then allow rescan.
            if (result[""success""].get_bool()) {
                fRunScan = true;
            }

            // Get the lowest timestamp.
            if (timestamp < nLowestTimestamp) {
                nLowestTimestamp = timestamp;
            }
        }
    }
    if (fRescan && fRunScan && requests.size()) {
        int64_t scannedTime = pwallet->RescanFromTime(nLowestTimestamp, reserver, true /* update */);
        {
            auto locked_chain = pwallet->chain().lock();
            LOCK(pwallet->cs_wallet);
            pwallet->ReacceptWalletTransactions(*locked_chain);
        }

        if (pwallet->IsAbortingRescan()) {
            throw JSONRPCError(RPC_MISC_ERROR, ""Rescan aborted by user."");
        }
        if (scannedTime > nLowestTimestamp) {
            std::vector<UniValue> results = response.getValues();
            response.clear();
            response.setArray();
            size_t i = 0;
            for (const UniValue& request : requests.getValues()) {
                // If key creation date is within the successfully scanned
                // range, or if the import result already has an error set, let
                // the result stand unmodified. Otherwise replace the result
                // with an error message.
                if (scannedTime <= GetImportTimestamp(request, now) || results.at(i).exists(""error"")) {
                    response.push_back(results.at(i));
                } else {
                    UniValue result = UniValue(UniValue::VOBJ);
                    result.pushKV(""success"", UniValue(false));
                    result.pushKV(
                        ""error"",
                        JSONRPCError(
                            RPC_MISC_ERROR,
                            strprintf(""Rescan failed for key with creation timestamp %d. There was an error reading a ""
                                      ""block from time %d, which is after or within %d seconds of key creation, and ""
                                      ""could contain transactions pertaining to the key. As a result, transactions ""
                                      ""and coins using this key may not appear in the wallet. This error could be ""
                                      ""caused by pruning or data corruption (see bitcoind log for details) and could ""
                                      ""be dealt with by downloading and rescanning the relevant blocks (see -reindex ""
                                      ""and -rescan options)."",
                                GetImportTimestamp(request, now), scannedTime - TIMESTAMP_WINDOW - 1, TIMESTAMP_WINDOW)));
                    response.push_back(std::move(result));
                }
                ++i;
            }
        }
    }

    return response;
}
",16139,True,3102.0295428433806,median
"

////
* Copyright 2014-2022 Real Logic Limited.
*
* 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
*
* https://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.
////

= Aeron Cluster Tutorial
:sampleBaseDir: ../../..
:sampleSourceDir: {sampleBaseDir}/src/main/java
:aeronVersion: [aeronVersion]
:sectnums:
:source-highlighter: prettify
:autofit-option:

IMPORTANT: This tutorial is currently a work in progress, information may be missing or incomplete.

This tutorial assumes that the user already has a basic working knowledge of Aeron Messaging.

== Introduction

Aeron Cluster is a framework for high-performance in memory fault tolerant services. It implements the
https://raft.github.io/[Raft Consensus Algorithm] to provide log replication, to allow multiple nodes to maintain the
same state and automated leader election to ensure that there is a single leader within the cluster. Systems built using
Aeron Cluster have a linearizable consistency model and can cope with partial system failure, including failure of the
leader node, as long as a quorum of `(n / 2) + 1` nodes remain available.

=== Raft Basics

It is not the intention of this tutorial to go into a full description of the https://raft.github.io/[Raft Consensus
Algorithm], however it is difficult explain Aeron Cluster without a few definitions up front. The key concepts
are (some are Aeron specific):

- Node, a physical server, container instance, VM or group of processes that represents a logical server within a
cluster.
- Leader, a node within the cluster responsible for replicating messages to the other nodes and waiting for
acknowledgements.
- Follower, other nodes within the cluster that receive messages replicated from the leader.
- Election, process by which the cluster agrees on a new leader.
- Client, node external to the cluster.
- Ingress, the messages from a client into the cluster.
- Egress, response messages from the cluster back to a client.
- Snapshot, serialised representation of the application logic's state at a point in time.

=== Replication and Recovery

Within Aeron Cluster, replication (ensuring that a follower node has the same state as the leader) and recovery
(restoring a stopped node to its previous state)footnote:[Where stopping could include crashing or manually shutting
down] are the same problem, or at least at similar enough, to use the same mechanism. They rely on three functions.
Firstly, for some known initial state, this could either be the state when first provisioned (a 'null' or empty state), or
some snapshot of state at a point in time. Secondly, an ordered log of all input messages, this is handled by Cluster's
Raft implementation. Thirdly, the application logic needs to be deterministic, i.e. it must derive all of its resulting
state and output events from the initial state, and the input messages, such that for the same inputs it will always get
the same result. This can be a trickier than it first seems as it excludes some functionality that we may normally take
for granted.

[TIP]
====
Be careful to ensure determinism in clustered service, common pitfalls include:

- Timestamps
- Random Numbers
- Reading from configuration files.
- Iterating over some types of collections, e.g. HashMaps.
====

Time, as timestamps, is provided by Aeron Cluster (will be shown later). Random numbers are best avoided or use a seed
fixed in the initial state or via a message. Configuration changes should be pushed into the application logic via
messages. Iterating over collections should happen in a known order, with a collection that preserves ordering (e.g.
TreeMap, LinkedHashMap) through sorting the values from the collection before sending them as messages. Alternatively,
the Agrona collections can be used with their consistent iteration order and low allocation characteristics.

As it may be impractical to replay all data from the ""beginning of time"" the system should take snapshots periodically,
e.g. daily or hourly. The frequency of snapshots should be determined by the volume of data into the
system, the throughput of the business logic, and the desired mean time to recovery. It is not uncommon to have systems
that may take an hour or two to recover from a days worth of messages, in those systems snapshotting every 30 minutes
may be more appropriate.

=== Components of Aeron Cluster

One of the key design goals of Aeron is to build a system that is highly composable. For example, Aeron Archive which
provides a means to persist the Raft log created by Aeron Cluster. Aeron Cluster sends messages via a Media Driver.
Therefore, Aeron Cluster is an aggregation of a number of existing Aeron components and a few new ones. To successfully
run a cluster node it is necessary to have one (or at least one in the case of ClusteredServiceContainer) of each of
the Aeron components running. Because all communication between these components within a single node uses IPC they can
be run all in the same process, in separate processes or any arbitrary combination.

==== MediaDriver

The MediaDriver is the means by which the cluster communicates. Aeron Cluster reuses the Publication, Subscription, and
Counter functionality in Aeron to handle all distributed and inter-process communication.

NOTE: Currently, only the Java implementation of the MediaDriver is supported for use in Aeron Cluster.

==== Archive

Raft is primarily a log replication protocol, so Aeron Cluster uses Aeron Archive to persist its log.

==== ConsensusModule

The Consensus Module is the key component with Aeron Cluster and ensures the nodes have a consistent copy of the
replicated log. The Consensus Module will coordinate with the Archive to persist messages, replicate/ack messages
to/from other nodes and deliver messages through to the Clustered Services.

==== ClusteredServiceContainer

This is the service running the developer supplied application logic. There can be one or more clustered services per
node. Aeron Cluster provides a container for the application logic. There is a ClusteredService interface that must be
implemented by the application to receive the events and messages from Cluster.

== Getting Started Aeron Cluster

Install JDK 8 or JDK 11 and ensure that `$JAVA_HOME` is set and `$JAVA_HOME/bin` is on your `$PATH`.

The typical way to get started with Aeron in your own application is to use the
https://search.maven.org/artifact/io.aeron/aeron-all[aeron-all jar]. However, for this tutorial we are going to
recommend that you check out the source code from Github.

[#usingthesource]
=== Using the Source From this Tutorial

In order to look at the examples and run the code from this tutorial you will need to checkout the full Aeron source
code, use the appropriate release version and build the projects.

[subs = ""attributes+""]
----
> git clone https://github.com/real-logic/aeron.git
> cd aeron
> git checkout -b my_tutorial {aeronVersion}
> ./gradlew
----

The location on your computer where this has been checked out to will be referred to as `<AERON_HOME>`.

This tutorial will include snippets of code from the working example. The scripts and classes for this tutorial are:

 * <AERON_HOME>/aeron-samples/src/main/java/io/aeron/samples/tutorial/cluster/
 ** BasicAuctionClusteredService.java
 ** BasicAuctionClusteredServiceNode.java
 ** BasicAuctionClusterClient.java
 * <AERON_HOME>/aeron-samples/scripts/cluster/
 ** basic-auction-cluster
 ** basic-auction-client

You may wish to open these up in your favourite IDE or editor while we proceed with the tutorial.

== Implementing a Clustered Service

The first step to setting up a cluster is to implement the application logic. For this tutorial we are going to
implement simple auction service. It will have one auction and will track the best price, and an id for the customer
who bid that price. To properly demonstrate the state management and recovery features of cluster it is important to
have some functionality that is stateful, rather than something that is stateless like an echo service.

NOTE: In order to understandably show the various features of Cluster, we've kept the various aspects of the code
(data serialisation, application logic, Cluster integration) very close together. It is unlikely you would do this in a
real world application. You would probably want to have greater separation of concerns and perhaps use libraries to
handle functionality like serialisation.

We must define the link between the application logic and Aeron Cluster. This is done by implementing the
`ClusteredService` interface. The `ClusteredService` interface defines a number of callbacks which deliver messages
and lifecycle events as they occur, as well as providing the hooks that our service can use to interact with the
cluster (e.g. sending response messages and taking snapshots).

[source, Java, indent=0, options=""nowrap""]
----
include::{sampleSourceDir}/io/aeron/samples/cluster/tutorial/BasicAuctionClusteredService.java[tag=new_service]
----

=== Start Up

The clustered service container will notify the service it has started using the `onStart` callback. This will occur
before input messages are received, either from log replay or live from a client. It is during this phase that we need
to load the initial state of the service. Aeron Cluster passes in an `Image` that will contain the most recent valid
snapshot of the service. The service should take care of deserializing the data from the image and initialize its state.
We will come back to the details of how the snapshot is loaded after we've looked how messages are handled and how a
snapshot is stored.

[source, Java, indent=0, options=""nowrap""]
----
include::{sampleSourceDir}/io/aeron/samples/cluster/tutorial/BasicAuctionClusteredService.java[tag=start]
----

<1> Take a reference to the cluster, so that we can have access to features of the cluster within the other callbacks.

<2> Take a reference to the cluster's idle strategy. This will be used anytime we enter a busy loop within service.

<3> The snapshot can be null (this occurs the first time the service is started).

=== Handling Messages

The `onSessionMessage` callback is the main entry point for requests coming into the cluster. Messages reach here by
being published to Cluster's ingress channel. This method will also be passed messages during log replay. It is from
within this method we will interact with our application logic. Cluster also provides a reliable timestamp as a
parameter to this method. As mentioned earlier this is one of the challenges of building deterministic systems. Use
this value as the timestamp within your application state, so it will be consistent under replay.

[source, Java, indent=0, options=""nowrap""]
----
include::{sampleSourceDir}/io/aeron/samples/cluster/tutorial/BasicAuctionClusteredService.java[tag=state]
----
[source, Java, indent=0, options=""nowrap""]
----
include::{sampleSourceDir}/io/aeron/samples/cluster/tutorial/BasicAuctionClusteredService.java[tag=message]
----

For our input message we have 3 fields, a `correlationId` which is the customer supplied identifier for the message,
`customerId` to identify the customer placing the bid, and a `price` (we've used a long for this, which represents the
value in cents).

<1> Pull the data out of the message. This is similar to the pattern used in an Aeron Subscription's `onFragment`
callback when doing a poll.

<2> Execute the business logic, in our case this is applying the incoming bid to the auction to see if it is a winner.

<3> The `ClientSession` allows the service to get information about the calling client, but also provide a means to
return responses back to the client.

<4> Serialise response message.

<5> Calling `offer` on the client session will send the response on the egress channel. Make sure to check the return
value of `offer` as it is a non-blocking call and not guaranteed to succeed.

<6> When doing any busy loops within the clustered application use the Cluster's `IdleStrategy::idle(int)` within the
wait loop to allow the service to wait while allowing other threads to progress. It will take care of handling thread
interrupts and ensure the node fails correctly.

=== Storing State

As was mentioned earlier we need to regularly take snapshots of the service's state in order to reduce the mean time to
recovery and facilitate release migration. There is a callback `onTakeSnapshot` that will be called when it is time to
snapshot the state of the service.

Aeron Cluster provides an `ExclusivePublication` to write a snapshot as the serialised representation of the application
logic's state. For real world applications snapshotting can become tricky. The two big concerns you have includes:
ensuring that you consistently write snapshots, and dealing with fragmentation of the application state across messages.
For now, our state is so simple neither of those will impact us.

[source%autofit, Java, indent=0, options=""nowrap""]
----
include::{sampleSourceDir}/io/aeron/samples/cluster/tutorial/BasicAuctionClusteredService.java[tag=takeSnapshot]
----

<1> Write the persistent part of the application logic to a message buffer. In our case, the currently winning customer
id and bid price.

<2> Write the message to the publication, again we need to check the return from the `offer` call and use
the Cluster's `IdleStrategy::idle` inside the busy wait loop.

=== Loading State

Our `onStart` implementation contained a method to load the snapshot. Now we have seen how to take a snapshot, we
can now look at how it is loaded. The `Image` provided to the `onStart` has a method that will indicate if there is no
more data available. However, application code should also encode enough information that the end of the stream can be
detected from the store messages. The two approaches can be used to sanity check all the received data.

[source, Java, indent=0, options=""nowrap""]
----
include::{sampleSourceDir}/io/aeron/samples/cluster/tutorial/BasicAuctionClusteredService.java[tag=loadSnapshot]
----

<1> The method `Image::isEndOfStream` can be used to determine if there is going to be any more input.

<2> Because our snapshot is a stream of messages written to a publication, we use the Image's poll method for
extracting data from the snapshot.

<3> Our total snapshot length (16 bytes) is going to be smaller than any reasonable MTU therefore we can assume that all
the data will come in a single message.

<4> Once all data is loaded, we can initialise the application logic state from the snapshot.

<5> Once we've loaded all the data for the application we can break out of the snapshot loading loop.

<6> Again make sure we use the Cluster's `IdleStrategy::idle` in the tight loops.  It could take time for the snapshot
to be propagated to the service, so the number of fragments can be zero on any given invocation.

<7> It is also worthwhile having some sanity checks, these ensure that the snapshot store/load code and Aeron agree on
where the end of the input data is. We've used asserts, but other mechanisms, (e.g. log message, exceptions) could
also be used to indicate an issue.

=== Other events

There a number of other events received by the `ClusteredService` interface, such as timer events, clients connecting
and disconnecting from the cluster, plus leadership and role changes. We won't look at these in this tutorial.

== Configuring a Cluster

Now we have our application implemented we can move onto running it in a cluster. There are a number of moving parts to
setting up a cluster node, one of the trickiest parts of using Aeron Cluster is getting the configuration correct. We
are going to start with a static three-node cluster with a simplified configuration where all the components
(MediaDriver, Archive, ConsensusModule and ClusteredServiceContainer) for a single node within a single process. Later
we will then start the cluster as three separate processes.

=== Running Multiple Nodes on the Same Host

In a production deployment, you will want to run the 3 instances on three separate servers, however for our example we
want to run the services on a single machine. This does make port allocation a concern as each node within the cluster
needs to bind to a number of ports, so we need to make sure are no clashes. We could do this with VMs or containers,
but in the interest of simplicity we are going to specify a port range for each node. For example:

- Node 0, ports: 9000-9099
- Node 1, ports: 9100-9199
- Node 2, ports: 9200-9299

[source, Java, indent=0, options=""nowrap""]
----
include::{sampleSourceDir}/io/aeron/samples/cluster/tutorial/BasicAuctionClusteredServiceNode.java[tag=ports]
----
[source, Java, indent=0, options=""nowrap""]
----
include::{sampleSourceDir}/io/aeron/samples/cluster/tutorial/BasicAuctionClusteredServiceNode.java[tag=udp_channel]
----

While we don't really need 100 ports for each node (closer to 10), it does make it clear which ports are assigned to
each service. Each endpoint will be an offset from the first port in a node's range. E.g. the archive control request
port has an offset of 1, so for Node 2 it will have port 9201.

To start the cluster node we are going define our own class with a main method. It will construct and start all the
necessary components. As indicated above we are going to give each node of the cluster a unique id (0, 1, and 2). We are
also going to use this value as the cluster member id.

[source, Java, indent=0, options=""nowrap""]
----
include::{sampleSourceDir}/io/aeron/samples/cluster/tutorial/BasicAuctionClusteredServiceNode.java[tag=new_service]
----
[source, Java, indent=0, options=""nowrap""]
----
include::{sampleSourceDir}/io/aeron/samples/cluster/tutorial/BasicAuctionClusteredServiceNode.java[tag=main]
----

<1> Pass in the node id as a command line parameter to the service so that we can reuse the code for each instance of
the service.

<2> Define a set of hostnames for the cluster. For now everything is running on localhost, but we could put actual
hostnames or ip addresses in this list and run the same example across multiple servers.

<3> For each node we need a location on disk that will hold the persistent data. This will include the raft log, mark
files for each service component, and the recording log used to track snapshots within the log. In a production system
this location is likely to be fairly important as you will want to map this to a fast disk in order to get the best
performance out the system.

<4> Create a shutdown barrier that will be used to trap exit signals and allow the service to exit cleanly.

=== Configuration

==== Media Driver

[source, Java, indent=0, options=""nowrap""]
----
include::{sampleSourceDir}/io/aeron/samples/cluster/tutorial/BasicAuctionClusteredServiceNode.java[tag=media_driver]
----

Note we've specified the custom `aeronDirName` to allow multiple Media Drivers on the same host. There is nothing
special in the configuration in the Media Driver specific to Cluster.

==== Archive

[source, Java, indent=0, options=""nowrap""]
----
include::{sampleSourceDir}/io/aeron/samples/cluster/tutorial/BasicAuctionClusteredServiceNode.java[tag=archive]
----

Again nothing special in the Archive configuration specific to Cluster. We've used the same `aeronDirName` as used by
the Media Driver. The `controlChannel` uses node specific port in the construction of its UDP channel.

==== Archive Client

[source, Java, indent=0, options=""nowrap""]
----
include::{sampleSourceDir}/io/aeron/samples/cluster/tutorial/BasicAuctionClusteredServiceNode.java[tag=archive_client]
----

Because Cluster's Consensus Module requires that we write a log file to support the Raft protocol, we need a client for
the constructed Archive for it to use. As the Consensus Module should always be deployed on the same node as its
archive, we're going to use the local (IPC) configuration.  It is also worth noting that we haven't changed the
controlRequestStreamId in our setup.  The defaults in this situation are the most appropriate (from Aeron version 1.33.0
onwards).

==== Consensus Module

[source, Java, indent=0, options=""nowrap""]
----
include::{sampleSourceDir}/io/aeron/samples/cluster/tutorial/BasicAuctionClusteredServiceNode.java[tag=consensus_module]
----

This is first of the two configuration sections that are specific to Cluster. The Consensus Module is responsible for
handling the main aspects of the Raft protocol, e.g. leader election, ensuring consensus-based consistency of the data
in the log and passing properly replicated messages onto the Cluster Container.

<1> Each Consensus Module needs an identifier within the Cluster, we are going to use the `nodeId` that we have used to
separate each of the nodes.

<2> This is probably the trickiest part of the configuration. It specifies all the static members of the cluster
along with all the endpoints that they require for the various operations of the Consensus Module. These are encoded
into a single string of the form.
+
----
0,ingress:port,consensus:port,log:port,catchup:port,archive:port|\\
1,ingress:port,consensus:port,log:port,catchup:port,archive:port|...
----
Where each of the leading numeric values is a member id for the cluster (as specified in the `clusterMemberId` method).
The values for each endpoint represent:

* ingress, where the client will connect to for the ingress channel.
* consensus, where other members of the cluster communicate with each other to achieve cluster consensus.
* log, used to replicate logs to.
* catchup, used for a stream that members can use to catch up to a leader when behind the current log position.
* archive, the same endpoint used to control archive running on this node.
+
In our example we've used the same hostname for each of the endpoints (localhost), however each endpoint allows the
specification of a host, so that traffic could potentially be separated if required, e.g. running consensus traffic
on a separate network to the ingress traffic.

<3> Specify the data directory for the Consensus Module. Make sure it is node specific.

<4> Define the ingress channel for the cluster. Note this value does not need to be the full channel URI. It can be a
template that specifies the parameters, but excludes the endpoint, which will be filled using value from the
`clusterMembersString` as appropriate for this node.

<5> Specify the log channel. Like the ingress channel this is specified as a template. This channel needs to be a
multi-destination cast or multicast channel. In our example we are using multi-destination cast using manual
configuration, hence we need a separate control endpoint (including a port) used for adding and removing destination to
the publication.

<6> Specify the replication channel. This channel is the one that the local archive for a node will receive replication
responses from other archives when the log or snapshot replication step is required. This was added in version 1.33.0
and is a required parameter. It is important in a production environment that this channel's endpoint is not set to
localhost, but instead a hostname/ip address that is reachable by the other nodes in the cluster.

<7> Clone the Archive Client context that the Consensus Module will use to talk to the Archive.

==== Clustered Service Container

The final part of the configuration is the component to run our application logic. It is possible to have multiple
Clustered Service Containers per Consensus Module and have them talk to each other using IPC. In our simplified case we
just have the one.

[source, Java, indent=0, options=""nowrap""]
----
include::{sampleSourceDir}/io/aeron/samples/cluster/tutorial/BasicAuctionClusteredServiceNode.java[tag=clustered_service]
----

<1> Again we use the node specific Media Driver.

<2> Plus the node's Archive, via the Archive Client configuration.

<3> This is the point where we bind an instance of our application logic to the cluster.

=== Running the Cluster

Now we have a configured cluster, we can start it running. The code for launching the service is as follows.

[source, Java, indent=0, options=""nowrap""]
----
include::{sampleSourceDir}/io/aeron/samples/cluster/tutorial/BasicAuctionClusteredServiceNode.java[tag=running]
----

<1> Launches a `ClusteredMediaDriver` that includes instances of the Media Driver, Archive and Consensus Module.

<2> Immediately afterward we launch a `ClusteredServiceContainer` which is our application.

<3> Use the shutdown barrier to keep our system live until it is signalled to shut down (e.g. using SIG_TERM or SIG_INT
on Unix).

There is a script provide to launch the cluster. Assuming you've followed the <<usingthesource>> step above you
should be able to do the following:

// TODO need to add windows command examples.

----
> cd <AERON_HOME>/aeron-samples/scripts/cluster
> ./basic-auction-cluster
----

This will spit out a lot of logging but should end with something like:

----
[4452.593894535] CLUSTER: STATE_CHANGE [22/22]: memberId=0 INIT -> ACTIVE
[4452.594377676] CLUSTER: ELECTION_STATE_CHANGE [23/23]: memberId=0 INIT -> CANVASS
[4452.599524774] CLUSTER: CANVASS_POSITION [28/28]: logLeadershipTermId=-1 leadershipTermId=-1 logPosition=0 followerMemberId=1
[4452.60341655] CLUSTER: CANVASS_POSITION [28/28]: logLeadershipTermId=-1 leadershipTermId=-1 logPosition=0 followerMemberId=2
[4452.603442309] CLUSTER: ELECTION_STATE_CHANGE [27/27]: memberId=0 CANVASS -> NOMINATE
[4452.612230425] CLUSTER: ELECTION_STATE_CHANGE [36/36]: memberId=0 NOMINATE -> CANDIDATE_BALLOT
[4452.612255072] CLUSTER: ROLE_CHANGE [29/29]: memberId=0 FOLLOWER -> CANDIDATE
[4452.6157387] CLUSTER: ELECTION_STATE_CHANGE [50/50]: memberId=0 CANDIDATE_BALLOT -> LEADER_LOG_REPLICATION
[4452.627815713] CLUSTER: ELECTION_STATE_CHANGE [47/47]: memberId=0 LEADER_LOG_REPLICATION -> LEADER_REPLAY
[4452.627835581] CLUSTER: ELECTION_STATE_CHANGE [36/36]: memberId=0 LEADER_REPLAY -> LEADER_INIT
[4452.627844468] CLUSTER: ROLE_CHANGE [27/27]: memberId=0 CANDIDATE -> LEADER
[4452.653330292] CLUSTER: ELECTION_STATE_CHANGE [35/35]: memberId=0 LEADER_INIT -> LEADER_READY
[4452.759977752] CLUSTER: ELECTION_STATE_CHANGE [30/30]: memberId=0 LEADER_READY -> CLOSED
----

We now have our new service running in a cluster.

You can shutdown the nodes using the following:
----
> pkill -f BasicAuctionClusteredServiceNode
----

You should also be able to see the stored data for each of the nodes in the working directory.

----
> ls
basic-auction-client  basic-auction-cluster  logs  node0  node1  node2  script-common
----

Let's look briefly how the script launches the code.

[source, Bash, indent=0, options=""nowrap""]
----
include::{sampleBaseDir}/scripts/cluster/basic-auction-cluster[tag=start_jvm]
----

The `-javaagent:../../../aeron-agent/build/libs/aeron-agent-${VERSION}-all.jar` allows the weaving of the Aeron's
logging agent into the running code. Specifying `-Daeron.event.cluster.log=all` tells the agent to log all the events
relating to the cluster operation.

== Using a Cluster Client

While we now have our cluster up and running, we can't do anything with it until we have a client that will interact
with the cluster.

=== Connecting to a Cluster

First off, we need a way to connect our client to the cluster. All the messaging between the client and the cluster
happens via Aeron, but we have an additional layer called `AeronCluster` that handles connections to the independent
nodes and provides methods for offering messages into the cluster and polling for responses.

[source, Java, indent=0, options=""nowrap""]
----
include::{sampleSourceDir}/io/aeron/samples/cluster/tutorial/BasicAuctionClusterClient.java[tag=client]
----
[source, Java, indent=0, options=""nowrap""]
----
include::{sampleSourceDir}/io/aeron/samples/cluster/tutorial/BasicAuctionClusterClient.java[tag=connect]
----

<1> Launch a media driver that will allow communication with the cluster nodes. We're using an embedded instance here
to make it easier to launch multiple drivers on the same machine for use in this tutorial, but it would be perfectly
viable to launch a single media driver and have multiple clients on the same host sharing the same media driver. We're
also avoiding using the media drivers that each of the cluster nodes are using.

<2> This is where we bind our client application code to the responses from the cluster. This requires implementing the
`EgressListener` interface, which provides callbacks for session messages, session related events (e.g. errors), and
cluster events (e.g. new elected leaders).

<3> Specify the channel to receive egress responses back from the cluster. In our case we are using a UDP unicast
response, which will limit responses to the session that sent the ingress message. We are using port 0 to allow for
multiple clients on the same machine with multiple media drivers and to avoid having to specify an actual port per
cluster client.

+

It is possible to specify a multicast address here if you wanted all clients to see all responses. Some systems may
find this useful, e.g. an exchange with multiple gateways may wish to have the execution for a trade sent to a client
that was on the passive side of a trade.

<4> Specify the ingress channel for the cluster. In our case as we are using multiple destinations we need to use the
template style approach that was used when setting up the Consensus Module. We just identify that access to the cluster
is via UDP.

<5> Identify the actual static endpoints for the cluster. Will be merged into the configuration specified for the
ingress channel.

NOTE: This example is using UDP unicast for the ingress and egress channels. It is possible to use multicast, but you
will need to be in an environment where multicast is supported. In cloud deployments UDP multicast is typically not
supported or in very early stages, so unicast is currently recommended in those environments.

=== Publishing to the Cluster

Next we are going to push messages into the cluster itself. So that the client is able to fail over to different nodes,
as nodes come and go, in the cluster the Aeron publications are contained in a class called `AeronCluster`. This is the
second of the two items that are connected at start up. This class provides an API very similar to the Publication API.

[source, Java, indent=0, options=""nowrap""]
----
include::{sampleSourceDir}/io/aeron/samples/cluster/tutorial/BasicAuctionClusterClient.java[tag=publish]
----

<1> In much the same way that we would send messages to a publication we put the data that we want to send into an
Agrona `DirectBuffer`. The `AeronCluster` contains offer methods that behave in the same way as the `Publication` offer
methods.

<2> Publish the data in the same way we would with a `Publication`. We must check the return value to ensure that the
message has been sent because back pressure could happen at any time.

<3> If we fail to send, and need to run an idle loop, we should utilise an `IdleStrategy` to ensure that we don't
inappropriately overuse the CPU. With cluster clients we should also be continually polling the egress stream to pick
up any messages that have been sent back from the cluster, including errors or session status messages.

=== Receiving Responses

As was mentioned previously, our client must have a class which implements the `EgressListener` interface to receive
messages that come back from the cluster. The responses can be application messages, session events (e.g. error
messages), or notifications of a new leader. In this tutorial there is not a lot to do, therefore we simply print out
the responses that received.

[source, Java, indent=0, options=""nowrap""]
----
include::{sampleSourceDir}/io/aeron/samples/cluster/tutorial/BasicAuctionClusterClient.java[tag=response]
----

=== Using the Cluster

Now we have all the pieces in place we start to run the cluster and client together and see how the cluster behaves.
You will need at least three terminal windows as we will leave the one we used to start the cluster open showing logging
information for the cluster.

Firstly, start up the cluster.

----
> cd <AERON_HOME>/aeron-samples/scripts/cluster
> ./basic-auction-cluster
----

Wait until you see a message that indicates one of the nodes is now leader.

----
[57240.190127954] CLUSTER: ELECTION_STATE_CHANGE [29/29]: memberId=1, LEADER_READY -> CLOSE
----

Now in a second terminal window, run a client that will place some bids into our cluster hosted auction. The `10`
parameter is the customer id to use for the client, change this number if you want to run multiple clients.

----
> cd <AERON_HOME>/aeron-samples/scripts/cluster
> ./basic-auction-client 10
----

We should see some output similar to the following:

----
Sent(8474093274723075706, 10, 105) bidsRemaining=9
SessionMessage(1, 8474093274723075706, 10, 105, true)
Sent(8474093274723075707, 10, 109) bidsRemaining=8
SessionMessage(1, 8474093274723075707, 10, 109, true)
Sent(8474093274723075708, 10, 110) bidsRemaining=7
SessionMessage(1, 8474093274723075708, 10, 110,true)
Sent(8474093274723075709, 10, 119) bidsRemaining=6
SessionMessage(1, 8474093274723075709, 10, 119, true)
Sent(8474093274723075710, 10, 122) bidsRemaining=5
SessionMessage(1, 8474093274723075710, 10, 122, true)
Sent(8474093274723075711, 10, 127) bidsRemaining=4
SessionMessage(1, 8474093274723075711, 10, 127, true)
Sent(8474093274723075712, 10, 129) bidsRemaining=3
SessionMessage(1, 8474093274723075712, 10, 129, true)
Sent(8474093274723075713, 10, 135) bidsRemaining=2
SessionMessage(1, 8474093274723075713, 10, 135, true)
Sent(8474093274723075714, 10, 136) bidsRemaining=1
SessionMessage(1, 8474093274723075714, 10, 136,true)
Sent(8474093274723075715, 10, 142) bidsRemaining=0
SessionMessage(1, 8474093274723075715, 10, 142, true)
----

=== Failed Nodes and Leader Election

Now the cluster is up and running, and we are able to send and receive messages, we can look at some additional tools
available for Cluster and experiment with the fault tolerance functionality.

First thing we are interested in is which node of the three is the leader, with this information we can try shutdown the
leader and see if our client is able to recover.

[subs = ""attributes+""]
----
> java -cp <AERON_HOME>/aeron-all/build/libs/aeron-all-{aeronVersion}.jar \\
  io.aeron.cluster.ClusterTool node0/consensus-module list-members
----

This will show a list of all the members in the cluster, similar to the following:

----
currentTimeNs=1579564309666000000, leaderMemberId=0, memberId=0, activeMembers=[ClusterMember{isBallotSent=false,
isLeader=false, hasRequestedJoin=false, id=0, leadershipTermId=5, logPosition=11872, candidateTermId=-1,
catchupReplaySessionId=-1, correlationId=-1, removalPosition=-1, timeOfLastAppendPositionNs=1579564309666000000,
ingressEndpoint='localhost:9003', consensusEndpoint='localhost:9004', logEndpoint='localhost:9005',
catchupEndpoint='localhost:9006', archiveEndpoint='localhost:9001',
endpoints='localhost:9003,localhost:9004,localhost:9005,localhost:9006,localhost:9001', publication=null,
vote=null}, ClusterMember{isBallotSent=false, isLeader=false, hasRequestedJoin=false, id=1, leadershipTermId=5,
logPosition=11872, candidateTermId=-1, catchupReplaySessionId=-1, correlationId=-1, removalPosition=-1,
timeOfLastAppendPositionNs=1579564309495000000, ingressEndpoint='localhost:9103',
consensusEndpoint='localhost:9104', logEndpoint='localhost:9105', catchupEndpoint='localhost:9106',
archiveEndpoint='localhost:9101',
endpoints='localhost:9103,localhost:9104,localhost:9105,localhost:9106,localhost:9101', publication=null,
vote=null}, ClusterMember{isBallotSent=false, isLeader=false, hasRequestedJoin=false, id=2, leadershipTermId=5,
logPosition=11872, candidateTermId=-1, catchupReplaySessionId=-1, correlationId=-1, removalPosition=-1,
timeOfLastAppendPositionNs=1579564309552000000, ingressEndpoint='localhost:9203',
consensusEndpoint='localhost:9204', logEndpoint='localhost:9205', catchupEndpoint='localhost:9206',
archiveEndpoint='localhost:9201',
endpoints='localhost:9203,localhost:9204,localhost:9205,localhost:9206,localhost:9201', publication=null,
vote=null}], passiveMembers=[]
----

The part we are interested in is the leaderMemberId, this allows us to identify the leader in order to shut it down. We
can discover the pid for that member using the following command:

[subs = ""attributes+""]
----
> java -cp <AERON_HOME>/aeron-all/build/libs/aeron-all-{aeronVersion}.jar \\
  io.aeron.cluster.ClusterTool node<leaderMemberId>/consensus-module pid
15060
----

Note the second argument to the `ClusterTool` is the directory where the Consensus Module's stores its data, and we have
substituted the `leaderMemberId` to locate the correct directory for the leader.

This will have printed out a simple number which is the pid of the leader process.

Next start the client again, but this time we will let it run a bit longer and attempt to trigger a leader election
within the cluster while it is running.

----
> cd <AERON_HOME>/aeron-samples/scripts/cluster
> ./basic-auction-client 10 1000 3000
----

Once the client is running, switch to a different terminal and kill the leader process using the pid from the earlier
step.

----
> kill <pid>
----

The system will stall for a short while until the followers timeout after not receiving a heartbeat from the leader
before deciding to elect a new one. The logs for the cluster will contain something similar to:

----
==> logs/cluster-0.log <==
[0] Exiting
Consensus Module
io.aeron.cluster.client.ClusterException: heartbeat timeout from leader
        at io.aeron.cluster.ConsensusModuleAgent.slowTickWork(ConsensusModuleAgent.java:1884)
        at io.aeron.cluster.ConsensusModuleAgent.doWork(ConsensusModuleAgent.java:288)
        at org.agrona.concurrent.AgentRunner.doDutyCycle(AgentRunner.java:283)
        at org.agrona.concurrent.AgentRunner.run(AgentRunner.java:164)
        at java.base/java.lang.Thread.run(Thread.java:834)
Consensus Module
io.aeron.cluster.client.ClusterException: heartbeat timeout from leader
        at io.aeron.cluster.ConsensusModuleAgent.slowTickWork(ConsensusModuleAgent.java:1884)
        at io.aeron.cluster.ConsensusModuleAgent.doWork(ConsensusModuleAgent.java:288)
        at org.agrona.concurrent.AgentRunner.doDutyCycle(AgentRunner.java:283)
        at org.agrona.concurrent.AgentRunner.run(AgentRunner.java:164)
        at java.base/java.lang.Thread.run(Thread.java:834)
...
[65188.006731058] CLUSTER: ELECTION_STATE_CHANGE [42/42]: memberId=1, FOLLOWER_BALLOT -> FOLLOWER_REPLAY
[65188.006791979] CLUSTER: ELECTION_STATE_CHANGE [54/54]: memberId=1, FOLLOWER_REPLAY -> FOLLOWER_CATCHUP_TRANSITION
[65188.009951316] CLUSTER: ELECTION_STATE_CHANGE [55/55]: memberId=1, FOLLOWER_CATCHUP_TRANSITION -> FOLLOWER_CATCHUP
[65188.028244817] CLUSTER: ELECTION_STATE_CHANGE [47/47]: memberId=1, FOLLOWER_CATCHUP -> FOLLOWER_TRANSITION
[65188.028355173] CLUSTER: ELECTION_STATE_CHANGE [45/45]: memberId=1, FOLLOWER_TRANSITION -> FOLLOWER_READY
[65188.02995347] CLUSTER: ELECTION_STATE_CHANGE [31/31]: memberId=1, FOLLOWER_READY -> CLOSE

==> logs/cluster-2.log <==
[65188.033401987] CLUSTER: ELECTION_STATE_CHANGE [29/29]: memberId=2, LEADER_READY -> CLOSE
----

Showing that a new leader has been elected to run the cluster. At this point the cluster will have no redundancy and
will only have two working nodes.

The client should automatically resume sending messages into the cluster and receiving responses. There may, or may
not, be an exception logged by the client depending on timing.

----
Sent(-7819190107498904370, 10, 12969) bidsRemaining=980
SessionMessage(20, -7819190107498904370, 10, 12969, true)
Sent(-7819190107498904369, 10, 12969) bidsRemaining=979
Sent(-7819190107498904368, 10, 12970) bidsRemaining=978
Sent(-7819190107498904367, 10, 12978) bidsRemaining=977
Sent(-7819190107498904366, 10, 12975) bidsRemaining=976
Sent(-7819190107498904365, 10, 12971) bidsRemaining=975
Consensus Module
io.aeron.cluster.client.ClusterException: heartbeat timeout from leader
        at io.aeron.cluster.ConsensusModuleAgent.slowTickWork(ConsensusModuleAgent.java:1884)
        at io.aeron.cluster.ConsensusModuleAgent.doWork(ConsensusModuleAgent.java:288)
        at org.agrona.concurrent.AgentRunner.doDutyCycle(AgentRunner.java:283)
        at org.agrona.concurrent.AgentRunner.run(AgentRunner.java:164)
        at java.lang.Thread.run(Thread.java:748)
NewLeader(20, 7, 1)
Sent(-7819190107498904364, 10, 12977) bidsRemaining=974
Sent(-7819190107498904363, 10, 12974) bidsRemaining=973
SessionMessage(20, -7819190107498904364, 10, 12977, true)
SessionMessage(20, -7819190107498904363, 10, 12977, false)
----

IMPORTANT: If you look carefully at the `correlationId` values you will notice there are no `SessionMessage` log entries
for a number of the messages that were sent. This is because when the leader fails some messages sent into the cluster
can be lost. For this reason it is important the client to track responses for its messages and provide timeouts to the
caller if required.

We can restore the failed node back into service:

----
> cd <AERON_HOME>/aeron-samples/scripts/cluster
> ./basic-auction-cluster <leaderMemberId>
----

Where the leaderMemberId is the id of the member that was killed (not the new leader of the cluster). The cluster logs
will show the member rejoining the cluster:

----
[0] Started Cluster Node on localhost...
[66250.672741109] CLUSTER: STATE_CHANGE [22/22]: memberId=0, INIT -> ACTIVE
[66250.687237677] CLUSTER: ELECTION_STATE_CHANGE [23/23]: memberId=0, INIT -> CANVASS
[66250.689468615] CLUSTER: NEW_LEADERSHIP_TERM [40/40]: logLeadershipTermId=6, leadershipTermId=6, logPosition=19424, timestamp=1579566538529, leaderMemberId=2, logSessionId=-1889384498
[66250.689493099] CLUSTER: ELECTION_STATE_CHANGE [34/34]: memberId=0, CANVASS -> FOLLOWER_REPLAY
onSessionOpen(ClientSession{id=1, responseStreamId=102, responseChannel='aeron:udp?endpoint=localhost:19132', encodedPrincipal=[], clusteredServiceAgent=io.aeron.cluster.service.ClusteredServiceAgent@19a05123, responsePublication=null, isClosing=false})
attemptBid(this=Auction{bestPrice=0, currentWinningCustomerId=-1}, price=123,customerId=132)
onSessionClose(ClientSession{id=1, responseStreamId=102, responseChannel='aeron:udp?endpoint=localhost:19132', encodedPrincipal=[], clusteredServiceAgent=io.aeron.cluster.service.ClusteredServiceAgent@19a05123, responsePublication=null, isClosing=false})
onSessionOpen(ClientSession{id=2, responseStreamId=102, responseChannel='aeron:udp?endpoint=localhost:19132', encodedPrincipal=[], clusteredServiceAgent=io.aeron.cluster.service.ClusteredServiceAgent@19a05123, responsePublication=null, isClosing=false})
----

You can see that the new node looks like it is re-executing application messages. That is because it is. It is
replaying the log of the messages that have been sent into the cluster up to this point in order to restore its
in-memory state to what it was before the failure.

=== Snapshots

Earlier in the tutorial we looked at how a node can store a snapshot of its current state so that it would not need to
replay every single application message since the beginning of time. We can look at the recording log for a node to see
the logs, and snapshots, that are stored for a node in the cluster. We can also use the tool to trigger a snapshot.

Firstly lets look at the recording log.

[subs=""attributes+""]
----
> java -cp <AERON_HOME>/aeron-all/build/libs/aeron-all-{aeronVersion}.jar \\
  io.aeron.cluster.ClusterTool node0/consensus-module recording-log
----

Which should show a recording log with a single entry:

----
RecordingLog{entries=[Entry{recordingId=0, leadershipTermId=0, termBaseLogPosition=0, logPosition=-1, timestamp=1579569542227, serviceId=-1, type=0, isValid=true, entryIndex=0}], cacheIndex={0=0}}
----

We can trigger a snapshot on the leader.

----
> java -cp <AERON_HOME>/aeron-all/build/libs/aeron-all-{aeronVersion}.jar \\
  io.aeron.cluster.ClusterTool node2/consensus-module snapshot
----

The recording log will now have additional entries.

----
RecordingLog{entries=[Entry{recordingId=0, leadershipTermId=0, termBaseLogPosition=0, logPosition=-1, timestamp=1579569542227, serviceId=-1, type=0, isValid=true, entryIndex=0}, Entry{recordingId=1, leadershipTermId=0, termBaseLogPosition=0, logPosition=1376, timestamp=1579570195606, serviceId=0, type=1, isValid=true, entryIndex=1}, Entry{recordingId=2, leadershipTermId=0, termBaseLogPosition=0, logPosition=1376, timestamp=1579570195606, serviceId=-1, type=1, isValid=true, entryIndex=2}], cacheIndex={0=0}}
----

There are two more entries. One for the snapshot just taken and a now term entry to indicate the point within the log
the service should start recovering from where it to use the new snapshot on re-start.

== Exercises

Here are some exercises that you can try out.

. Have multiple customers competing on the same auction.
. Use multicast for the egress channel so that customers can see the others prices and make better bids.
. Implement a second message type that will allow customers to query for the current bid price of the auction.

//== Timers
//
//== Multiple Services Per Cluster Node
//
//== More Complex State
//
//== Dynamically Add/Removing Nodes from a Cluster


////
<1> To manage fragmenting the arbitrary sized state we are going to serialize our state to a single buffer. In this case
we are using the `snapshotMessageBuffer` as our temporary buffer for the keys and their counts. This makes sense when
the state of the system is as simple as this. However, in a real scenario you probably wouldn't want to serialize
the whole state of a service to a single buffer, you may want to break up this by
https://dddcommunity.org/resources/ddd_terms/[repository or entity]

<2> You'll notice that we are sorting the output before writing to the buffer. While not strictly required, it is highly
recommended that snapshots be written with data in a consistent order. This means that if at some point in the future
you wanted to verify snapshots written by different services that have logically consumed the same messages then it can
be done as a straight forward binary comparison. A sort is required here because `HashMap` iteration is not
deterministic (especially in cases where services are at the same point in the log, but initialised from snapshots
taken at different times). An alternative would be to use a collection that has a known order, e.g. `TreeMap`.

<3> Two things are happening here. Firstly, we mentioned the necessity of having a protocol to handle fragmentation of
our data when sending via the `Publication`. In our case we are going to have a very minimal header, consisting of two
32-bit values, the current offset in to the full buffer of data and the total size. This will allow a consumer to know
how far through the total set of data this fragment is, and can be used for sanity checking on load.  Secondly, we are
determining the size of the individual Aeron message being sent. Given that we will be handling fragmentation ourselves,
there is no point in having Aeron fragment and reconstruct messages for us, so we should limit the size of the messages
such that we do not exceed the `MTU`, so this calculation tells us the maximum amount of the encoded
`snapshotMessageBuffer` we can send with each message.

<4> Write out our header to the first two 32-bit entries in the fragment.

<5> Get the amount of data from the full serialized message that we want to send, either fill up the MTU or use whatever
is remaining, whichever is smallest.

<6> Write the header and the message data to the publication using the gathering API.

Before moving onto configuring our service to run in a cluster, a couple of points to remember.

[TIP]
====
. Treat snapshot store and load as a messaging problem using a protocol to efficiently deal with fragmentation.
. Ensure message serialisation is encapsulated, preferably with a tool that provides a schema for the serialised data.
. Write data to the snapshot in a deterministic order to allow for verification later.
====
////",12479,False,2216.8145734551213,median
"= Debezium Connector for MongoDB
include::../_attributes.adoc[]
:toc:
:toc-placement: macro
:linkattrs:
:icons: font
:source-highlighter: highlight.js

toc::[]

Debezium's MongoDB Connector can monitor a https://docs.mongodb.com/manual/tutorial/deploy-replica-set/[MongoDB replica set] or a https://docs.mongodb.com/manual/core/sharded-cluster-components/[MongoDB sharded cluster] for document changes in databases and collections, recording those changes as events in Kafka topics. The connector automatically handles the https://docs.mongodb.com/manual/tutorial/add-shards-to-shard-cluster/[addition] or https://docs.mongodb.com/manual/tutorial/remove-shards-from-cluster/[removal] of shards in a sharded cluster, changes in membership of each replica set, https://docs.mongodb.com/manual/core/replica-set-elections/[elections] within each replica set, and awaiting the resolution of communications problems.

[[overview]]
== Overview

MongoDB's https://docs.mongodb.com/manual/replication/[replication mechanism] provides redundancy and high availability, and is the preferred way to run MongoDB in production. A MongoDB _replica set_ consists of a set of servers that all have copies of the same data, and replication ensures that all changes made by clients to documents on the replica set's _primary_ are correctly applied to the other replica set's servers, called _secondaries_. MongoDB replication works by having the primary record the changes in its _oplog_ (or operation log), and then each of the secondaries reads the primary's oplog and applies in order all of the operations to their own documents. When a new server is added to a replica set, that server first performs an https://docs.mongodb.com/manual/core/replica-set-sync/[initial sync] of all of the databases and collections on the primary, and then reads the primary's oplog to apply all changes that might have been made since it began the initial sync. This new server becomes a secondary (and able to handle queries) when it catches up to the tail of the primary's oplog.

The Debezium MongoDB connector uses this same replication mechanism, though it does not actually become a member of the replica set. Just like MongoDB secondaries, however, the connector always reads the oplog of the replica set's primary. And, when the connector sees a replica set for the first time, it looks at the oplog to get the last recorded transaction and then performs an _intial sync_ of the primary's databases and collections. When all the data is copied, the connector then starts reading the oplog from the position it read earlier. Operations in the MongoDB oplog are https://docs.mongodb.com/manual/core/replica-set-oplog/[idempotent], so no matter how many times the operations are applied, they result in the same end state.

As the MongoDB connector processes the oplog, it periodically records the position in the oplog where the event originated. When the MongoDB connector stops, it records the last oplog position that it processed, so that upon restart it simply begins reading the oplog from that position. In other words, the connector can be stopped, upgraded or maintained, and restarted some time later, and it will pick up exactly where it left off without losing a single event. Of course, MongoDB's oplogs are usually capped at a maximum size, which means that the connector should not be stopped for too long, or else some of the operations in the oplog might be purged before the connector has a change to read them. In this case, upon restart the connector will detect the missing oplog operations, perform an initial sync, and then proceed to tail the oplog.

The MongoDB connector is also quite tolerant of changes in membership and leadership of the replica sets, of additions or removals of shards within a sharded cluster, and network problems that might cause communication failures. The connector always uses the replica set's primary node to tail the oplog, so when the replica set undergoes an election and a different node becomes primary, the connector will immediately stop tailing the oplog, connect to the new primary, and start tailing the oplog using the new primary node. Likewise, if connector experiences any problems communicating with the replica set primary, it will try to reconnect (using exponential backoff so as to not overwhelm the network or replica set) and continue tailing the oplog from where it last left off. In this way the connector is able to dynamically adjust to changes in replica set membership and to automatically handle communication failures.

[[setting-up-mongodb]]
== Setting up MongoDB

The Debezium MongoDB connector uses MongoDB's oplog to capture the changes, so the connector works only with MongoDB replica sets or with sharded clusters where each shard is a separate replica set. See the MongoDB documentation for setting up a https://docs.mongodb.com/manual/replication/[replica set] or https://docs.mongodb.com/manual/sharding/[sharded cluster]. Also, be sure to understand how to enable https://docs.mongodb.com/manual/tutorial/deploy-replica-set-with-keyfile-access-control/#deploy-repl-set-with-auth[access control and authentication] with replica sets.

You must also have a MongoDB user that has the appropriate roles to read the `admin` database where the oplog can be read. Additionally, the user must also be able to read the `config` database in the configuration server of a sharded cluster and must have `listDatabases` privilege action.

[[supported-mongodb-topologies]]
== Supported MongoDB topologies

The Debezium MongoDB connector can be used with a variety of MongoDB topologies.

[[mongodb-replicaset]]
=== MongoDB replica set

The Debezium MongoDB connector can capture changes from a single https://docs.mongodb.com/manual/replication/[MongoDB replica set]. Although production replica sets should have https://docs.mongodb.com/manual/core/replica-set-architecture-three-members/[at least three members], the connector actually doesn't care how many members are in the replica set.

To use the Debezium MongoDB connector with a replica set, simply provide the addresses of one or more replica set servers as _seed addresses_ via the connector's `mongodb.hosts` property. The connector will use these seeds to connect to the replica set, and then once connected will get from the replica set the complete set of members and which member is primary. The connector will start a task to connect to the primary and capture the changes from the primary's oplog. When the replica set elects a new primary, the task will automatically switch over to the new primary.

[TIP]
====
When MongoDB is fronted by a proxy (such as with Docker on OS X or Windows), then when a client connects to the replica set and discover the members, the MongoDB client will exclude the proxy as a valid member and will attempt and fail to connect directly to the members rather than go through the proxy.

In these cases, set the connector's optional `mongodb.members.auto.discover` configuration property to `false` to instruct the connector to forgo membership discovery and instead simply use the first seed address (specified via the `mongodb.hosts` property) as the primary node. This may work, but still make cause issues when election occurs.
====

[[mongodb-sharded-cluster]]
=== MongoDB sharded cluster

A https://docs.mongodb.com/manual/sharding/[MongoDB sharded cluster] consists of:

* one or more _shards_, each deployed as a replica set;
* a separate replica set that acts as the cluster's _configuration server_; and
* one or more _routers_ (also called `mongos`) to which clients connect and that routes requests to the appropriate shards

To use the Debezium MongoDB connector with a sharded cluster, configure the connector with the host addresses of the _configuration server_ replica set. When the connector connects to this replica set, it discovers that it is acting as the configuration server for a sharded cluster, discovers the information about each replica set used as a shard in the cluster, and will then start up a separate task to capture the changes from each replica set. If new shards are added to the cluster or existing shards removed, the connector will automatically adjust its tasks accordingly.

[[mongodb-standalone-server]]
=== MongoDB standalone server

The Debezium MongoDB connector is not capable of monitoring the changes of a standalone MongoDB server, since standalone servers do not have an oplog. The connector will work if the standalone server is converted to a replica set with one member.

[TIP]
====
MongoDB https://docs.mongodb.com/manual/core/replica-set-architectures/[does not recommend] running a standalone server in production anyway.
====


[[how-it-works]]
[[how-the-mongodb-connector-works]]
== How the MongoDB connector works

This section goes into detail about how the MongoDB connector captures the changes in a replica set or sharded cluster.

[[tasks]]
=== Tasks

When a MongoDB connector is configured and deployed, it starts by connecting to the MongoDB servers at the seed addresses, and determines the details about each of the available replica sets. Since each replica set has its own independent oplog, the connector will try to use a separate task for each replica set. The connector can limit the maximum number of tasks it will use, and if not enough tasks are available the connector will assign multiple replica sets to each task, although the task will still use a separate thread for each replica set.

[TIP]
====
When running the connector against a sharded cluster, use a value of `tasks.max` that is greater than the number of replica sets. This will allow the connector to create one task for each replica set, and will let Kafka Connect coordinate, distribute, and manage the tasks across all of the available worker processes.
====

[[logical-name]]
[[logical-connector-name]]
=== Logical connector name

One of the connector configuration properties is `mongodb.name`, and it serves as a _logical name_ for the MongoDB replica set or sharded cluster. The connector uses the logical name in a number of ways: as the prefix for all topic names, and as a unique identifier when recording the oplog position of each replica set.

You should give each MongoDB connector a unique logical name that meaningfully describes the source MongoDB system. We recommend logical names begin with an alphabetic or underscore character, and remaining characters that are alphanumeric or underscore.

[[initial-sync]]
=== Initial sync

When a task starts up using a replica set, it uses the connector's logical name and the replica set name to find an _offset_ that describes the position in the replica sets oplog where the connector previously stopped reading. If an offset can be found and it is still in the oplog, then the task immediately proceeds with link:#tailing-the-oplog[tailing the oplog], starting at the recorded offset position.

However, if no offset is found or if the oplog no longer contains that position, the task must first obtain the current state of the replica set contents by performing an _initial sync_. This process starts by recording the current position of the oplog and recording that as the offset (along with a flag that denotes an initial sync has been started). The task will then proceed to copy each collection, spawning as many threads as possible (up to the value of the `initial.sync.max.threads` configuration property) to perform this work in parallel. The connector will record a separate _read event_ for each document it sees, and that read event will contain the object's identifier, the complete state of the object, and _source_ information about the MongoDB replica set where the object was found. The source information will also include a flag that denotes the event was produced during an initial sync.

This initial sync will continue until it has copied all collections that match the connector's filters. If the connector is stopped before the tasks' initial syncs are completed, upon restart the connector will begin the initial sync again.

[TIP]
====
Try to avoid task reassignment and reconfiguration while the connector is performing an intial sync of any replica sets. The connector does log messages with the progress of the initial sync. For utmost control, run a separate cluster of Kafka Connect for each connector.
====

[[tailing-the-oplog]]
=== Tailing the oplog

Once the connector task for a replica set has an offset, it uses the offset to determine the position in the oplog where it should start reading. The task will then connect to the replica set's primary node and start reading the oplog from that position, processing all of the create, insert, and delete operations and converting them into Debezium link:#events[change events]. Each change event includes the position in the oplog where the operation was found, and the connector periodically records this as its most recent offset. (The interval at which the offset is recorded is governed by the `offset.flush.interval.ms` http://docs.confluent.io/3.0.0/connect/userguide.html#configuring-workers[Kafka Connect worker configuration property].)

When the connector is stopped gracefully, the last offset processed is recorded so that, upon restart, the connector will continue exactly where it left off. If the connector's tasks terminate unexpectedly, however, then the tasks may have processed and generated events after it last records the offset but before the last offset is recorded; upon restart, the connector will begin at the last _recorded_ offset, possibly generating some the same events that were previously generated just prior to the crash.

[NOTE]
====
When everything is operating nominally, Kafka consumers will actually see every message *_exactly once_*. However, when things go wrong Kafka can only guarantee consumers will see every message *_at least once_*. Therefore, your consumers need to anticipate seeing messages more than once.
====

As mentioned above, the connector tasks always use the replica set's primary node to tail the oplog, ensuring that the connector sees the most up-to-date operations as possible and can capture the changes with lower latency than if secondaries were to be used instead. When the replica set elects a new primary, the connector will immediately stop tailing the oplog, connect to the new primary, and start tailing the new primary's oplog start at the same position. Likewise, if connector experiences any problems communicating with the replica set members, it will try to reconnect (using exponential backoff so as to not overwhelm the replica set) and once connected continue tailing the oplog from where it last left off. In this way the connector is able to dynamically adjust to changes in replica set membership and to automatically handle communication failures.

The bottom line is that the MongoDB connector will continue running under most situations, though communication problems may cause the connector to wait until the problems are resolved.

[[topic-names]]
=== Topics names

The MongoDB connector writes events for all insert, update, and delete operations to documents in each collection to a single Kafka topic. The name of the Kafka topics always takes the form _logicalName_._databaseName_._collectionName_, where _logicalName_ is the link:logical-name[logical name] of the connector as specified with the `mongodb.name` configuration property, _databaseName_ is the name of the database where the operation occurred, and _collectionName_ is the name of the MongoDB collection in which the affected document existed.

For example, consider a MongoDB replica set with an `inventory` database that contains four collections: `products`, `products_on_hand`, `customers`, and `orders`. If the connector monitoring this database were given a logical name of `fulfillment`, then the connector would produce events on these four Kafka topics:

* `fulfillment.inventory.products`
* `fulfillment.inventory.products_on_hand`
* `fulfillment.inventory.customers`
* `fulfillment.inventory.orders`

Notice that the topic names do not incorporate the replica set name or shard name. As a result, all changes to a sharded collection (where each shard contains a subset of the collection's documents) all go to the same Kafka topic.

You can set up Kafka to http://kafka.apache.org/documentation.html#basic_ops_add_topic[auto-create] the topics as they are needed. If not, then you must use Kafka administration tools to create the topics before starting the connector.

[[partitions]]
=== Partitions

The MongoDB connector does not make any explicit determination of the topic partitions for events. Instead, it allows Kafka to determine the partition based upon the key. You can change Kafka's partitioning logic by defining in the Kafka Connect worker configuration the name of the `Partitioner` implementation.

Be aware that Kafka only maintains total order for events written to a single topic _partition_. Partitioning the events by key does mean that all events with the same key will always go to the same partition, ensuring that all events for a specific document are always totally ordered.



[[events]]
=== Events

All data change events produced by the MongoDB connector have a key and a value. The rest of this section outlines the structure of these keys and values.

[NOTE]
====
Starting with Kafka 0.10, Kafka can optionally record with the message key and value the http://kafka.apache.org/documentation.html#upgrade_10_performance_impact[_timestamp_] at which the message was created (recorded by the producer) or written to the log by Kafka.
====

Debezium and Kafka Connect are designed around _continuous streams of event messages_, and the structure of these events could potentially change over time if the source of those events changed in structure or if the connector is improved or changed. This could be difficult for consumers to deal with, so to make it very easy Kafka Connect makes each event self-contained. Every message key and value has two parts: a _schema_ and _payload_. The schema describes the structure of the payload, while the payload contains the actual data.

[[change-events-key]]
==== Change event's key

For a given collection, the change event's key will be a structure that contains a single `id` field. Its value will be the document's identifier represented as string which is derived from the https://docs.mongodb.com/manual/reference/mongodb-extended-json/[MongoDB extended JSON serialization in strict mode]. Consider a connector with a logical name of `fulfillment`, a replica set containing an `inventory` database with a `customers` collection containing documents such as:

[source,json,indent=0]
----
  {
    ""_id"": 1004,
    ""first_name"": ""Anne"",
    ""last_name"": ""Kretchmar"",
    ""email"": ""annek@noanswer.org""
  }
----

Every change event for the `customers` collection will feature the same key structure, which in JSON looks like this:

[source,json,indent=0]
----
  {
    ""schema"": {
      ""type"": ""struct"",
      ""name"": ""fulfillment.inventory.customers.Key""
      ""optional"": false,
      ""fields"": [
        {
          ""field"": ""id"",
          ""type"": ""string"",
          ""optional"": false
        }
      ]
    },
    ""payload"": {
      ""id"": ""1004""
    }
  }
----

The `schema` portion of the key contains a Kafka Connect schema describing what is in the payload portion, and in our case that means that the `payload` value is not optional, is a structure defined by a schema named `fulfillment.inventory.customers.Key`, and has one required field named `id` of type `string`. If we look at the value of the key's `payload` field, we'll see that it is indeed a structure (which in JSON is just an object) with a single `id` field, whose value is a string containing the integer `1004`.

This example used a document with an integer identifier, but any valid MongoDB document identifier (including documents) will work. The value of the `id` field in the payload will simply be a string representing a MongoDB extended JSON serialization (strict mode) of the original document's `_id` field. Find below a few examples showing how `_id` fields of
different types will get encoded as the event key's payload:

[options=""header"",role=""code-wordbreak-col2 code-wordbreak-col3""]
|==========================================
|Type    |MongoDB `_id` Value|Key's payload
|Integer |1234|`{ ""id"" : ""1234"" }`
|Float   |12.34|`{ ""id"" : ""12.34"" }`
|String  |""1234""|`{ ""id"" : ""\\""1234\\"""" }`
|Document|{ ""hi"" : ""kafka"", ""nums"" : [10.0, 100.0, 1000.0] }|`{ ""id"" : ""{\\""hi\\"" : \\""kafka\\"", \\""nums\\"" : [10.0, 100.0, 1000.0]}"" }`
|ObjectId|ObjectId(""596e275826f08b2730779e1f"")|`{ ""id"" : ""{\\""$oid\\"" : \\""596e275826f08b2730779e1f\\""}"" }`
|Binary  |BinData(""a2Fma2E="",0)|`{ ""id"" : ""{\\""$binary\\"" : \\""a2Fma2E=\\"", \\""$type\\"" : \\""00\\""}"" }`
|==========================================

[WARNING]
====
As of Debezium 0.3.0, the Debezium MongoDB connector ensures that all Kafka Connect _schema names_ are http://avro.apache.org/docs/current/spec.html#names[valid Avro schema names]. This means that the logical server name must start with Latin letters or an underscore (e.g., [a-z,A-Z,\\_]), and the remaining characters in the logical server name and all characters in the database and collections names must be Latin letters, digits, or an underscore (e.g., [a-z,A-Z,0-9,\\_]). If not, then all invalid characters will automatically be replaced with an underscore character.

This can lead to unexpected conflicts in schemas names when the logical server name, database names, and table names contain other characters, and the only distinguishing characters between table full names are invalid and thus replaced with underscores. The connector attempts to produce an exception in this such cases, but only when the conflicts exist between schemas used within a single connector.
====

[[change-events-value]]
==== Change event's value

The value of the change event message is a bit more complicated. Like the key message, it has a _schema_ section and _payload_ section. The payload section of every change event value produced by the MongoDB connector has an _envelope_ structure with the following fields:

* `op` is a mandatory field that contains a string value describing the type of operation. Values for the MongoDB connector are `c` for create (or insert), `u` for update, `d` for delete, and `r` for read (in the case of a initial sync).
* `after` is an optional field that if present contains the state of the document _after_ the event occurred. MongoDB's oplog entries only contain the full state of a document for _create_ events, so these are the only events that contain an _after_ field.
* `source` is a mandatory field that contains a structure describing the source metadata for the event, which in the case of MongoDB contains several fields: the Debezium version, the logical name, the replica set's name, the namespace of the collection, the MongoDB timestamp (and ordinal of the event within the timestamp) at which the event occurred, the identifier of the MongoDB operation (e.g., the `h` field in the oplog event), and the initial sync flag if the event resulted during an intial sync.
* `ts_ms` is optional and if present contains the time (using the system clock in the JVM running the Kafka Connect task) at which the connector processed the event.

And of course, the _schema_ portion of the event message's value contains a schema that describes this envelope structure and the nested fields within it.

Let's look at what a _create_/_read_ event value might look like for our `customers` table:

[source,json,indent=0,subs=""attributes""]
----
{
    ""schema"": {
      ""type"": ""struct"",
      ""fields"": [
        {
          ""type"": ""string"",
          ""optional"": true,
          ""name"": ""io.debezium.data.Json"",
          ""version"": 1,
          ""field"": ""after""
        },
        {
          ""type"": ""string"",
          ""optional"": true,
          ""name"": ""io.debezium.data.Json"",
          ""version"": 1,
          ""field"": ""patch""
        },
        {
          ""type"": ""struct"",
          ""fields"": [
            {
              ""type"": ""string"",
              ""optional"": false,
              ""field"": ""version""
            },
            {
              ""type"": ""string"",
              ""optional"": false,
              ""field"": ""connector""
            },
            {
              ""type"": ""string"",
              ""optional"": false,
              ""field"": ""name""
            },
            {
              ""type"": ""int64"",
              ""optional"": false,
              ""field"": ""ts_ms""
            },
            {
              ""type"": ""boolean"",
              ""optional"": true,
              ""default"": false,
              ""field"": ""snapshot""
            },
            {
              ""type"": ""string"",
              ""optional"": false,
              ""field"": ""db""
            },
            {
              ""type"": ""string"",
              ""optional"": false,
              ""field"": ""rs""
            },
            {
              ""type"": ""string"",
              ""optional"": false,
              ""field"": ""collection""
            },
            {
              ""type"": ""int32"",
              ""optional"": false,
              ""field"": ""ord""
            },
            {
              ""type"": ""int64"",
              ""optional"": true,
              ""field"": ""h""
            }
          ],
          ""optional"": false,
          ""name"": ""io.debezium.connector.mongo.Source"",
          ""field"": ""source""
        },
        {
          ""type"": ""string"",
          ""optional"": true,
          ""field"": ""op""
        },
        {
          ""type"": ""int64"",
          ""optional"": true,
          ""field"": ""ts_ms""
        }
      ],
      ""optional"": false,
      ""name"": ""dbserver1.inventory.customers.Envelope""
      },
    ""payload"": {
      ""after"": ""{\\""_id\\"" : {\\""$numberLong\\"" : \\""1004\\""},\\""first_name\\"" : \\""Anne\\"",\\""last_name\\"" : \\""Kretchmar\\"",\\""email\\"" : \\""annek@noanswer.org\\""}"",
      ""patch"": null,
      ""source"": {
        ""version"": ""{debezium-version}"",
        ""connector"": ""mongodb"",
        ""name"": ""fulfillment"",
        ""ts_ms"": 1558965508000,
        ""snapshot"": true,
        ""db"": ""inventory"",
        ""rs"": ""rs0"",
        ""collection"": ""customers"",
        ""ord"": 31,
        ""h"": 1546547425148721999
      },
      ""op"": ""r"",
      ""ts_ms"": 1558965515240
    }
  }
----

If we look at the `schema` portion of this event's _value_, we can see the schema for the _envelope_ is specific to the collection, and the schema for the `source` structure (which is specific to the MongoDB connector and reused across all events). Also note that the `after` value is always a string, and that by convention it will contain a JSON representation of the document.

If we look at the `payload` portion of this event's _value_, we can see the information in the event, namely that it is describing that the document was read as part of an initial sync (since `op=r` and `initsync=true`), and that the `after` field value contains the JSON string representation of the document.

[TIP]
====
It may appear that the JSON representations of the events are much larger than the rows they describe. This is true, because the JSON representation must include the _schema_ and the _payload_ portions of the message. It is possible and even recommended to use the link:/docs/faq/#avro-converter[Avro Converter] to dramatically decrease the size of the actual messages written to the Kafka topics.
====

The value of an _update_ change event on this collection will actually have the exact same _schema_, and its payload will be structured the same but will hold different values. Specifically, an update event will not have an `after` value and will instead have a `patch` string containing the JSON representation of the idempotent update operation. Here's an example:

[source,json,indent=0,subs=""attributes""]
----
{
    ""schema"": { ... },
    ""payload"": {
      ""op"": ""u"",
      ""ts_ms"": 1465491461815,
      ""patch"": ""{\\""$set\\"":{\\""first_name\\"":\\""Anne Marie\\""}}"",
      ""source"": {
        ""version"": ""{debezium-version}"",
        ""connector"": ""mongodb"",
        ""name"": ""fulfillment"",
        ""ts_ms"": 1558965508000,
        ""snapshot"": true,
        ""db"": ""inventory"",
        ""rs"": ""rs0"",
        ""collection"": ""customers"",
        ""ord"": 6,
        ""h"": 1546547425148721999
      }
    }
  }
----

When we compare this to the value in the _insert_ event, we see a couple of differences in the `payload` section:

* The `op` field value is now `u`, signifying that this document changed because of an update
* The `patch` field appears and has the stringified JSON representation of the actual MongoDB idempotent change to the document, which in this example involves setting the `first_name` field to a new value
* The `after` field no longer appears
* The `source` field structure has the same fields as before, but the values are different since this event is from a different position in the oplog.
* The `ts_ms` shows the timestamp that Debezium processed this event.

[WARNING]
====
The content of the `patch` field is provided by MongoDB itself and its exact format depends on the version.
You can thus expect that the messages will not be same for MongoDB 3.4 and 3.6 and you should be careful
while upgrading the MongoDB instance to a new version.

All examples in this document were obtained from MongoDB 3.4 and might differ if you use a different one.
====

[NOTE]
====
Once again, update events in MongoDB's oplog don't have the _before_ or _after_ states of the changed document, so there's no way for the Debezium connector to provide this information. However, because _create_ or _read_ events _do_ contain the starting state, downstream consumers of the stream can actually fully-reconstruct the state by keeping the latest state for each document and applying each event to that state. Debezium connector's are not able to keep such state, so it is not able to do this.
====

So far we've seen samples of _create_/_read_ and _update_ events. Now, let's look at the value of a _delete_ event for the same table. The value of an _delete_ event on this collection will also have the exact same _schema_, and its payload will be structured the same but will hold different values. In particular, a delete event will not have an `after` value or a `patch` value:

[source,json,indent=0,subs=""attributes""]
----
{
    ""schema"": { ... },
    ""payload"": {
      ""op"": ""d"",
      ""ts_ms"": 1465495462115,
      ""source"": {
        ""version"": ""{debezium-version}"",
        ""connector"": ""mongodb"",
        ""name"": ""fulfillment"",
        ""ts_ms"": 1558965508000,
        ""snapshot"": true,
        ""db"": ""inventory"",
        ""rs"": ""rs0"",
        ""collection"": ""customers"",
        ""ord"": 6,
        ""h"": 1546547425148721999
      }
    }
  }
----

When we compare this to the value in the other events, we see a couple of differences in the `payload` section:

* The `op` field value is now `d`, signifying that this document was deleted
* The `patch` field does not appear
* The `after` field does not appear
* The `source` field structure has the same fields as before, but the values are different since this event is from a different position in the oplog.
* The `ts_ms` shows the timestamp that Debezium processed this event.

The Debezium MongoDB connector actually provides one other kind of event. Each _delete_ event will be followed by a _tombstone_ event that has the same key but a `null` value, giving Kafka enough information to know that its https://cwiki.apache.org/confluence/display/KAFKA/Log+Compaction[Kafka log compaction] mechanism can remove _all_ messages with that key.

[NOTE]
====
All MongoDB connector events are designed to work with https://cwiki.apache.org/confluence/display/KAFKA/Log+Compaction[Kafka log compaction], which allows for the removal of older messages as long as at least the most recent message for every key is kept. This is how Kafka can reclaim storage space while ensuring the topic contains a complete dataset and can be used for reloading key-based state.

All MongoDB connector events for a uniquely identified document will have exactly the same key, signalling to Kafka that only the latest event be kept. And, a tombstone event informs Kafka that _all_ messages with that same key can be removed.
====

[[fault-tolerance]]
[[when-things-go-wrong]]
=== When things go wrong

Debezium is a distributed system that captures all changes in multiple upstream databases, and will never miss or lose an event. Of course, when the system is operating nominally or being administered carefully, then Debezium provides _exactly once_ delivery of every change event. However, if a fault does happen then the system will still not lose any events, although while it is recovering from the fault it may repeat some change events. Thus, in these abnormal situations Debezium (like Kafka) provides _at least once_ delivery of change events.

The rest of this section describes how Debezium handles various kinds of faults and problems.

==== Configuration and startup errors

The connector will fail upon startup, report an error/exception in the log, and stop running when the connector's configuration is invalid, or when the connector repeatedly fails to connect to MongoDB using the specified connectivity parameters. Reconnection is done using exponential backoff, and the maximum number of attempts is configurable.

In these cases, the error will have more details about the problem and possibly a suggested work around. The connector can be restarted when the configuration has been corrected or the MongoDB problem has been addressed.

==== MongoDB becomes unavailable

Once the connector is running, if the primary node of any of the MongoDB replica sets become unavailable or unreachable, the connector will repeatedly attempt to reconnect to the primary node, using exponential backoff to prevent saturating the network or servers. If the primary remains unavailable after the configurable number of connection attempts, the connector will fail.

The attempts to reconnect are controlled by three properties:

* `connect.backoff.initial.delay.ms` - The delay before attempting to reconnect for the first time, with a default of 1 second (1000 milliseconds).
* `connect.backoff.max.delay.ms` - The maximum delay before attempting to reconnect, with a default of 120 seconds (120,000 milliseconds).
* `connect.max.attempts` - The maximum number of attempts before an error is produced, with a default of 16.

Each delay is double that of the prior delay, up to the maximum delay. Given the default values, the following table shows the delay for each failed connection attempt and the total accumulated time before failure.

[width=75,cols=""30%a,30%a,40%a"",options=""header,footer"",role=""table table-bordered table-striped""]
|=======================
|Reconnection attempt number
|Delay before attempt, in seconds
|Total delay before attempt, in minutes and seconds

|1 |1 |00:01
|2 |2 |00:03
|3 |4 |00:07
|4 |8 |00:15
|5 |16 |00:31
|6 |32 |01:03
|7 |64 |02:07
|8 |120|04:07
|9 |120|06:07
|10 |120|08:07
|11 |120|10:07
|12 |120|12:07
|13 |120|14:07
|14 |120|16:07
|15 |120|18:07
|16 |120|20:07
|=======================


==== Kafka Connect process stops gracefully

If Kafka Connect is being run in distributed mode, and a Kafka Connect process is stopped gracefully, then prior to shutdown of that processes Kafka Connect will migrate all of the process' connector tasks to another Kafka Connect process in that group, and the new connector tasks will pick up exactly where the prior tasks left off. There will be a short delay in processing while the connector tasks are stopped gracefully and restarted on the new processes.

If the group contains only one process and that process is stopped gracefully, then Kafka Connect will stop the connector and record the last offset for each replica set. Upon restart, the replica set tasks will continue exactly where they left off.

==== Kafka Connect process crashes

If the Kafka Connector process stops unexpectedly, then any connector tasks it was running will obviously terminate without recording their most recently-processed offsets. When Kafka Connect is being run in distributed mode, it will restart those connector tasks on other processes. However, the MongoDB connectors will resume from the last offset _recorded_ by the earlier processes, which means that the new replacement tasks may generate some of the same change events that were processed just prior to the crash. The number of duplicate events will depend on the offset flush period and the volume of data changes just before the crash.

[TIP]
====
Because there is a chance that some events may be duplicated during a recovery from failure, consumers should always anticipate some events may be duplicated. Debezium change are idempotent, so a sequence of events always results in the same state.

Debezium also includes with each change event message the source-specific information about the origin of the event, including the MongoDB event's unique transaction identifier (`h`) and timestamp (`sec` and `ord`). Consumers can keep track of other of these values to know whether it has already seen a particular event.
====

==== Kafka becomes unavailable

As the connector generates change events, the Kafka Connect framework records those events in Kafka using the Kafka producer API. Kafka Connect will also periodically record the latest offset that appears in those change events, at a frequency you've specified in the Kafka Connect worker configuration. If the Kafka brokers become unavailable, the Kafka Connect worker process running the connectors will simply repeatedly attempt to reconnect to the Kafka brokers. In other words, the connector tasks will simply pause until a connection can be reestablished, at which point the connectors will resume exactly where they left off.

==== Connector is stopped for a duration

If the connector is gracefully stopped, the replica sets can continue to be used and any new changes will be recorded in MongoDB's oplog. When the connector is restarted, it will resume reading the oplog for each replica set where it last left off, recording change events for all of the changes that were made while the connector was stopped. If the connector is stopped long enough such that MongoDB purges from its oplog some operations that the connector has not read, then upon startup the connector will perform an initial sync.

A properly configured Kafka cluster is able to https://engineering.linkedin.com/kafka/benchmarking-apache-kafka-2-million-writes-second-three-cheap-machines[massive throughput]. Kafka Connect is written with Kafka best practices, and given enough resources will also be able to handle very large numbers of database change events. Because of this, when a connector has been restarted after a while, it is very likely to catch up with the database, though how quickly will depend upon the capabilities and performance of Kafka and the volume of changes being made to the data in MongoDB.

[NOTE]
====
If the connector remains stopped for long enough, MongoDB might purge older oplog files and the connector's last position may be lost. In this case, when the connector configured with _initial_ snapshot mode (the default) is finally restarted, the MongoDB server will no longer have the starting point and the connector will fail with an error.
====

==== MongoDB loses writes

It is possible for MongoDB to lose commits in specific failure situations. For example, if the primary applies a change and records it in its oplog before it then crashes unexpectedly, the secondary nodes may not have had a chance to read those changes from the primary's oplog before the primary crashed. If one such secondary is then elected as primary, it's oplog is missing the last changes that the old primary had recorded and no longer has those changes.

In these cases where MongoDB loses changes recorded in a primary's oplog, it is possible that the MongoDB connector may or may not capture these lost changes. At this time, there is no way to prevent this side effect of MongoDB.



[[configuration]]
[[deploying-a-connector]]
== Deploying a connector

If you've already installed https://zookeeper.apache.org[Zookeeper], http://kafka.apache.org/[Kafka], and http://kafka.apache.org/documentation.html#connect[Kafka Connect], then using Debezium's MongoDB connector is easy. Simply download the https://repo1.maven.org/maven2/io/debezium/debezium-connector-mongodb/0.3.0/debezium-connector-mongodb-0.3.0-plugin.tar.gz[connector's plugin archive], extract the JARs into your Kafka Connect environment, and add the directory with the JARs to http://docs.confluent.io/3.0.0/connect/userguide.html#installing-connector-plugins[Kafka Connect's classpath]. Restart your Kafka Connect process to pick up the new JARs.

If immutable containers are your thing, then check out https://hub.docker.com/r/debezium/[Debezium's Docker images] for Zookeeper, Kafka, and Kafka Connect with the MongoDB connector already pre-installed and ready to go. Our xref:tutorial.adoc[tutorial] even walks you through using these images, and this is a great way to learn what Debezium is all about. You can even link:/blog/2016/05/31/Debezium-on-Kubernetes/[run Debezium on Kubernetes and OpenShift].

To use the connector to produce change events for a particular MongoDB replica set or sharded cluster, simply create a link:#configuration[configuration file for the MongoDB Connector] and use the link:http://docs.confluent.io/3.0.0/connect/userguide.html#rest-interface[Kafka Connect REST API] to add that connector to your Kafka Connect cluster. When the connector starts, it will perform an initial sync of the collections in your MongoDB replica set(s) and start reading the replica sets' oplogs, producing events for every inserted, updated, and deleted row. Optionally filter out collections that are not needed.

[[example]]
[[example-configuration]]
=== Example configuration

Using the MongoDB connector is straightforward. Here is an example of the configuration for a MongoDB connector that monitors a MongoDB replica set `rs0` at port 27017 on 192.168.99.100, which we logically name `fullfillment`:

[source,json]
----
{
  ""name"": ""inventory-connector"",  // <1>
  ""config"": {
    ""connector.class"": ""io.debezium.connector.mongodb.MongoDbConnector"", // <2>
    ""mongodb.hosts"": ""rs0/192.168.99.100:27017"", // <3>
    ""mongodb.name"": ""fullfillment"", // <4>
    ""collection.whitelist"": ""inventory[.]*"", // <5>
  }
}
----
<1> The name of our connector when we register it with a Kafka Connect service.
<2> The name of the MongoDB connector class.
<3> The host addresses to use to connect to the MongoDB replica set
<4> The _logical name_ of the MongoDB replica set, which forms a namespace for generated events and is used in all the names of the Kafka topics to which the connector writes, the Kafka Connect schema names, and the namespaces of the corresponding Avro schema when the link:#avro-converter[Avro Connector] is used.
<5> A list of regular expressions that match the collection namespaces (e.g., <dbName>.<collectionName>) of all collections to be monitored. This is optional.

See the link:#connector-properties[complete list of connector properties] that can be specified in these configurations.

This configuration can be sent via POST to a running Kafka Connect service, which will then record the configuration and start up the one connector task that will connect to the MongoDB replica set or sharded cluster, assign tasks for each replica set, perform an initial sync if necessary, read the oplog, and record events to Kafka topics.


[[connector-properties]]
=== Connector properties

The following configuration properties are _required_ unless a default value is available.

[cols=""35%a,10%a,55%a"",options=""header,footer"",role=""table table-bordered table-striped code-wordbreak-col""]
|=======================
|Property
|Default
|Description

|`name`
|
|Unique name for the connector. Attempting to register again with the same name will fail. (This property is required by all Kafka Connect connectors.)

|`connector.class`
|
|The name of the Java class for the connector. Always use a value of `io.debezium.connector.mongodb.MongoDbConnector` for the MongoDB connector.

|`mongodb.hosts`
|
|The comma-separated list of hostname and port pairs (in the form 'host' or 'host:port') of the MongoDB servers in the replica set. The list can contain a single hostname and port pair. If `mongodb.members.auto.discover` is set to `false`, then the host and port pair should be prefixed with the replica set name (e.g., `rs0/localhost:27017`).

|`mongodb.name`
|
|A unique name that identifies the connector and/or MongoDB replica set or sharded cluster that this connector monitors. Each server should be monitored by at most one Debezium connector, since this server name prefixes all persisted Kafka topics emanating from the MongoDB replica set or cluster.

|`mongodb.user`
|
|Name of the database user to be used when connecting to MongoDB. This is required only when MongoDB is configured to use authentication.

|`mongodb.password`
|
|Password to be used when connecting to MongoDB. This is required only when MongoDB is configured to use authentication.

|`mongodb.authsource`
|`admin`
|Database (authentication source) containing MongoDB credentials. This is required only when MongoDB is configured to use authentication with another authentication database than `admin`.

|`mongodb.ssl.enabled`
|`false`
|Connector will use SSL to connect to MongoDB instances.

|`mongodb.ssl.invalid.hostname.allowed`
|`false`
|When SSL is enabled this setting controls whether strict hostname checking is disabled during connection phase. If `true` the connection will not prevent man-in-the-middle attacks.

|`database.whitelist`
|_empty string_
|An optional comma-separated list of regular expressions that match database names to be monitored; any database name not included in the whitelist will be excluded from monitoring. By default all databases will be monitored. May not be used with `database.blacklist`.

|`database.blacklist`
|_empty string_
|An optional comma-separated list of regular expressions that match database names to be excluded from monitoring; any database name not included in the blacklist will be monitored. May not be used with `database.whitelist`.

|`collection.whitelist`
|_empty string_
|An optional comma-separated list of regular expressions that match fully-qualified namespaces for MongoDB collections to be monitored; any collection not included in the whitelist will be excluded from monitoring. Each identifier is of the form _databaseName_._collectionName_. By default the connector will monitor all collections except those in the `local` and `admin` databases. May not be used with `collection.blacklist`.

|`collection.blacklist`
|_empty string_
|An optional comma-separated list of regular expressions that match fully-qualified namespaces for MongoDB collections to be excluded from monitoring; any collection not included in the blacklist will be monitored. Each identifier is of the form _databaseName_._collectionName_. May not be used with `collection.whitelist`.

|`snapshot.mode`
|`initial`
|Specifies the criteria for running a snapshot (eg. initial sync) upon startup of the connector. The default is *initial*, and specifies the connector reads a snapshot when either no offset is found or if the oplog no longer contains the previous offset. The *never* option specifies that the connector should never use snapshots, instead the connector should proceed to tail the log.

|`field.blacklist`
|_empty string_
|An optional comma-separated list of the fully-qualified names of fields that should be excluded from change event message values. Fully-qualified names for fields are of the form _databaseName_._collectionName_._fieldName_._nestedFieldName_, where _databaseName_ and _collectionName_ may contain the wildcard (*) which matches any characters.

|`field.renames`
|_empty string_
|An optional comma-separated list of the fully-qualified replacements of fields that should be used to rename fields in change event message values. Fully-qualified replacements for fields are of the form _databaseName_._collectionName_._fieldName_._nestedFieldName_:__newNestedFieldName__, where _databaseName_ and _collectionName_ may contain the wildcard (*) which matches any characters, the colon character (:) is used to determine rename mapping of field. The next field replacement is applied to the result of the previous field replacement in the list, so keep this in mind when renaming multiple fields that are in the same path.

|`tasks.max`
|`1`
|The maximum number of tasks that should be created for this connector. The MongoDB connector will attempt to use a separate task for each replica set, so the default is acceptable when using the connector with a single MongoDB replica set. When using the connector with a MongoDB sharded cluster, we recommend specifying a value that is equal to or more than the number of shards in the cluster, so that the work for each replica set can be distributed by Kafka Connect.

|`initial.sync.max.threads`
|`1`
|Positive integer value that specifies the maximum number of threads used to perform an intial sync of the collections in a replica set. Defaults to 1.

|`tombstones.on.delete`
|`true`
| Controls whether a tombstone event should be generated after a delete event. +
When `true` the delete operations are represented by a delete event and a subsequent tombstone event. When `false` only a delete event is sent. +
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.

|`snapshot.delay.ms`
|
|An interval in milli-seconds that the connector should wait before taking a snapshot after starting up; +
Can be used to avoid snapshot interruptions when starting multiple connectors in a cluster, which may cause re-balancing of connectors.

|`snapshot.fetch.size`
|`0`
|Specifies the maximum number of documents that should be read in one go from each collection while taking a snapshot.
The connector will read the collection contents in multiple batches of this size. +
Defaults to 0, which indicates that the server chooses an appropriate fetch size.

|=======================


The following _advanced_ configuration properties have good defaults that will work in most situations and therefore rarely need to be specified in the connector's configuration.

[cols=""35%a,10%a,55%a"",width=100,options=""header,footer"",role=""table table-bordered table-striped code-wordbreak-col""]
|=======================
|Property
|Default
|Description

|`max.queue.size`
|`8192`
|Positive integer value that specifies the maximum size of the blocking queue into which change events read from the database log are placed before they are written to Kafka. This queue can provide backpressure to the oplog reader when, for example, writes to Kafka are slower or if Kafka is not available. Events that appear in the queue are not included in the offsets periodically recorded by this connector. Defaults to 8192, and should always be larger than the maximum batch size specified in the `max.batch.size` property.

|`max.batch.size`
|`2048`
|Positive integer value that specifies the maximum size of each batch of events that should be processed during each iteration of this connector. Defaults to 2048.

|`poll.interval.ms`
|`1000`
|Positive integer value that specifies the number of milliseconds the connector should wait during each iteration for new change events to appear. Defaults to 1000 milliseconds, or 1 second.

|`connect.backoff.initial.delay.ms`
|`1000`
|Positive integer value that specifies the initial delay when trying to reconnect to a primary after the first failed connection attempt or when no primary is available. Defaults to 1 second (1000 ms).

|`connect.backoff.max.delay.ms`
|`1000`
|Positive integer value that specifies the maximum delay when trying to reconnect to a primary after repeated failed connection attempts or when no primary is available. Defaults to 120 seconds (120,000 ms).

|`connect.max.attempts`
|`16`
|Positive integer value that specifies the maximum number of failed connection attempts to a replica set primary before an exception occurs and task is aborted. Defaults to 16, which with the defaults for `connect.backoff.initial.delay.ms` and `connect.backoff.max.delay.ms` results in just over 20 minutes of attempts before failing.

|`mongodb.members.auto.discover`
|`true`
|Boolean value that specifies whether the addresses in 'mongodb.hosts' are seeds that should be used to discover all members of the cluster or replica set (`true`), or whether the address(es) in `mongodb.hosts` should be used as is (`false`). The default is `true` and should be used in all cases except where MongoDB is link:#mongodb-replicaset[fronted by a proxy].

|`source.struct.version`
|v2
|Schema version for the `source` block in CDC events; Debezium 0.10 introduced a few breaking +
changes to the structure of the `source` block in order to unify the exposed structure across
all the connectors. +
By setting this option to `v1` the structure used in earlier versions can be produced.
Note that this setting is not recommended and is planned for removal in a future Debezium version.

|`heartbeat.interval.ms`
|`0`
|Controls how frequently heartbeat messages are sent. +
This property contains an interval in milli-seconds that defines how frequently the connector sends messages into a heartbeat topic.
This can be used to monitor whether the connector is still receiving change events from the database.
You also should leverage heartbeat messages in cases where only records in non-captured collections are changed for a longer period of time.
In such situation the connector would proceed to read the oplog from the database but never emit any change messages into Kafka,
which in turn means that no offset updates will be committed to Kafka.
This will cause the oplog files to be rotated out but connector will not notice it so on restart some events are no longer available which leads to the need of re-execution of the initial snapshot.

Set this parameter to `0` to not send heartbeat messages at all. +
Disabled by default.

|`heartbeat.topics.prefix`
|`__debezium-heartbeat`
|Controls the naming of the topic to which heartbeat messages are sent. +
The topic is named according to the pattern `<heartbeat.topics.prefix>.<server.name>`.

|`sanitize.field.names`
|`true` when connector configuration explicitly specifies the `key.converter` or `value.converter` parameters to use Avro, otherwise defaults to `false`.
|Whether field names will be sanitized to adhere to Avro naming requirements.
See xref:configuration/avro.adoc#names[Avro naming] for more details.

|=======================
",12116,False,2030.8556751925348,median
"// sgmm/am-sgmm.cc

// Copyright 2009-2011  Microsoft Corporation;  Lukas Burget;
//                      Saarland University (Author: Arnab Ghoshal);
//                      Ondrej Glembek;  Yanmin Qian;
// Copyright 2012-2013  Johns Hopkins University (Author: Daniel Povey)
//                      Liang Lu;  Arnab Ghoshal

// See ../../COPYING for clarification regarding multiple authors
//
// 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
//
// THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
// WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
// MERCHANTABLITY OR NON-INFRINGEMENT.
// See the Apache 2 License for the specific language governing permissions and
// limitations under the License.

#include <functional>
#include <queue>
#include ""sgmm/am-sgmm.h""
#include ""thread/kaldi-thread.h""

namespace kaldi {
using std::vector;

// This function needs to be added because std::generate is complaining
// about RandGauss(), which takes an optional arguments.
static inline float _RandGauss()
{
  return RandGauss();
}

void AmSgmm::Read(std::istream &in_stream, bool binary) {
  int32 num_states, feat_dim, num_gauss;
  std::string token;

  ExpectToken(in_stream, binary, ""<SGMM>"");
  ExpectToken(in_stream, binary, ""<NUMSTATES>"");
  ReadBasicType(in_stream, binary, &num_states);
  ExpectToken(in_stream, binary, ""<DIMENSION>"");
  ReadBasicType(in_stream, binary, &feat_dim);
  KALDI_ASSERT(num_states > 0 && feat_dim > 0);

  ReadToken(in_stream, binary, &token);

  while (token != ""</SGMM>"") {
    if (token == ""<DIAG_UBM>"") {
      diag_ubm_.Read(in_stream, binary);
    } else if (token == ""<FULL_UBM>"") {
      full_ubm_.Read(in_stream, binary);
    } else if (token == ""<SigmaInv>"") {
      ExpectToken(in_stream, binary, ""<NUMGaussians>"");
      ReadBasicType(in_stream, binary, &num_gauss);
      SigmaInv_.resize(num_gauss);
      for (int32 i = 0; i < num_gauss; i++) {
        SigmaInv_[i].Read(in_stream, binary);
      }
    } else if (token == ""<M>"") {
      ExpectToken(in_stream, binary, ""<NUMGaussians>"");
      ReadBasicType(in_stream, binary, &num_gauss);
      M_.resize(num_gauss);
      for (int32 i = 0; i < num_gauss; i++) {
        M_[i].Read(in_stream, binary);
      }
    } else if (token == ""<N>"") {
      ExpectToken(in_stream, binary, ""<NUMGaussians>"");
      ReadBasicType(in_stream, binary, &num_gauss);
      N_.resize(num_gauss);
      for (int32 i = 0; i < num_gauss; i++) {
        N_[i].Read(in_stream, binary);
      }
    } else if (token == ""<w>"") {
      w_.Read(in_stream, binary);
    } else if (token == ""<v>"") {
      v_.resize(num_states);
      for (int32 j = 0; j < num_states; j++) {
        v_[j].Read(in_stream, binary);
      }
    } else if (token == ""<c>"") {
      c_.resize(num_states);
      for (int32 j = 0; j < num_states; j++) {
        c_[j].Read(in_stream, binary);
      }
    } else if (token == ""<n>"") {
      n_.resize(num_states);
      for (int32 j = 0; j < num_states; j++) {
        n_[j].Read(in_stream, binary);
      }
      // The following are the Gaussian prior parameters for MAP adaptation of M
      // They may be moved to somewhere else eventually.
    } else if (token == ""<M_Prior>"") {
      ExpectToken(in_stream, binary, ""<NUMGaussians>"");
      ReadBasicType(in_stream, binary, &num_gauss);
      M_prior_.resize(num_gauss);
      for (int32 i = 0; i < num_gauss; i++) {
        M_prior_[i].Read(in_stream, binary);
      }
    } else if (token == ""<Row_Cov_Inv>"") {
      row_cov_inv_.Read(in_stream, binary);
    } else if (token == ""<Col_Cov_Inv>"") {
      col_cov_inv_.Read(in_stream, binary);
    } else {
      KALDI_ERR << ""Unexpected token '"" << token << ""' in model file "";
    }
    ReadToken(in_stream, binary, &token);
  }

  if (n_.empty()) {
    ComputeNormalizers();
  }
}

void AmSgmm::Write(std::ostream &out_stream, bool binary,
                   SgmmWriteFlagsType write_params) const {
  int32 num_states = NumPdfs(),
      feat_dim = FeatureDim(),
      num_gauss = NumGauss();

  WriteToken(out_stream, binary, ""<SGMM>"");
  if (!binary) out_stream << ""\\n"";
  WriteToken(out_stream, binary, ""<NUMSTATES>"");
  WriteBasicType(out_stream, binary, num_states);
  WriteToken(out_stream, binary, ""<DIMENSION>"");
  WriteBasicType(out_stream, binary, feat_dim);
  if (!binary) out_stream << ""\\n"";

  if (write_params & kSgmmBackgroundGmms) {
    WriteToken(out_stream, binary, ""<DIAG_UBM>"");
    diag_ubm_.Write(out_stream, binary);
    WriteToken(out_stream, binary, ""<FULL_UBM>"");
    full_ubm_.Write(out_stream, binary);
  }

  if (write_params & kSgmmGlobalParams) {
    WriteToken(out_stream, binary, ""<SigmaInv>"");
    WriteToken(out_stream, binary, ""<NUMGaussians>"");
    WriteBasicType(out_stream, binary, num_gauss);
    if (!binary) out_stream << ""\\n"";
    for (int32 i = 0; i < num_gauss; i++) {
      SigmaInv_[i].Write(out_stream, binary);
    }
    WriteToken(out_stream, binary, ""<M>"");
    WriteToken(out_stream, binary, ""<NUMGaussians>"");
    WriteBasicType(out_stream, binary, num_gauss);
    if (!binary) out_stream << ""\\n"";
    for (int32 i = 0; i < num_gauss; i++) {
      M_[i].Write(out_stream, binary);
    }
    if (N_.size() != 0) {
      WriteToken(out_stream, binary, ""<N>"");
      WriteToken(out_stream, binary, ""<NUMGaussians>"");
      WriteBasicType(out_stream, binary, num_gauss);
      if (!binary) out_stream << ""\\n"";
      for (int32 i = 0; i < num_gauss; i++) {
        N_[i].Write(out_stream, binary);
      }
    }
    WriteToken(out_stream, binary, ""<w>"");
    w_.Write(out_stream, binary);

    // The following are the Gaussian prior parameters for MAP adaptation of M.
    // They may be moved to somewhere else eventually.
    if (M_prior_.size() != 0) {
      WriteToken(out_stream, binary, ""<M_Prior>"");
      WriteToken(out_stream, binary, ""<NUMGaussians>"");
      WriteBasicType(out_stream, binary, num_gauss);
      if (!binary) out_stream << ""\\n"";
      for (int32 i = 0; i < num_gauss; i++) {
        M_prior_[i].Write(out_stream, binary);
      }

      KALDI_ASSERT(row_cov_inv_.NumRows() != 0 &&
                   ""Empty row covariance for MAP prior"");
      WriteToken(out_stream, binary, ""<Row_Cov_Inv>"");
      if (!binary) out_stream << ""\\n"";
      row_cov_inv_.Write(out_stream, binary);

      KALDI_ASSERT(col_cov_inv_.NumRows() != 0 &&
                   ""Empty column covariance for MAP prior"");
      WriteToken(out_stream, binary, ""<Col_Cov_Inv>"");
      if (!binary) out_stream << ""\\n"";
      col_cov_inv_.Write(out_stream, binary);
    }
    // end priors for MAP adaptation
  }

  if (write_params & kSgmmStateParams) {
    WriteToken(out_stream, binary, ""<v>"");
    for (int32 j = 0; j < num_states; j++) {
      v_[j].Write(out_stream, binary);
    }
    WriteToken(out_stream, binary, ""<c>"");
    for (int32 j = 0; j < num_states; j++) {
      c_[j].Write(out_stream, binary);
    }
  }

  if (write_params & kSgmmNormalizers) {
    WriteToken(out_stream, binary, ""<n>"");
    if (n_.empty())
      KALDI_WARN << ""Not writing normalizers since they are not present."";
    else
      for (int32 j = 0; j < num_states; j++)
        n_[j].Write(out_stream, binary);
  }

  WriteToken(out_stream, binary, ""</SGMM>"");
}

void AmSgmm::Check(bool show_properties) {
  int32 num_states = NumPdfs(),
      num_gauss = NumGauss(),
      feat_dim = FeatureDim(),
      phn_dim = PhoneSpaceDim(),
      spk_dim = SpkSpaceDim();

  if (show_properties)
    KALDI_LOG << ""AmSgmm: #states = "" << num_states << "", #Gaussians = ""
              << num_gauss << "", feature dim = "" << feat_dim
              << "", phone-space dim ="" << phn_dim
              << "", speaker-space dim ="" << spk_dim;
  KALDI_ASSERT(num_states > 0 && num_gauss > 0 && feat_dim > 0 && phn_dim > 0);

  std::ostringstream debug_str;

  // First check the diagonal-covariance UBM.
  KALDI_ASSERT(diag_ubm_.NumGauss() == num_gauss);
  KALDI_ASSERT(diag_ubm_.Dim() == feat_dim);

  // Check the full-covariance UBM.
  KALDI_ASSERT(full_ubm_.NumGauss() == num_gauss);
  KALDI_ASSERT(full_ubm_.Dim() == feat_dim);

  // Check the globally-shared covariance matrices.
  KALDI_ASSERT(SigmaInv_.size() == static_cast<size_t>(num_gauss));
  for (int32 i = 0; i < num_gauss; i++) {
    KALDI_ASSERT(SigmaInv_[i].NumRows() == feat_dim &&
                 SigmaInv_[i](0, 0) > 0.0);  // or it wouldn't be +ve definite.
  }

  KALDI_ASSERT(M_.size() == static_cast<size_t>(num_gauss));
  for (int32 i = 0; i < num_gauss; i++) {
    KALDI_ASSERT(M_[i].NumRows() == feat_dim && M_[i].NumCols() == phn_dim);
  }

  KALDI_ASSERT(w_.NumRows() == num_gauss && w_.NumCols() == phn_dim);

  {  // check v, c.
    KALDI_ASSERT(v_.size() == static_cast<size_t>(num_states) &&
                 c_.size() == static_cast<size_t>(num_states));
    int32 nSubstatesTot = 0;
    for (int32 j = 0; j < num_states; j++) {
      int32 M_j = NumSubstates(j);
      nSubstatesTot += M_j;
      KALDI_ASSERT(M_j > 0 && v_[j].NumRows() == M_j &&
          c_[j].Dim() == M_j && v_[j].NumCols() == phn_dim);
    }
    debug_str << ""Substates: ""<< (nSubstatesTot) << "".  "";
  }

  // check n.
  if (n_.size() == 0) {
    debug_str << ""Normalizers: no.  "";
  } else {
    debug_str << ""Normalizers: yes.  "";
    KALDI_ASSERT(n_.size() == static_cast<size_t>(num_states));
    for (int32 j = 0; j < num_states; j++) {
      KALDI_ASSERT(n_[j].NumRows() == num_gauss &&
          n_[j].NumCols() == NumSubstates(j));
    }
  }

  if (show_properties)
    KALDI_LOG << ""Subspace GMM model properties: "" << debug_str.str();
}

void AmSgmm::InitializeFromFullGmm(const FullGmm &full_gmm,
                                   int32 num_states,
                                   int32 phn_subspace_dim,
                                   int32 spk_subspace_dim) {
  full_ubm_.CopyFromFullGmm(full_gmm);
  diag_ubm_.CopyFromFullGmm(full_gmm);
  if (phn_subspace_dim < 1 || phn_subspace_dim > full_gmm.Dim() + 1) {
    KALDI_WARN << ""Initial phone-subspace dimension must be in [1, ""
               << full_gmm.Dim() + 1 << ""]. Changing from "" << phn_subspace_dim
               << "" to "" << full_gmm.Dim() + 1;
    phn_subspace_dim = full_gmm.Dim() + 1;
  }
  if (spk_subspace_dim < 0 || spk_subspace_dim > full_gmm.Dim()) {
    KALDI_WARN << ""Initial spk-subspace dimension must be in [1, ""
               << full_gmm.Dim() << ""]. Changing from "" << spk_subspace_dim
               << "" to "" << full_gmm.Dim();
    spk_subspace_dim = full_gmm.Dim();
  }
  w_.Resize(0, 0);
  N_.clear();
  c_.clear();
  v_.clear();
  SigmaInv_.clear();

  KALDI_LOG << ""Initializing model"";
  Matrix<BaseFloat> norm_xform;
  ComputeFeatureNormalizer(full_gmm, &norm_xform);
  InitializeMw(phn_subspace_dim, norm_xform);
  if (spk_subspace_dim > 0) InitializeN(spk_subspace_dim, norm_xform);
  InitializeVecs(num_states);
  KALDI_LOG << ""Initializing variances"";
  InitializeCovars();
}

void AmSgmm::CopyFromSgmm(const AmSgmm &other,
                          bool copy_normalizers) {
  KALDI_LOG << ""Copying AmSgmm"";

  // Copy background GMMs
  diag_ubm_.CopyFromDiagGmm(other.diag_ubm_);
  full_ubm_.CopyFromFullGmm(other.full_ubm_);

  // Copy global params
  SigmaInv_ = other.SigmaInv_;
  M_ = other.M_;
  w_ = other.w_;
  N_ = other.N_;

  // Copy state-specific params, but only copy normalizers if requested.
  v_ = other.v_;
  c_ = other.c_;
  if (copy_normalizers) n_ = other.n_;

  KALDI_LOG << ""Done."";
}

void AmSgmm::CopyGlobalsInitVecs(const AmSgmm &other,
                                 int32 phn_subspace_dim,
                                 int32 spk_subspace_dim,
                                 int32 num_pdfs) {
  if (phn_subspace_dim < 1 || phn_subspace_dim > other.PhoneSpaceDim()) {
    KALDI_WARN << ""Initial phone-subspace dimension must be in [1, ""
        << other.PhoneSpaceDim() << ""]. Changing from "" << phn_subspace_dim
        << "" to "" << other.PhoneSpaceDim();
    phn_subspace_dim = other.PhoneSpaceDim();
  }
  if (spk_subspace_dim < 0 || spk_subspace_dim > other.SpkSpaceDim()) {
    KALDI_WARN << ""Initial spk-subspace dimension must be in [1, ""
               << other.SpkSpaceDim() << ""]. Changing from "" << spk_subspace_dim
               << "" to "" << other.SpkSpaceDim();
    spk_subspace_dim = other.SpkSpaceDim();
  }

  KALDI_LOG << ""Initializing model"";

  // Copy background GMMs
  diag_ubm_.CopyFromDiagGmm(other.diag_ubm_);
  full_ubm_.CopyFromFullGmm(other.full_ubm_);

  // Copy global params
  SigmaInv_ = other.SigmaInv_;
  int32 num_gauss = diag_ubm_.NumGauss(),
      data_dim = other.FeatureDim();
  M_.resize(num_gauss);
  w_.Resize(num_gauss, phn_subspace_dim);
  for (int32 i = 0; i < num_gauss; i++) {
    M_[i].Resize(data_dim, phn_subspace_dim);
    M_[i].CopyFromMat(other.M_[i].Range(0, data_dim, 0, phn_subspace_dim),
                      kNoTrans);
  }
  w_.CopyFromMat(other.w_.Range(0, num_gauss, 0, phn_subspace_dim), kNoTrans);

  if (spk_subspace_dim > 0) {
    N_.resize(num_gauss);
    for (int32 i = 0; i < num_gauss; i++) {
      N_[i].Resize(data_dim, spk_subspace_dim);
      N_[i].CopyFromMat(other.N_[i].Range(0, data_dim, 0, spk_subspace_dim),
                        kNoTrans);
    }
  } else {
    N_.clear();
  }
  InitializeVecs(num_pdfs);
}


void AmSgmm::ComputePerFrameVars(const VectorBase<BaseFloat> &data,
                                 const std::vector<int32> &gselect,
                                 const SgmmPerSpkDerivedVars &spk_vars,
                                 BaseFloat logdet_s,
                                 SgmmPerFrameDerivedVars *per_frame_vars) const {
  KALDI_ASSERT(!n_.empty() && ""ComputeNormalizers() must be called."");

  if (per_frame_vars->NeedsResizing(gselect.size(),
                                    FeatureDim(),
                                    PhoneSpaceDim()))
    per_frame_vars->Resize(gselect.size(), FeatureDim(), PhoneSpaceDim());

  per_frame_vars->gselect = gselect;
  per_frame_vars->xt.CopyFromVec(data);

  for (int32 ki = 0, last = gselect.size(); ki < last; ki++) {
    int32 i = gselect[ki];
    per_frame_vars->xti.Row(ki).CopyFromVec(per_frame_vars->xt);
    if (spk_vars.v_s.Dim() != 0)
      per_frame_vars->xti.Row(ki).AddVec(-1.0, spk_vars.o_s.Row(i));
  }
  Vector<BaseFloat> SigmaInv_xt(FeatureDim());
  for (int32 ki = 0, last = gselect.size(); ki < last; ki++) {
    int32 i = gselect[ki];
    SigmaInv_xt.AddSpVec(1.0, SigmaInv_[i], per_frame_vars->xti.Row(ki), 0.0);
    // Eq (35): z_{i}(t) = M_{i}^{T} \\Sigma_{i}^{-1} x_{i}(t)
    per_frame_vars->zti.Row(ki).AddMatVec(1.0, M_[i], kTrans, SigmaInv_xt, 0.0);
    // Eq.(36): n_{i}(t) = -0.5 x_{i}^{T} \\Sigma_{i}^{-1} x_{i}(t)
    per_frame_vars->nti(ki) = -0.5 * VecVec(per_frame_vars->xti.Row(ki),
                                            SigmaInv_xt) + logdet_s;
  }
}

BaseFloat AmSgmm::LogLikelihood(const SgmmPerFrameDerivedVars &per_frame_vars,
                                int32 j, BaseFloat log_prune) const {
  KALDI_ASSERT(j < NumPdfs());
  const vector<int32> &gselect = per_frame_vars.gselect;


  // Eq.(37): log p(x(t), m, i|j)  [indexed by j, ki]
  // Although the extra memory allocation of storing this as a
  // matrix might seem unnecessary, we save time in the LogSumExp()
  // via more effective pruning.
  Matrix<BaseFloat> logp_x(gselect.size(), NumSubstates(j));

  for (int32 ki = 0, last = gselect.size();  ki < last; ki++) {
    SubVector<BaseFloat> logp_xi(logp_x, ki);
    int32 i = gselect[ki];
    // for all substates, compute z_{i}^T v_{jm}
    logp_xi.AddMatVec(1.0, v_[j], kNoTrans, per_frame_vars.zti.Row(ki), 0.0);
    logp_xi.AddVec(1.0, n_[j].Row(i));  // for all substates, add n_{jim}
    logp_xi.Add(per_frame_vars.nti(ki));  // for all substates, add n_{i}(t)
  }
  // Eq. (38): log p(x(t)|j) = log \\sum_{m, i} p(x(t), m, i|j)
  return logp_x.LogSumExp(log_prune);
}

BaseFloat
AmSgmm::ComponentPosteriors(const SgmmPerFrameDerivedVars &per_frame_vars,
                            int32 j,
                            Matrix<BaseFloat> *post) const {
  KALDI_ASSERT(j < NumPdfs());
  if (post == NULL) KALDI_ERR << ""NULL pointer passed as return argument."";
  const vector<int32> &gselect = per_frame_vars.gselect;
  int32 num_gselect = gselect.size();
  post->Resize(num_gselect, NumSubstates(j));

  // Eq.(37): log p(x(t), m, i|j) = z_{i}^T v_{jm} (for all substates)
  post->AddMatMat(1.0, per_frame_vars.zti, kNoTrans, v_[j], kTrans, 0.0);
  for (int32 ki = 0; ki < num_gselect; ki++) {
    int32 i = gselect[ki];
    // Eq. (37): log p(x(t), m, i|j) += n_{jim} + n_{i}(t) (for all substates)
    post->Row(ki).AddVec(1.0, n_[j].Row(i));
    post->Row(ki).Add(per_frame_vars.nti(ki));
  }

  // Eq. (38): log p(x(t)|j) = log \\sum_{m, i} p(x(t), m, i|j)
  return post->ApplySoftMax();
}

struct SubstateCounter {
  SubstateCounter(int32 j, int32 num_substates, BaseFloat occ)
      : state_index(j), num_substates(num_substates), occupancy(occ) {}

  int32 state_index;
  int32 num_substates;
  BaseFloat occupancy;

  bool operator < (const SubstateCounter &r) const {
    return occupancy/num_substates < r.occupancy/r.num_substates;
  }
};

void AmSgmm::SplitSubstates(const Vector<BaseFloat> &state_occupancies,
                                   int32 target_nsubstates, BaseFloat perturb,
                                   BaseFloat power, BaseFloat max_cond) {
  // power == p in document.  target_nsubstates == T in document.
  KALDI_ASSERT(state_occupancies.Dim() == NumPdfs());
  int32 tot_n_substates_old = 0;
  int32 phn_dim = PhoneSpaceDim();
  std::priority_queue<SubstateCounter> substate_counts;
  vector< SpMatrix<BaseFloat> > H_i;
  SpMatrix<BaseFloat> sqrt_H_sm;
  Vector<BaseFloat> rand_vec(phn_dim), v_shift(phn_dim);

  for (int32 j = 0; j < NumPdfs(); j++) {
    BaseFloat gamma_p = pow(state_occupancies(j), power);
    substate_counts.push(SubstateCounter(j, NumSubstates(j), gamma_p));
    tot_n_substates_old += NumSubstates(j);
  }
  if (target_nsubstates <= tot_n_substates_old || tot_n_substates_old == 0) {
    KALDI_WARN << ""Cannot split from "" << (tot_n_substates_old) <<
        "" to "" << (target_nsubstates) << "" substates."";
    return;
  }

  ComputeH(&H_i);  // set up that array.
  ComputeSmoothingTermsFromModel(H_i, state_occupancies, &sqrt_H_sm, max_cond);
  H_i.clear();
  sqrt_H_sm.ApplyPow(-0.5);

  for (int32 n_states = tot_n_substates_old;
       n_states < target_nsubstates; n_states++) {
    SubstateCounter state_to_split = substate_counts.top();
    substate_counts.pop();
    state_to_split.num_substates++;
    substate_counts.push(state_to_split);
  }

  while (!substate_counts.empty()) {
    int32 j = substate_counts.top().state_index;
    int32 tgt_n_substates_j = substate_counts.top().num_substates;
    int32 n_substates_j     = NumSubstates(j);
    substate_counts.pop();

    if (n_substates_j == tgt_n_substates_j) continue;

    // Resize v[j] and c[j] to fit new substates
    Matrix<BaseFloat> tmp_v_j(v_[j]);
    v_[j].Resize(tgt_n_substates_j, phn_dim);
    v_[j].Range(0, n_substates_j, 0, phn_dim).CopyFromMat(tmp_v_j);
    tmp_v_j.Resize(0, 0);

    Vector<BaseFloat> tmp_c_j(c_[j]);
    c_[j].Resize(tgt_n_substates_j);
    c_[j].Range(0, n_substates_j).CopyFromVec(tmp_c_j);
    tmp_c_j.Resize(0);

    // Keep splitting substates until obtaining the desired number
    for (; n_substates_j < tgt_n_substates_j; n_substates_j++) {
      int32 split_substate = std::max_element(c_[j].Data(), c_[j].Data()
          + n_substates_j) - c_[j].Data();

      // c_{jkm} := c_{jmk}' := c_{jkm} / 2
      c_[j](split_substate) = c_[j](n_substates_j) = c_[j](split_substate) / 2;

      // v_{jkm} := +/- split_perturb * H_k^{(sm)}^{-0.5} * rand_vec
      std::generate(rand_vec.Data(), rand_vec.Data() + rand_vec.Dim(),
                    _RandGauss);
      v_shift.AddSpVec(perturb, sqrt_H_sm, rand_vec, 0.0);
      v_[j].Row(n_substates_j).CopyFromVec(v_[j].Row(split_substate));
      v_[j].Row(n_substates_j).AddVec(1.0, v_shift);
      v_[j].Row(split_substate).AddVec((-1.0), v_shift);
    }
  }
  KALDI_LOG << ""Getting rid of normalizers as they will no longer be valid"";

  n_.clear();
  KALDI_LOG << ""Split "" << (tot_n_substates_old) << "" substates to ""
      << (target_nsubstates);
}

void AmSgmm::IncreasePhoneSpaceDim(int32 target_dim,
                                   const Matrix<BaseFloat> &norm_xform) {
  KALDI_ASSERT(!M_.empty());
  int32 initial_dim = PhoneSpaceDim(),
      feat_dim = FeatureDim();
  KALDI_ASSERT(norm_xform.NumRows() == feat_dim);

  if (target_dim < initial_dim)
    KALDI_ERR << ""You asked to increase phn dim to a value lower than the ""
              << "" current dimension, "" << target_dim << "" < "" << initial_dim;

  if (target_dim > initial_dim + feat_dim) {
    KALDI_WARN << ""Cannot increase phone subspace dimensionality from ""
               << initial_dim << "" to "" << target_dim << "", increasing to ""
               << initial_dim + feat_dim;
    target_dim = initial_dim + feat_dim;
  }

  if (initial_dim < target_dim) {
    Matrix<BaseFloat> tmp_M(feat_dim, initial_dim);
    for (int32 i = 0; i < NumGauss(); i++) {
      tmp_M.CopyFromMat(M_[i]);
      M_[i].Resize(feat_dim, target_dim);
      M_[i].Range(0, feat_dim, 0, tmp_M.NumCols()).CopyFromMat(tmp_M);
      M_[i].Range(0, feat_dim, tmp_M.NumCols(),
          target_dim - tmp_M.NumCols()).CopyFromMat(norm_xform.Range(0,
              feat_dim, 0, target_dim-tmp_M.NumCols()));
    }
    Matrix<BaseFloat> tmp_w = w_;
    w_.Resize(tmp_w.NumRows(), target_dim);
    w_.Range(0, tmp_w.NumRows(), 0, tmp_w.NumCols()).CopyFromMat(tmp_w);

    for (int32 j = 0; j < NumPdfs(); j++) {
      // Resize v[j]
      Matrix<BaseFloat> tmp_v_j = v_[j];
      v_[j].Resize(tmp_v_j.NumRows(), target_dim);
      v_[j].Range(0, tmp_v_j.NumRows(), 0, tmp_v_j.NumCols()).CopyFromMat(
          tmp_v_j);
    }
    KALDI_LOG << ""Phone subspace dimensionality increased from "" <<
        initial_dim << "" to "" << target_dim;
  } else {
    KALDI_LOG << ""Phone subspace dimensionality unchanged, since target "" <<
        ""dimension ("" << target_dim << "") <= initial dimansion ("" <<
        initial_dim << "")"";
  }
}

void AmSgmm::IncreaseSpkSpaceDim(int32 target_dim,
                                 const Matrix<BaseFloat> &norm_xform) {
  int32 initial_dim = SpkSpaceDim(),
      feat_dim = FeatureDim();
  KALDI_ASSERT(norm_xform.NumRows() == feat_dim);

  if (N_.size() == 0)
    N_.resize(NumGauss());

  if (target_dim < initial_dim)
    KALDI_ERR << ""You asked to increase spk dim to a value lower than the ""
              << "" current dimension, "" << target_dim << "" < "" << initial_dim;

  if (target_dim > initial_dim + feat_dim) {
    KALDI_WARN << ""Cannot increase speaker subspace dimensionality from ""
               << initial_dim << "" to "" << target_dim << "", increasing to ""
               << initial_dim + feat_dim;
    target_dim = initial_dim + feat_dim;
  }

  if (initial_dim < target_dim) {
    int32 dim_change = target_dim - initial_dim;
    Matrix<BaseFloat> tmp_N((initial_dim != 0) ? feat_dim : 0,
                            initial_dim);
    for (int32 i = 0; i < NumGauss(); i++) {
      if (initial_dim != 0) tmp_N.CopyFromMat(N_[i]);
      N_[i].Resize(feat_dim, target_dim);
      if (initial_dim != 0) {
        N_[i].Range(0, feat_dim, 0, tmp_N.NumCols()).CopyFromMat(tmp_N);
      }
      N_[i].Range(0, feat_dim, tmp_N.NumCols(), dim_change).CopyFromMat(
          norm_xform.Range(0, feat_dim, 0, dim_change));
    }
    KALDI_LOG << ""Speaker subspace dimensionality increased from "" <<
        initial_dim << "" to "" << target_dim;
  } else {
    KALDI_LOG << ""Speaker subspace dimensionality unchanged, since target "" <<
        ""dimension ("" << target_dim << "") <= initial dimansion ("" <<
        initial_dim << "")"";
  }
}

void AmSgmm::ComputeDerivedVars() {
  if (n_.empty()) {
    ComputeNormalizers();
  }
  if (diag_ubm_.NumGauss() != full_ubm_.NumGauss()
      || diag_ubm_.Dim() != full_ubm_.Dim()) {
    diag_ubm_.CopyFromFullGmm(full_ubm_);
  }
}

class ComputeNormalizersClass: public MultiThreadable { // For multi-threaded.
 public:
  ComputeNormalizersClass(AmSgmm *am_sgmm,
                          int32 *entropy_count_ptr,
                          double *entropy_sum_ptr):
      am_sgmm_(am_sgmm), entropy_count_ptr_(entropy_count_ptr),
      entropy_sum_ptr_(entropy_sum_ptr), entropy_count_(0),
      entropy_sum_(0.0) { }

  ~ComputeNormalizersClass() {
    *entropy_count_ptr_ += entropy_count_;
    *entropy_sum_ptr_ += entropy_sum_;
  }
  
  inline void operator() () {
    // Note: give them local copy of the sums we're computing,
    // which will be propagated to original pointer in the destructor.
    am_sgmm_->ComputeNormalizersInternal(num_threads_, thread_id_,
                                         &entropy_count_,
                                         &entropy_sum_);
  }
 private:
  ComputeNormalizersClass() { } // Disallow empty constructor.
  AmSgmm *am_sgmm_;
  int32 *entropy_count_ptr_;
  double *entropy_sum_ptr_;
  int32 entropy_count_;
  double entropy_sum_;

};

void AmSgmm::ComputeNormalizers() {
  KALDI_LOG << ""Computing normalizers"";
  n_.resize(NumPdfs());
  int32 entropy_count = 0;
  double entropy_sum = 0.0;
  ComputeNormalizersClass c(this, &entropy_count, &entropy_sum);
  RunMultiThreaded(c);

  KALDI_LOG << ""Entropy of weights in substates is ""
            << (entropy_sum / entropy_count) << "" over "" << entropy_count
            << "" substates, equivalent to perplexity of ""
            << (Exp(entropy_sum /entropy_count));
  KALDI_LOG << ""Done computing normalizers"";
}


void AmSgmm::ComputeNormalizersInternal(int32 num_threads, int32 thread,
                                        int32 *entropy_count,
                                        double *entropy_sum) {

  BaseFloat DLog2pi = FeatureDim() * Log(2 * M_PI);
  Vector<BaseFloat> log_det_Sigma(NumGauss());

  for (int32 i = 0; i < NumGauss(); i++) {
    try {
      log_det_Sigma(i) = - SigmaInv_[i].LogPosDefDet();
    } catch(...) {
      if (thread == 0) // just for one thread, print errors [else, duplicates]
        KALDI_WARN << ""Covariance is not positive definite, setting to unit"";
      SigmaInv_[i].SetUnit();
      log_det_Sigma(i) = 0.0;
    }
  }


  int block_size = (NumPdfs() + num_threads-1) / num_threads;
  int j_start = thread * block_size, j_end = std::min(NumPdfs(), j_start + block_size);
  
  for (int32 j = j_start; j < j_end; j++) {
    Matrix<BaseFloat> log_w_jm(NumSubstates(j), NumGauss());
    n_[j].Resize(NumGauss(), NumSubstates(j));
    Matrix<BaseFloat> mu_jmi(NumSubstates(j), FeatureDim());
    Matrix<BaseFloat> SigmaInv_mu(NumSubstates(j), FeatureDim());
        
    // (in logs): w_jm = softmax([w_{k1}^T ... w_{kD}^T] * v_{jkm}) eq.(7)
    log_w_jm.AddMatMat(1.0, v_[j], kNoTrans, w_, kTrans, 0.0);
    for (int32 m = 0; m < NumSubstates(j); m++) {
      log_w_jm.Row(m).Add(-1.0 * log_w_jm.Row(m).LogSumExp());    
      {  // DIAGNOSTIC CODE
        (*entropy_count)++;
        for (int32 i = 0; i < NumGauss(); i++) {
          (*entropy_sum) -= log_w_jm(m, i) * Exp(log_w_jm(m, i));
        }
      }
    }      
    
    for (int32 i = 0; i < NumGauss(); i++) {    
      // mu_jmi = M_{i} * v_{jm}
      mu_jmi.AddMatMat(1.0, v_[j], kNoTrans, M_[i], kTrans, 0.0);
      SigmaInv_mu.AddMatSp(1.0, mu_jmi, kNoTrans, SigmaInv_[i], 0.0);
    
      for (int32 m = 0; m < NumSubstates(j); m++) {
        // mu_{jmi} * \\Sigma_{i}^{-1} * mu_{jmi}
        BaseFloat mu_SigmaInv_mu = VecVec(mu_jmi.Row(m), SigmaInv_mu.Row(m));
        BaseFloat logc = Log(c_[j](m));

        // Suggestion: Both mu_jmi and SigmaInv_mu could
        // have been computed at once for i,
        // if M[i] was concatenated to single matrix over i indices
        
        // eq.(31)
        n_[j](i, m) = logc + log_w_jm(m, i) - 0.5 * (log_det_Sigma(i) + DLog2pi
            + mu_SigmaInv_mu);
        {  // Mainly diagnostic code.  Not necessary.
          BaseFloat tmp = n_[j](i, m);
          if (!KALDI_ISFINITE(tmp)) {  // NaN or inf
            KALDI_LOG << ""Warning: normalizer for j = "" << j << "", m = "" << m
                      << "", i = "" << i << "" is infinite or NaN "" << tmp << ""= ""
                      << (logc) << ""+"" << (log_w_jm(m, i)) << ""+"" << (-0.5 *
                          log_det_Sigma(i)) << ""+"" << (-0.5 * DLog2pi)
                      << ""+"" << (mu_SigmaInv_mu) << "", setting to finite."";
            n_[j](i, m) = -1.0e+40;  // future work(arnab): get rid of magic number
          }
        }
      }
    }
  }
}


void AmSgmm::ComputeNormalizersNormalized(
    const std::vector< std::vector<int32> > &normalize_sets) {
  { // Check sets in normalize_sets are disjoint and cover all Gaussians.
    std::set<int32> all;
    for (int32 i = 0; i < normalize_sets.size(); i++)
      for (int32 j = 0; static_cast<size_t>(j) < normalize_sets[i].size(); j++) {
        int32 n = normalize_sets[i][j];
        KALDI_ASSERT(all.count(n) == 0 && n >= 0 && n < NumGauss());
        all.insert(n);
      }
    KALDI_ASSERT(all.size() == NumGauss());
  }

  KALDI_LOG << ""Computing normalizers [normalized]"";
  BaseFloat DLog2pi = FeatureDim() * Log(2 * M_PI);
  Vector<BaseFloat> mu_jmi(FeatureDim());
  Vector<BaseFloat> SigmaInv_mu(FeatureDim());
  Vector<BaseFloat> log_det_Sigma(NumGauss());

  for (int32 i = 0; i < NumGauss(); i++) {
    try {
      log_det_Sigma(i) = - SigmaInv_[i].LogPosDefDet();
    } catch(...) {
      KALDI_WARN << ""Covariance is not positive definite, setting to unit"";
      SigmaInv_[i].SetUnit();
      log_det_Sigma(i) = 0.0;
    }
  }

  n_.resize(NumPdfs());
  for (int32 j = 0; j < NumPdfs(); j++) {
    Vector<BaseFloat> log_w_jm(NumGauss());

    n_[j].Resize(NumGauss(), NumSubstates(j));
    for (int32 m = 0; m < NumSubstates(j); m++) {
      BaseFloat logc = Log(c_[j](m));

      // (in logs): w_jm = softmax([w_{k1}^T ... w_{kD}^T] * v_{jkm}) eq.(7)
      log_w_jm.AddMatVec(1.0, w_, kNoTrans, v_[j].Row(m), 0.0);
      log_w_jm.Add((-1.0) * log_w_jm.LogSumExp());

      for (int32 n = 0; n < normalize_sets.size(); n++) {
        const std::vector<int32> &this_set(normalize_sets[n]);
        double sum = 0.0;
        for (int32 p = 0; p < this_set.size(); p++)
          sum += Exp(log_w_jm(this_set[p]));
        double offset = -Log(sum);  // add ""offset"", to normalize weights.
        for (int32 p = 0; p < this_set.size(); p++)
          log_w_jm(this_set[p]) += offset;
      }

      for (int32 i = 0; i < NumGauss(); i++) {
        // mu_jmi = M_{i} * v_{jm}
        mu_jmi.AddMatVec(1.0, M_[i], kNoTrans, v_[j].Row(m), 0.0);

        // mu_{jmi} * \\Sigma_{i}^{-1} * mu_{jmi}
        SigmaInv_mu.AddSpVec(1.0, SigmaInv_[i], mu_jmi, 0.0);
        BaseFloat mu_SigmaInv_mu = VecVec(mu_jmi, SigmaInv_mu);

        // Suggestion: Both mu_jmi and SigmaInv_mu could
        // have been computed at once  for i ,
        // if M[i] was concatenated to single matrix over i indeces

        // eq.(31)
        n_[j](i, m) = logc + log_w_jm(i) - 0.5 * (log_det_Sigma(i) + DLog2pi
            + mu_SigmaInv_mu);
        {  // Mainly diagnostic code.  Not necessary.
          BaseFloat tmp = n_[j](i, m);
          if (!KALDI_ISFINITE(tmp)) {  // NaN or inf
            KALDI_LOG << ""Warning: normalizer for j = "" << j << "", m = "" << m
                      << "", i = "" << i << "" is infinite or NaN "" << tmp << ""= ""
                      << (logc) << ""+"" << (log_w_jm(i)) << ""+"" << (-0.5 *
                          log_det_Sigma(i)) << ""+"" << (-0.5 * DLog2pi)
                      << ""+"" << (mu_SigmaInv_mu) << "", setting to finite."";
            n_[j](i, m) = -1.0e+40;  // future work(arnab): get rid of magic number
          }
        }
      }
    }
  }

  KALDI_LOG << ""Done computing normalizers (normalized over subsets)"";
}


void AmSgmm::ComputeFmllrPreXform(const Vector<BaseFloat> &state_occs,
    Matrix<BaseFloat> *xform, Matrix<BaseFloat> *inv_xform,
    Vector<BaseFloat> *diag_mean_scatter) const {
  int32 num_states = NumPdfs(),
      num_gauss = NumGauss(),
      dim = FeatureDim();
  KALDI_ASSERT(state_occs.Dim() == num_states);

  BaseFloat total_occ = state_occs.Sum();

  // Degenerate case: unlikely to ever happen.
  if (total_occ == 0) {
    KALDI_WARN << ""Zero probability (computing transform). Using unit ""
               << ""pre-transform"";
    xform->Resize(dim, dim + 1, kUndefined);
    xform->SetUnit();
    inv_xform->Resize(dim, dim + 1, kUndefined);
    inv_xform->SetUnit();
    diag_mean_scatter->Resize(dim, kSetZero);
    return;
  }

  // Convert state occupancies to posteriors; Eq. (B.1)
  Vector<BaseFloat> state_posteriors(state_occs);
  state_posteriors.Scale(1/total_occ);

  Vector<BaseFloat> mu_jmi(dim), global_mean(dim);
  SpMatrix<BaseFloat> within_class_covar(dim), between_class_covar(dim);
  Vector<BaseFloat> gauss_weight(num_gauss);  // weights for within-class vars.
  Vector<BaseFloat> w_jm(num_gauss);
  BaseFloat substate_weight;
  for (int32 j = 0; j < num_states; j++) {
    for (int32 m = 0; m < NumSubstates(j); m++) {
      // Eq. (7): w_jm = softmax([w_{1}^T ... w_{D}^T] * v_{jm})
      w_jm.AddMatVec(1.0, w_, kNoTrans, v_[j].Row(m), 0.0);
      w_jm.ApplySoftMax();

      for (int32 i = 0; i < num_gauss; i++) {
        substate_weight = state_posteriors(j) * c_[j](m) * w_jm(i);
        mu_jmi.AddMatVec(1.0, M_[i], kNoTrans, v_[j].Row(m), 0.0);  // Eq. (6)
        // Eq. (B.3): \\mu_avg = \\sum_{jmi} p(j) c_{jm} w_{jmi} \\mu_{jmi}
        global_mean.AddVec(substate_weight, mu_jmi);
        // \\Sigma_B = \\sum_{jmi} p(j) c_{jm} w_{jmi} \\mu_{jmi} \\mu_{jmi}^T
        between_class_covar.AddVec2(substate_weight, mu_jmi);  // Eq. (B.4)
        gauss_weight(i) += substate_weight;
      }
    }
  }
  between_class_covar.AddVec2(-1.0, global_mean);  // Eq. (B.4)

  for (int32 i = 0; i < num_gauss; i++) {
    SpMatrix<BaseFloat> Sigma(SigmaInv_[i]);
    Sigma.InvertDouble();
    // Eq. (B.2): \\Sigma_W = \\sum_{jmi} p(j) c_{jm} w_{jmi} \\Sigma_i
    within_class_covar.AddSp(gauss_weight(i), Sigma);
  }

  TpMatrix<BaseFloat> tmpL(dim);
  Matrix<BaseFloat> tmpLInvFull(dim, dim);
  tmpL.Cholesky(within_class_covar);  // \\Sigma_W = L L^T
  tmpL.InvertDouble();  // L^{-1}
  tmpLInvFull.CopyFromTp(tmpL);  // get as full matrix.

  // B := L^{-1} * \\Sigma_B * L^{-T}
  SpMatrix<BaseFloat> tmpB(dim);
  tmpB.AddMat2Sp(1.0, tmpLInvFull, kNoTrans, between_class_covar, 0.0);

  Matrix<BaseFloat> U(dim, dim);
  diag_mean_scatter->Resize(dim);
  xform->Resize(dim, dim + 1);
  inv_xform->Resize(dim, dim + 1);

  tmpB.Eig(diag_mean_scatter, &U);  // Eq. (B.5): B = U D V^T
  int32 n;
  if ((n = diag_mean_scatter->ApplyFloor(1.0e-04)) != 0)
    KALDI_WARN << ""Floored "" << n << "" elements of the mean-scatter matrix."";
  
  // Eq. (B.6): A_{pre} = U^T * L^{-1}
  SubMatrix<BaseFloat> Apre(*xform, 0, dim, 0, dim);
  Apre.AddMatMat(1.0, U, kTrans, tmpLInvFull, kNoTrans, 0.0);

#ifdef KALDI_PARANOID
  {
    SpMatrix<BaseFloat> tmp(dim);
    tmp.AddMat2Sp(1.0, Apre, kNoTrans, within_class_covar, 0.0);
    KALDI_ASSERT(tmp.IsUnit(0.01));
  }
  {
    SpMatrix<BaseFloat> tmp(dim);
    tmp.AddMat2Sp(1.0, Apre, kNoTrans, between_class_covar, 0.0);
    KALDI_ASSERT(tmp.IsDiagonal(0.01));
  }
#endif

  // Eq. (B.7): b_{pre} = - A_{pre} \\mu_{avg}
  Vector<BaseFloat> b_pre(dim);
  b_pre.AddMatVec(-1.0, Apre, kNoTrans, global_mean, 0.0);
  for (int32 r = 0; r < dim; r++) {
    xform->Row(r)(dim) = b_pre(r);  // W_{pre} = [ A_{pre}, b_{pre} ]
  }

  // Eq. (B.8) & (B.9): W_{inv} = [ A_{pre}^{-1}, \\mu_{avg} ]
  inv_xform->CopyFromMat(*xform);
  inv_xform->Range(0, dim, 0, dim).InvertDouble();
  for (int32 r = 0; r < dim; r++)
    inv_xform->Row(r)(dim) = global_mean(r);
}  // End of ComputePreXform()

template<typename Real>
void AmSgmm::GetNtransSigmaInv(vector< Matrix<Real> > *out) const {
  KALDI_ASSERT(SpkSpaceDim() > 0 &&
      ""Cannot compute N^{T} \\\\Sigma_{i}^{-1} without speaker projections."");
  out->resize(NumGauss());
  Matrix<Real> tmpcov(FeatureDim(), FeatureDim());
  Matrix<Real> tmp_n(FeatureDim(), SpkSpaceDim());
  for (int32 i = 0; i < NumGauss(); i++) {
    tmpcov.CopyFromSp(SigmaInv_[i]);
    tmp_n.CopyFromMat(N_[i]);
    (*out)[i].Resize(SpkSpaceDim(), FeatureDim());
    (*out)[i].AddMatMat(1.0, tmp_n, kTrans, tmpcov, kNoTrans, 0.0);
  }
}

// Instantiate the above template.
template
void AmSgmm::GetNtransSigmaInv(vector< Matrix<float> > *out) const;
template
void AmSgmm::GetNtransSigmaInv(vector< Matrix<double> > *out) const;

///////////////////////////////////////////////////////////////////////////////

template<class Real>
void AmSgmm::ComputeH(std::vector< SpMatrix<Real> > *H_i) const {
  KALDI_ASSERT(NumGauss() != 0);
  (*H_i).resize(NumGauss());
  SpMatrix<BaseFloat> H_i_tmp(PhoneSpaceDim());
  for (int32 i = 0; i < NumGauss(); i++) {
    (*H_i)[i].Resize(PhoneSpaceDim());
    H_i_tmp.AddMat2Sp(1.0, M_[i], kTrans, SigmaInv_[i], 0.0);
    (*H_i)[i].CopyFromSp(H_i_tmp);
  }
}

// Instantiate the template.
template
void AmSgmm::ComputeH(std::vector< SpMatrix<float> > *H_i) const;
template
void AmSgmm::ComputeH(std::vector< SpMatrix<double> > *H_i) const;


// Initializes the matrices M_{i} and w_i
void AmSgmm::InitializeMw(int32 phn_subspace_dim,
                          const Matrix<BaseFloat> &norm_xform) {
  int32 ddim = full_ubm_.Dim();
  KALDI_ASSERT(phn_subspace_dim <= ddim + 1);
  KALDI_ASSERT(phn_subspace_dim <= norm_xform.NumCols() + 1);
  KALDI_ASSERT(ddim <= norm_xform.NumRows());

  Vector<BaseFloat> mean(ddim);
  int32 num_gauss = full_ubm_.NumGauss();
  w_.Resize(num_gauss, phn_subspace_dim);
  M_.resize(num_gauss);
  for (int32 i = 0; i < num_gauss; i++) {
    full_ubm_.GetComponentMean(i, &mean);
    Matrix<BaseFloat> &thisM(M_[i]);
    thisM.Resize(ddim, phn_subspace_dim);
    // Eq. (27): M_{i} = [ \\bar{\\mu}_{i} (J)_{1:D, 1:(S-1)}]
    thisM.CopyColFromVec(mean, 0);
    thisM.Range(0, ddim, 1, phn_subspace_dim-1).CopyFromMat(
        norm_xform.Range(0, ddim, 0, phn_subspace_dim-1), kNoTrans);
  }
}

// Initializes the matrices N_{i}
void AmSgmm::InitializeN(int32 spk_subspace_dim,
                         const Matrix<BaseFloat> &norm_xform) {
  int32 ddim = full_ubm_.Dim();
  KALDI_ASSERT(spk_subspace_dim <= ddim);
  KALDI_ASSERT(spk_subspace_dim <= norm_xform.NumCols());
  KALDI_ASSERT(ddim <= norm_xform.NumRows());

  int32 num_gauss = full_ubm_.NumGauss();
  N_.resize(num_gauss);
  for (int32 i = 0; i < num_gauss; i++) {
    N_[i].Resize(ddim, spk_subspace_dim);
    // Eq. (28): N_{i} = [ (J)_{1:D, 1:T)}]
    N_[i].CopyFromMat(norm_xform.Range(0, ddim, 0, spk_subspace_dim), kNoTrans);
  }
}

// Initializes the vectors v_{jm}
void AmSgmm::InitializeVecs(int32 num_states) {
  KALDI_ASSERT(num_states >= 0);
  int32 phn_subspace_dim = PhoneSpaceDim();
  KALDI_ASSERT(phn_subspace_dim > 0 && ""Initialize M and w first."");

  v_.resize(num_states);
  c_.resize(num_states);
  for (int32 j = 0; j < num_states; j++) {
    v_[j].Resize(1, phn_subspace_dim);
    c_[j].Resize(1);
    v_[j](0, 0) = 1.0;  // Eq. (26): v_{j1} = [1 0 0 ... 0]
    c_[j](0) = 1.0;     // Eq. (25): c_{j1} = 1.0
  }
}

// Initializes the within-class vars Sigma_{ki}
void AmSgmm::InitializeCovars() {
  std::vector< SpMatrix<BaseFloat> > &inv_covars(full_ubm_.inv_covars());
  int32 num_gauss = full_ubm_.NumGauss();
  int32 dim = full_ubm_.Dim();
  SigmaInv_.resize(num_gauss);
  for (int32 i = 0; i < num_gauss; i++) {
    SigmaInv_[i].Resize(dim);
    SigmaInv_[i].CopyFromSp(inv_covars[i]);
  }
}

// Compute the ""smoothing"" matrices from expected counts given the model.
void AmSgmm::ComputeSmoothingTermsFromModel(
    const std::vector< SpMatrix<BaseFloat> > &H,
    const Vector<BaseFloat> &state_occupancies, SpMatrix<BaseFloat> *H_sm,
    BaseFloat max_cond) const {
  int32 num_gauss = NumGauss();
  BaseFloat tot_sum = 0.0;
  KALDI_ASSERT(state_occupancies.Dim() == NumPdfs());
  Vector<BaseFloat> w_jm(num_gauss);
  H_sm->Resize(PhoneSpaceDim());
  H_sm->SetZero();
  Vector<BaseFloat> gamma_i(num_gauss);
  gamma_i.SetZero();
  for (int32 j = 0; j < NumPdfs(); j++) {
    int32 M_j = NumSubstates(j);
    KALDI_ASSERT(M_j > 0);
    for (int32 m = 0; m < M_j; m++) {
      w_jm.AddMatVec(1.0, w_, kNoTrans, v_[j].Row(m), 0.0);
      w_jm.ApplySoftMax();
      gamma_i.AddVec(state_occupancies(j) * c_[j](m), w_jm);
    }
  }
  BaseFloat sum = 0.0;
  for (int32 i = 0; i < num_gauss; i++) {
    if (gamma_i(i) > 0) {
      H_sm->AddSp(gamma_i(i), H[i]);
      sum += gamma_i(i);
    }
  }
  if (sum == 0.0) {
    KALDI_WARN << ""Sum of counts is zero. "";
    // set to unit matrix--arbitrary non-singular matrix.. won't ever matter.
    H_sm->SetUnit();
  } else {
    H_sm->Scale(1.0 / sum);
    int32 tmp = H_sm->LimitCondDouble(max_cond);
    if (tmp > 0) {
      KALDI_WARN << ""Limited "" << (tmp) << "" eigenvalues of H_sm"";
    }
  }
  tot_sum += sum;

  KALDI_LOG << ""ComputeSmoothingTermsFromModel: total count is "" << tot_sum;
}

void ComputeFeatureNormalizer(const FullGmm &gmm, Matrix<BaseFloat> *xform) {
  int32 dim = gmm.Dim();
  int32 num_gauss = gmm.NumGauss();
  SpMatrix<BaseFloat> within_class_covar(dim);
  SpMatrix<BaseFloat> between_class_covar(dim);
  Vector<BaseFloat> global_mean(dim);

  // Accumulate LDA statistics from the GMM parameters.
  {
    BaseFloat total_weight = 0.0;
    Vector<BaseFloat> tmp_weight(num_gauss);
    Matrix<BaseFloat> tmp_means;
    std::vector< SpMatrix<BaseFloat> > tmp_covars;
    tmp_weight.CopyFromVec(gmm.weights());
    gmm.GetCovarsAndMeans(&tmp_covars, &tmp_means);
    for (int32 i = 0; i < num_gauss; i++) {
      BaseFloat w_i = tmp_weight(i);
      total_weight += w_i;
      within_class_covar.AddSp(w_i, tmp_covars[i]);
      between_class_covar.AddVec2(w_i, tmp_means.Row(i));
      global_mean.AddVec(w_i, tmp_means.Row(i));
    }
    KALDI_ASSERT(total_weight > 0);
    if (fabs(total_weight - 1.0) > 0.001) {
      KALDI_WARN << ""Total weight across the GMMs is "" << (total_weight)
          << "", renormalizing."";
      global_mean.Scale(1.0 / total_weight);
      within_class_covar.Scale(1.0 / total_weight);
      between_class_covar.Scale(1.0 / total_weight);
    }
    between_class_covar.AddVec2(-1.0, global_mean);
  }

  TpMatrix<BaseFloat> chol(dim);
  chol.Cholesky(within_class_covar);  // Sigma_W = L L^T
  TpMatrix<BaseFloat> chol_inv(chol);
  chol_inv.InvertDouble();
  Matrix<BaseFloat> chol_full(dim, dim);
  chol_full.CopyFromTp(chol_inv);
  SpMatrix<BaseFloat> LBL(dim);
  // LBL = L^{-1} \\Sigma_B L^{-T}
  LBL.AddMat2Sp(1.0, chol_full, kNoTrans, between_class_covar, 0.0);
  Vector<BaseFloat> Dvec(dim);
  Matrix<BaseFloat> U(dim, dim);
  LBL.Eig(&Dvec, &U);
  SortSvd(&Dvec, &U);

  xform->Resize(dim, dim);
  chol_full.CopyFromTp(chol);
  // T := L U, eq (23)
  xform->AddMatMat(1.0, chol_full, kNoTrans, U, kNoTrans, 0.0);

#ifdef KALDI_PARANOID
  Matrix<BaseFloat> inv_xform(*xform);
  inv_xform.InvertDouble();
  {  // Check that T*within_class_covar*T' = I.
    Matrix<BaseFloat> wc_covar_full(dim, dim), tmp(dim, dim);
    wc_covar_full.CopyFromSp(within_class_covar);
    tmp.AddMatMat(1.0, inv_xform, kNoTrans, wc_covar_full, kNoTrans, 0.0);
    wc_covar_full.AddMatMat(1.0, tmp, kNoTrans, inv_xform, kTrans, 0.0);
    KALDI_ASSERT(wc_covar_full.IsUnit(0.01));
  }
  {  // Check that T*between_class_covar*T' = diagonal.
    Matrix<BaseFloat> bc_covar_full(dim, dim), tmp(dim, dim);
    bc_covar_full.CopyFromSp(between_class_covar);
    tmp.AddMatMat(1.0, inv_xform, kNoTrans, bc_covar_full, kNoTrans, 0.0);
    bc_covar_full.AddMatMat(1.0, tmp, kNoTrans, inv_xform, kTrans, 0.0);
    KALDI_ASSERT(bc_covar_full.IsDiagonal(0.01));
  }
#endif
}

void AmSgmm::ComputePerSpkDerivedVars(SgmmPerSpkDerivedVars *vars) const {
  KALDI_ASSERT(vars != NULL);
  if (vars->v_s.Dim() != 0) {
    KALDI_ASSERT(vars->v_s.Dim() == SpkSpaceDim());
    vars->o_s.Resize(NumGauss(), FeatureDim());
    int32 num_gauss = NumGauss();
    for (int32 i = 0; i < num_gauss; i++) {
      // Eqn. (32): o_i^{(s)} = N_i v^{(s)}
      vars->o_s.Row(i).AddMatVec(1.0, N_[i], kNoTrans, vars->v_s, 0.0);
    }
  } else {
    vars->o_s.Resize(0, 0);
  }
}

BaseFloat AmSgmm::GaussianSelection(const SgmmGselectConfig &config,
                                    const VectorBase<BaseFloat> &data,
                                    std::vector<int32> *gselect) const {
  KALDI_ASSERT(diag_ubm_.NumGauss() != 0 &&
               diag_ubm_.NumGauss() == full_ubm_.NumGauss() &&
               diag_ubm_.Dim() == data.Dim());
  KALDI_ASSERT(config.diag_gmm_nbest > 0 && config.full_gmm_nbest > 0 &&
               config.full_gmm_nbest < config.diag_gmm_nbest);
  int32 num_gauss = diag_ubm_.NumGauss();

  std::vector< std::pair<BaseFloat, int32> > pruned_pairs;
  if (config.diag_gmm_nbest < num_gauss) {
    Vector<BaseFloat> loglikes(num_gauss);
    diag_ubm_.LogLikelihoods(data, &loglikes);
    Vector<BaseFloat> loglikes_copy(loglikes);
    BaseFloat *ptr = loglikes_copy.Data();
    std::nth_element(ptr, ptr+num_gauss-config.diag_gmm_nbest, ptr+num_gauss);
    BaseFloat thresh = ptr[num_gauss-config.diag_gmm_nbest];
    for (int32 g = 0; g < num_gauss; g++)
      if (loglikes(g) >= thresh)  // met threshold for diagonal phase.
        pruned_pairs.push_back(
            std::make_pair(full_ubm_.ComponentLogLikelihood(data, g), g));
  } else {
    Vector<BaseFloat> loglikes(num_gauss);
    full_ubm_.LogLikelihoods(data, &loglikes);
    for (int32 g = 0; g < num_gauss; g++)
      pruned_pairs.push_back(std::make_pair(loglikes(g), g));
  }
  KALDI_ASSERT(!pruned_pairs.empty());
  if (pruned_pairs.size() > static_cast<size_t>(config.full_gmm_nbest)) {
    std::nth_element(pruned_pairs.begin(),
                     pruned_pairs.end() - config.full_gmm_nbest,
                     pruned_pairs.end());
    pruned_pairs.erase(pruned_pairs.begin(),
                       pruned_pairs.end() - config.full_gmm_nbest);
  }
  Vector<BaseFloat> loglikes_tmp(pruned_pairs.size());  // for return value.
  KALDI_ASSERT(gselect != NULL);
  gselect->resize(pruned_pairs.size());
  // Make sure pruned Gaussians appear from best to worst.
  std::sort(pruned_pairs.begin(), pruned_pairs.end(),
            std::greater< std::pair<BaseFloat, int32> >());
  for (size_t i = 0; i < pruned_pairs.size(); i++) {
    loglikes_tmp(i) = pruned_pairs[i].first;
    (*gselect)[i] = pruned_pairs[i].second;
  }
  return loglikes_tmp.LogSumExp();
}

BaseFloat AmSgmm::GaussianSelectionPreselect(const SgmmGselectConfig &config,
                                             const VectorBase<BaseFloat> &data,
                                             const std::vector<int32> &preselect,
                                             std::vector<int32> *gselect) const {
  KALDI_ASSERT(IsSortedAndUniq(preselect) && !preselect.empty());
  KALDI_ASSERT(diag_ubm_.NumGauss() != 0 &&
               diag_ubm_.NumGauss() == full_ubm_.NumGauss() &&
               diag_ubm_.Dim() == data.Dim());

  int32 num_preselect = preselect.size();

  KALDI_ASSERT(config.diag_gmm_nbest > 0 && config.full_gmm_nbest > 0 &&
               config.full_gmm_nbest < num_preselect);

  std::vector<std::pair<BaseFloat, int32> > pruned_pairs;
  if (config.diag_gmm_nbest < num_preselect) {
    Vector<BaseFloat> loglikes(num_preselect);
    diag_ubm_.LogLikelihoodsPreselect(data, preselect, &loglikes);
    Vector<BaseFloat> loglikes_copy(loglikes);
    BaseFloat *ptr = loglikes_copy.Data();
    std::nth_element(ptr, ptr+num_preselect-config.diag_gmm_nbest,
                     ptr+num_preselect);
    BaseFloat thresh = ptr[num_preselect-config.diag_gmm_nbest];
    for (int32 p = 0; p < num_preselect; p++) {
      if (loglikes(p) >= thresh) {  // met threshold for diagonal phase.
        int32 g = preselect[p];
        pruned_pairs.push_back(
            std::make_pair(full_ubm_.ComponentLogLikelihood(data, g), g));
      }
    }
  } else {
    for (int32 p = 0; p < num_preselect; p++) {
      int32 g = preselect[p];
      pruned_pairs.push_back(
          std::make_pair(full_ubm_.ComponentLogLikelihood(data, g), g));
    }
  }
  KALDI_ASSERT(!pruned_pairs.empty());
  if (pruned_pairs.size() > static_cast<size_t>(config.full_gmm_nbest)) {
    std::nth_element(pruned_pairs.begin(),
                     pruned_pairs.end() - config.full_gmm_nbest,
                     pruned_pairs.end());
    pruned_pairs.erase(pruned_pairs.begin(),
                       pruned_pairs.end() - config.full_gmm_nbest);
  }
  // Make sure pruned Gaussians appear from best to worst.
  std::sort(pruned_pairs.begin(), pruned_pairs.end(),
            std::greater<std::pair<BaseFloat, int32> >());
  Vector<BaseFloat> loglikes_tmp(pruned_pairs.size());  // for return value.
  KALDI_ASSERT(gselect != NULL);
  gselect->resize(pruned_pairs.size());
  for (size_t i = 0; i < pruned_pairs.size(); i++) {
    loglikes_tmp(i) = pruned_pairs[i].first;
    (*gselect)[i] = pruned_pairs[i].second;
  }
  return loglikes_tmp.LogSumExp();
}



void SgmmGauPost::Write(std::ostream &os, bool binary) const {
  WriteToken(os, binary, ""<SgmmGauPost>"");
  int32 T = this->size();
  WriteBasicType(os, binary, T);
  for (int32 t = 0; t < T; t++) {
    WriteToken(os, binary, ""<gselect>"");
    WriteIntegerVector(os, binary, (*this)[t].gselect);
    WriteToken(os, binary, ""<tids>"");
    WriteIntegerVector(os, binary, (*this)[t].tids);
    KALDI_ASSERT((*this)[t].tids.size() == (*this)[t].posteriors.size());
    for (size_t i = 0; i < (*this)[t].posteriors.size(); i++) {
      (*this)[t].posteriors[i].Write(os, binary);
    }
  }
  WriteToken(os, binary, ""</SgmmGauPost>"");
}

void SgmmGauPost::Read(std::istream &is, bool binary) {
  ExpectToken(is, binary, ""<SgmmGauPost>"");
  int32 T;
  ReadBasicType(is, binary, &T);
  KALDI_ASSERT(T >= 0);
  this->resize(T);
  for (int32 t = 0; t < T; t++) {
    ExpectToken(is, binary, ""<gselect>"");
    ReadIntegerVector(is, binary, &((*this)[t].gselect));
    ExpectToken(is, binary, ""<tids>"");
    ReadIntegerVector(is, binary, &((*this)[t].tids));
    size_t sz = (*this)[t].tids.size();
    (*this)[t].posteriors.resize(sz);
    for (size_t i = 0; i < sz; i++)
      (*this)[t].posteriors[i].Read(is, binary);
  }
  ExpectToken(is, binary, ""</SgmmGauPost>"");
}


void AmSgmmFunctions::ComputeDistances(const AmSgmm &model,
                                       const Vector<BaseFloat> &state_occs,
                                       MatrixBase<BaseFloat> *dists) {
  int32 num_states = model.NumPdfs(),
      phn_space_dim = model.PhoneSpaceDim(),
      num_gauss = model.NumGauss();
  KALDI_ASSERT(dists != NULL && dists->NumRows() == num_states
               && dists->NumCols() == num_states);
  Vector<double> prior(state_occs);
  KALDI_ASSERT(prior.Sum() != 0.0);
  prior.Scale(1.0 / prior.Sum());  // Normalize.
  SpMatrix<BaseFloat> H(phn_space_dim);  // The same as H_sm in some other code.
  for (int32 i = 0; i < num_gauss; i++) {
    SpMatrix<BaseFloat> Hi(phn_space_dim);
    Hi.AddMat2Sp(1.0, model.M_[i], kTrans, model.SigmaInv_[i], 0.0);
    H.AddSp(prior(i), Hi);
  }
  bool warned = false;
  for (int32 j1 = 0; j1 < num_states; ++j1) {
    if (model.NumSubstates(j1) != 1 && !warned) {
      KALDI_WARN << ""ComputeDistances() can only give meaningful output if you ""
                 << ""have one substate per state."";
      warned = true;
    }
    for (int32 j2 = 0; j2 <= j1; ++j2) {
      Vector<BaseFloat> v_diff(model.v_[j1].Row(0));
      v_diff.AddVec(-1.0, model.v_[j2].Row(0));
      (*dists)(j1, j2) = (*dists)(j2, j1) = VecSpVec(v_diff, H, v_diff);
    }
  }
}

}  // namespace kaldi
",16190,True,2700.1450615398076,median
"#include ""stdhdr.h""
#include ""aircrft.h""
#include ""fack.h""
#include ""airframe.h""
#include ""soundfx.h""
#include ""fsound.h""
#include ""fcc.h""
#include ""radar.h""
#include ""falcmesg.h""
#include ""simdrive.h""
#include ""flightData.h""
#include ""otwdrive.h""
#include ""cpmanager.h""
#include ""sms.h""
#include ""playerop.h""
#include ""limiters.h""
#include ""IvibeData.h""
#include ""falcsess.h""

// MD -- 20031011: added to make the RWR related SetLightBits2() calls work
#include ""PlayerRWR.h""

// MD -- 20031207: adding for TFR STBY lamp check
#include ""lantirn.h""

/* not GetFault(obs_wrn) and //never get's set currently*/

//extern bool g_bEnableAircraftLimits; //me123 MI replaced with g_bRealisticAvionics
extern bool g_bRealisticAvionics;

//MI
bool Warned = FALSE;
//extern bool g_bEnableCATIIIExtension; //MI replaced with g_bRealisticAvionics
void AircraftClass::CautionCheck(void)
{
    if ( not isDigital)
    {
        // Check fuel
        if (af->Fuel() + af->ExternalFuel() < bingoFuel and not mFaults->GetFault(FaultClass::fms_fault))
        {
            if (g_bRealisticAvionics)
            {
                //MI added for ICP stuff.
                //rewritten 04/21/01
#if 0
                bingoFuel = bingoFuel * 0.5F;

                //Update our ICP readout
                if (OTWDriver.pCockpitManager->mpIcp->IsICPSet(ICPClass::BINGO_MODE))
                    OTWDriver.pCockpitManager->mpIcp->ExecBingo();

                if (bingoFuel < 100.0F)
                    bingoFuel = -1.0F;

                cockpitFlightData.SetLightBit(FlightData::FuelLow);
                mFaults->SetFault(fuel_low_fault);
                mFaults->SetMasterCaution();
                F4SoundFXSetDist(af->auxaeroData->sndBBBingo, TRUE, 0.0f, 1.0f);
#else

                //Only warn us if we've not already been warned.
                if ( not mFaults->GetFault(fuel_low_fault))
                {
                    cockpitFlightData.SetLightBit(FlightData::FuelLow);
                    //mFaults->SetFault(fuel_low_fault);
                    mFaults->SetWarning(fuel_low_fault);

                    //Smeg 27-Oct-2003 - added not to play Bingo when not alrady being played. Probably a typo.
                    //if( not F4SoundFXPlaying( af->auxaeroData->sndBBBingo)) // MLR 5/16/2004 -
                    //   F4SoundFXSetDist( af->auxaeroData->sndBBBingo, TRUE, 0.0f, 1.0f );
                    if ( not SoundPos.IsPlaying(af->auxaeroData->sndBBBingo)) // MLR 5/16/2004 -
                        SoundPos.Sfx(af->auxaeroData->sndBBBingo);
                }

#endif
            }
            else
            {
                //me123 let's set a bingo manualy
                bingoFuel =   100.0f;

                if (af->Fuel() <=  100.0F)
                    bingoFuel = -10.0F;

                cockpitFlightData.SetLightBit(FlightData::FuelLow);
                mFaults->SetFault(fuel_low_fault);
                mFaults->SetMasterCaution();

                //if( not F4SoundFXPlaying(af->auxaeroData->sndBBBingo)) // MLR 5/16/2004 -
                //   F4SoundFXSetDist( af->auxaeroData->sndBBBingo, TRUE, 0.0f, 1.0f );
                if ( not SoundPos.IsPlaying(af->auxaeroData->sndBBBingo)) // MLR 5/16/2004 -
                    SoundPos.Sfx(af->auxaeroData->sndBBBingo);

            }

        }
        //MI reset our fuel low fault if we set a bingo value below our current level
        else if (g_bRealisticAvionics and mFaults->GetFault(fuel_low_fault))
        {
            if (bingoFuel < af->Fuel() + af->ExternalFuel())
            {
                cockpitFlightData.ClearLightBit(FlightData::FuelLow);
                mFaults->ClearFault(fuel_low_fault);
            }
        }

        // Caution TO/LDG Config
        //MI
        //if(IsF16())
        //TJL 10/20/03 Allowing TO/LDG Config warning on all aircraft
        if ( not isDigital)
        {
            //RV - I-Hawk - changed altitude value from 10000 to 5000 according to Dannycoh
            if (ZPos() > -5000.0F and GetKias() < 190.0F and ZDelta() * 60.0F >= 250.0F and af->gearPos not_eq 1.0F)
            {
                if ( not mFaults->GetFault(to_ldg_config))
                {
                    if ( not g_bRealisticAvionics)
                        mFaults->SetFault(to_ldg_config);
                    else
                        mFaults->SetWarning(to_ldg_config);
                }
            }
            else
                mFaults->ClearFault(to_ldg_config);

            // JPO check for trapped fuel
            if ( not mFaults->GetFault(FaultClass::fms_fault) and af->CheckTrapped())
            {
                if ( not mFaults->GetFault(fuel_trapped))
                {
                    if ( not g_bRealisticAvionics)
                        mFaults->SetFault(fuel_trapped);
                    else
                        mFaults->SetWarning(fuel_trapped);
                }
            }
            else
                mFaults->ClearFault(fuel_trapped);

            //MI Fuel HOME warning
            if ( not mFaults->GetFault(FaultClass::fms_fault) and af->CheckHome())
            {
                if ( not mFaults->GetFault(fuel_home))
                {
                    if ( not g_bRealisticAvionics)
                        mFaults->SetFault(fuel_home);
                    else
                        mFaults->SetWarning(fuel_home);

                    //Make noise
                    //   if( not F4SoundFXPlaying(af->auxaeroData->sndBBBingo))
                    //   F4SoundFXSetDist( af->auxaeroData->sndBBBingo, TRUE, 0.0f, 1.0f );
                    if ( not SoundPos.IsPlaying(af->auxaeroData->sndBBBingo)) // MLR 5/16/2004 -
                        SoundPos.Sfx(af->auxaeroData->sndBBBingo);

                }
            }
            else
                mFaults->ClearFault(fuel_home);
        }

        /////////////me123 let's brake something if we fly too fast
        //me123 OWLOOK switch here to enable aircraft limits (overg and max speed)
        //if (g_bEnableAircraftLimits) { MI
        if (g_bRealisticAvionics)
        {
            // Marco Edit - OverG DOES NOT affect 
            // (at least not before the aircraft falls apart)
            //MI put back in after discussing with Marco
            CheckForOverG();
            CheckForOverSpeed();
        }

        // save for later.
        int savewarn = mFaults->WarnReset();
        int savemc = mFaults->MasterCaution();

        //// JPO - check hydraulics too.
        ///////////
        if ((af->rpm * 37.0F) < 15.0F or mFaults->GetFault(FaultClass::eng_fault))
        {
            if ( not mFaults->GetFault(oil_press))
            {
                if ( not g_bRealisticAvionics)
                    // less than 15 psi
                    mFaults->SetFault(oil_press);
                else
                    mFaults->SetWarning(oil_press);
            }
        }
        else
            mFaults->ClearFault(oil_press);

        if ( not af->HydraulicOK())
        {
            if ( not mFaults->GetFault(hyd))
            {
                if ( not g_bRealisticAvionics)
                    mFaults->SetFault(hyd);
                else
                    mFaults->SetWarning(hyd);
            }
        }
        else
            mFaults->ClearFault(hyd);

        // JPO Sec is active below 20% rpm
        if (af->rpm < 0.20F)
        {
            if ( not mFaults->GetFault(sec_fault))
            {
                if ( not g_bRealisticAvionics)
                    mFaults->SetFault(sec_fault);
                else
                    mFaults->SetCaution(sec_fault);
            }
        }
        else
            mFaults->ClearFault(sec_fault);

        // this is a hack JPO
        // when starting up we don't want to set the warn/caution lights,
        // but we do want the indicator lights.
        // so we clear the cautions if nothing else had them set.
        if (af->rpm < 1e-2 and OnGround())
        {
            if (savewarn == 0) mFaults->ClearWarnReset();

            if (savemc == 0) mFaults->ClearMasterCaution();
        }

#if 0 // JPO: I don't think this makes any sense to me... me123????

        ///////////me123 changed 27000 to -27000
        if (ZPos() < -27000.0F and mFaults->GetFault(FaultClass::eng_fault))
        {
            if ( not mFaults->GetFault(to_ldg_config))
                mFaults->SetFault(cabin_press_fault);
        }
        else
            mFaults->ClearFault(cabin_press_fault);

#endif

        // JPO - dump dumps cabin pressure, off means its not there anyway.
        // 10000 is a guess - thats where you requirte oxygen
        // MD -- 20031105: the dash one says this caution kicks in at 27k MSL
        if (ZPos() < -27000 and (af->GetAirSource() == AirframeClass::AS_DUMP or
                                af->GetAirSource() == AirframeClass::AS_OFF))
        {
            if ( not mFaults->GetFault(cabin_press_fault))
            {
                if ( not g_bRealisticAvionics)
                    mFaults->SetFault(cabin_press_fault);
                else
                    mFaults->SetCaution(cabin_press_fault);
            }
        }
        else
            mFaults->ClearFault(cabin_press_fault);

        if (mFaults->GetFault(FaultClass::hud_fault) and mFaults->GetFault(FaultClass::fcc_fault))
        {
            if ( not mFaults->GetFault(canopy))
            {
                if ( not g_bRealisticAvionics)
                    mFaults->SetFault(canopy);
                else
                    mFaults->SetWarning(canopy);
            }
        }
        else
            mFaults->ClearFault(canopy);

        ///////////
        if (mFaults->GetFault(FaultClass::fcc_fault))
        {
            if ( not mFaults->GetFault(dual_fc))
            {
                if ( not g_bRealisticAvionics)
                    mFaults->SetFault(dual_fc);
                else
                    mFaults->SetWarning(dual_fc);
            }
        }
        else
            mFaults->ClearFault(dual_fc);

        ///////////
        if (mFaults->GetFault(FaultClass::amux_fault) or mFaults->GetFault(FaultClass::bmux_fault))
        {
            if ( not g_bRealisticAvionics)
                mFaults->SetFault(avionics_fault);
            else
                mFaults->SetCaution(avionics_fault);
        }
        else
        {
            mFaults->ClearFault(avionics_fault);
        }

        ////////////
        if (mFaults->GetFault(FaultClass::ralt_fault))
        {
            if ( not mFaults->GetFault(radar_alt_fault))
            {
                if ( not g_bRealisticAvionics)
                    mFaults->SetFault(radar_alt_fault);
                else
                    mFaults->SetCaution(radar_alt_fault);
            }
        }
        else
            mFaults->ClearFault(radar_alt_fault);

        ///////////////
        if (mFaults->GetFault(FaultClass::iff_fault))
        {
            if ( not mFaults->GetFault(iff_fault))
            {
                if ( not g_bRealisticAvionics)
                    mFaults->SetFault(iff_fault);
                else
                    mFaults->SetCaution(iff_fault);
            }
        }
        else
            mFaults->ClearFault(iff_fault);

        ///////////////
        if (mFaults->GetFault(FaultClass::rwr_fault))
        {
            if ( not mFaults->GetFault(ecm_fault))
            {
                if ( not g_bRealisticAvionics)
                    mFaults->SetFault(ecm_fault);
                else
                    mFaults->SetCaution(ecm_fault);
            }
        }
        else
            mFaults->ClearFault(ecm_fault);

        ///////////////
        if (mFaults->GetFault(FaultClass::rwr_fault))
        {
            if ( not mFaults->GetFault(nws_fault))
            {
                if ( not g_bRealisticAvionics)
                    mFaults->SetFault(nws_fault);
                else
                    mFaults->SetCaution(nws_fault);
            }
        }
        else
            mFaults->ClearFault(nws_fault);

        /////////////
        //MI
        // Overheat Fault
        if (mFaults->GetFault(FaultClass::eng_fault) and af->rpm <= 0.75)
        {
            if ( not mFaults->GetFault(overheat_fault))
            {
                if ( not g_bRealisticAvionics)
                    mFaults->SetFault(overheat_fault);
                else
                    mFaults->SetCaution(overheat_fault);
            }
        }
        else
            mFaults->ClearFault(overheat_fault);


        // if lg up and aoa and speed
        // if airbrakes on
        //MI what kind of bullshit is this anyway?????
        if ( not g_bRealisticAvionics)
        {
            if (mFaults->GetFault(FaultClass::rwr_fault))
            {
                mFaults->SetFault(to_ldg_config);
            }
            else
            {
                mFaults->ClearFault(to_ldg_config);
            }
        }

        //////////////
        // Set external data if this is Ownship and player
        if (this == SimDriver.GetPlayerEntity())
            SetExternalData();

        // AMUX and BMUX combined failure forces FCC into NAV
        if (mFaults->GetFault(FaultClass::amux_fault) and mFaults->GetFault(FaultClass::bmux_fault))
        {
            FCC->SetMasterMode(FireControlComputer::Nav);
        }

        // If blanker broken, no ECM
        if (mFaults->GetFault(FaultClass::blkr_fault))
        {
            SensorClass* theRwr = FindSensor(this, SensorClass::RWR);

            if (theRwr)
                theRwr->SetPower(FALSE);

            UnSetFlag(ECM_ON);
        }

        // Shut down radar when broken
        if (mFaults->GetFault(FaultClass::fcc_fault) == FaultClass::xmtr)
        {
            RadarClass* theRadar = (RadarClass*)FindSensor(this, SensorClass::Radar);

            if (theRadar)
                theRadar->SetEmitting(FALSE);
        }

        if (mFaults->GetFault(FaultClass::fcc_fault) == FaultClass::bus)
        {
            RadarClass* theRadar = (RadarClass*)FindSensor(this, SensorClass::Radar);

            if (theRadar)
                theRadar->SetPower(FALSE);
        }

        // Shut down rwr when broken
        if (mFaults->GetFault(FaultClass::rwr_fault))
        {
            SensorClass* theRwr = FindSensor(this, SensorClass::RWR);

            if (theRwr)
                theRwr->SetPower(FALSE);
        }

        // Shut down HTS when broken
        if (mFaults->GetFault(FaultClass::harm_fault))
        {
            SensorClass* theHTS = FindSensor(this, SensorClass::HTS);

            if (theHTS)
                theHTS->SetPower(FALSE);
        }
    }

    //MI new home of the wrong/correct CAT stuff
    //if(af->platform->IsPlayer() and g_bEnableCATIIIExtension) MI
    if (IsPlayer() and g_bRealisticAvionics)
    {
        float MaxG = af->curMaxGs;
        float limitGs = 6.5f;
        Limiter *limiter = NULL; // JPO - use dynamic figure , not 6.5


        if (limiter = gLimiterMgr->GetLimiter(CatIIIMaxGs, af->VehicleIndex()))
            limitGs = limiter->Limit(0);

        if (MaxG <= limitGs)
        {
            //we need CATIII
            if ( not af->IsSet(AirframeClass::CATLimiterIII))
                WrongCAT();
            else
                CorrectCAT();
        }
        else
        {
            //we don't need CATIII
            if (af->IsSet(AirframeClass::CATLimiterIII))
                WrongCAT();
            else
                CorrectCAT();
        }
    }




    //MI Seat Arm switch
    if (IsPlayer() and g_bRealisticAvionics)
    {
        if ( not SeatArmed)
        {
            if ( not mFaults->GetFault(seat_notarmed_fault))
                mFaults->SetCaution(seat_notarmed_fault);
        }
        else
            mFaults->ClearFault(seat_notarmed_fault);
    }

    if (g_bRealisticAvionics)
    {
        //MI WARN Reset stuff
        //me123 loopign warnign sound is just T_LCFG i think
        if (cockpitFlightData.IsSet(FlightData::T_L_CFG)) //this one gives continous warning
        {
            //sound
            if (mFaults->WarnReset())
            {
                if (vuxGameTime >= WhenToPlayWarning)
                {
                    if ( not SoundPos.IsPlaying(SFX_BB_WARNING)) // MLR 5/16/2004 -
                        SoundPos.Sfx(SFX_BB_WARNING);

                    //    F4SoundFXSetDist(SFX_BB_WARNING, FALSE, 0.0f, 1.0f );
                }
            }
        }
        else
        {
            if (mFaults->DidManWarn())
            {
                mFaults->ClearManWarnReset();
                mFaults->ClearWarnReset();
            }
        }

        //MI Caution sound
        if (NeedsToPlayCaution)
        {
            if (vuxGameTime >= WhenToPlayCaution)
            {
                if (mFaults->MasterCaution())
                {
                    //    if( not F4SoundFXPlaying( af->auxaeroData->sndBBCaution))
                    //        F4SoundFXSetDist( af->auxaeroData->sndBBCaution, TRUE, 0.0f, 1.0f );
                    if ( not SoundPos.IsPlaying(af->auxaeroData->sndBBCaution)) // MLR 5/16/2004 -
                        SoundPos.Sfx(af->auxaeroData->sndBBCaution);


                }

                NeedsToPlayCaution = FALSE;
            }
        }

        if (NeedsToPlayWarning)
        {
            if (vuxGameTime >= WhenToPlayWarning)
            {
                if (mFaults->WarnReset())
                {
                    //    if( not F4SoundFXPlaying(af->auxaeroData->sndBBWarning))
                    //    F4SoundFXSetDist(af->auxaeroData->sndBBWarning, TRUE, 0.0f, 1.0f );
                    if ( not SoundPos.IsPlaying(af->auxaeroData->sndBBWarning)) // MLR 5/16/2004 -
                        SoundPos.Sfx(af->auxaeroData->sndBBWarning);

                }

                NeedsToPlayWarning = FALSE;
            }
        }

        //MI RF In SILENT gives TF FAIL
        if (RFState == 2)
        {
            if ( not mFaults->GetFault(tf_fail))
                mFaults->SetWarning(tf_fail);
        }
        else
            mFaults->ClearFault(tf_fail);
    }
}

//MI make some noise when overstressing
void AircraftClass::DamageSounds(void)
{
    int sound = rand() % 5;
    sound++;

    switch (sound)
    {
        case 1:
            SoundPos.Sfx(SFX_HIT_5);
            break;

        case 2:
            SoundPos.Sfx(SFX_HIT_4);
            break;

        case 3:
            SoundPos.Sfx(SFX_HIT_3);
            break;

        case 4:
            SoundPos.Sfx(SFX_HIT_2);
            break;

        case 5:
            SoundPos.Sfx(SFX_HIT_1);
            break;

        default:
            break;
    }
}

//MI warn us when in wrong config
void AircraftClass::WrongCAT(void)
{
    if (Warned)
        return;

    //set our fault
    mFaults->SetCaution(stores_config_fault);
    //mark that we've been here
    Warned = TRUE;
}

//MI we've switched to the correct CAT
void AircraftClass::CorrectCAT(void)
{
    if ( not Warned)
        return;

    //clear our fault
    mFaults->ClearFault(stores_config_fault);
    //mark that we've been here
    Warned = FALSE;
}

void AircraftClass::CheckForOverG(void)
{
    //check for bombs etc
    if (GetNz() > af->curMaxGs)
    {
        if (this == FalconLocalSession->GetPlayerEntity())
        {
            g_intellivibeData.IsOverG = true;
        }

        //let us know we're approaching overG
        GSounds();

        if (af->curMaxGs == 5.5 and GetNz() > af->curMaxGs + GToleranceBombs)
        {
            StoreToDamage(wcRocketWpn);
            StoreToDamage(wcBombWpn);
            StoreToDamage(wcAgmWpn);
            StoreToDamage(wcHARMWpn);
            StoreToDamage(wcSamWpn);
            StoreToDamage(wcGbuWpn);
        }

        //Tanks have 7G
        if ((af->curMaxGs == 7.0 or af->curMaxGs == 6.5) and GetNz() > af->curMaxGs + GToleranceTanks)
            if (GetNz() > af->curMaxGs + GToleranceTanks)
                StoreToDamage(wcTank);
    }
    else
    {
        if (this == FalconLocalSession->GetPlayerEntity())
            g_intellivibeData.IsOverG = false;
    }
}

void AircraftClass::CheckForOverSpeed(void)
{
    if (af->curMaxGs == 5.5 and GetKias() > af->curMaxStoreSpeed)
    {
        SSounds();

        if (GetKias() > af->curMaxStoreSpeed + SpeedToleranceBombs)
        {
            StoreToDamage(wcRocketWpn);
            StoreToDamage(wcBombWpn);
            StoreToDamage(wcAgmWpn);
            StoreToDamage(wcHARMWpn);
            StoreToDamage(wcSamWpn);
            StoreToDamage(wcGbuWpn);
        }
    }

    if ((af->curMaxGs == 7.0 or af->curMaxGs == 6.5) and GetKias() > af->curMaxStoreSpeed)
    {
        GSounds();

        if (GetKias() > af->curMaxStoreSpeed + SpeedToleranceTanks)
            StoreToDamage(wcTank);
    }

    //TJL 11/03/03 Adding VNE violation
    if (af->vcas > af->maxVcas)
    {
        //F4SoundFXSetDist(af->auxaeroData->sndOverSpeed2, TRUE, 0.0f, (GetKias() - af->maxVcas) / 10);
        //SoundPos.Sfx(af->auxaeroData->sndOverSpeed2, 0, (GetKias() - af->maxVcas) / 10, 0); // MLR 5/16/2004 -
        if (af->vcas > (af->maxVcas + (af->maxVcas * 0.05)))
        {
            DamageSounds();

            //TJL 05/30/04 added more damage modeling
            if ( not mFaults->GetFault(FaultClass::flcs_fault))
            {
                mFaults->SetFault(FaultClass::flcs_fault, FaultClass::dual, FaultClass::fail, FALSE);
            }

            if (pctStrength > 0.0f)
            {
                pctStrength -= 0.25f;
            }

            if (rand() % 100 < 20)
            {
                CanopyDamaged = TRUE;
            }

            if (rand() % 100 < 25 and not LEFState(RT_LEF_OUT))
            {
                if (LEFState(RT_LEF_DAMAGED))
                {
                    LEFOn(RT_LEF_OUT);
                    RTLEFAOA = -20.0f;
                }
                else
                {
                    LEFOn(RT_LEF_DAMAGED);
                    RTLEFAOA = -20.0f;
                    LEFOn(RT_LEF_OUT);
                    LEFOn(LEFSASYNCH);
                }
            }

        }
    }

    //end VNE violation


}

void AircraftClass::DoOverGSpeedDamage(int station)
{
    if ( not mFaults)
        return;

    int damage = rand() % 100;
    damage++;

    switch (station)
    {
        case 1:
            if (damage < 95 and not GetStationFailed(Station1_Degr) and not GetStationFailed(Station1_Fail))
            {
                mFaults->SetFault(FaultClass::sms_fault, FaultClass::sta1, FaultClass::degr, FALSE);
                StationFailed(Station1_Degr);
            }
            else
            {
                if ( not GetStationFailed(Station1_Fail) and (GSoundsNFuel == 2 or GSoundsWFuel == 3))
                    mFaults->SetFault(FaultClass::sms_fault, FaultClass::sta1, FaultClass::fail, FALSE);

                StationFailed(Station1_Fail);
            }

            break;

        case 2:
            damage = rand() % 100;

            if (damage < 95 and not GetStationFailed(Station2_Degr) and not GetStationFailed(Station2_Fail))
            {
                mFaults->SetFault(FaultClass::sms_fault, FaultClass::sta2, FaultClass::degr, FALSE);
                StationFailed(Station2_Degr);
            }
            else
            {
                if ( not GetStationFailed(Station2_Fail) and (GSoundsNFuel == 2 or GSoundsWFuel == 3))
                    mFaults->SetFault(FaultClass::sms_fault, FaultClass::sta2, FaultClass::fail, FALSE);

                StationFailed(Station2_Fail);
            }

            break;

        case 3:
            damage = rand() % 100;

            if (damage < 95 and not GetStationFailed(Station3_Degr) and not GetStationFailed(Station3_Fail))
            {
                mFaults->SetFault(FaultClass::sms_fault, FaultClass::sta3, FaultClass::degr, FALSE);
                StationFailed(Station3_Degr);
            }
            else
            {
                if ( not GetStationFailed(Station3_Fail) and (GSoundsNFuel == 2 or GSoundsWFuel == 3))
                    mFaults->SetFault(FaultClass::sms_fault, FaultClass::sta3, FaultClass::fail, FALSE);

                StationFailed(Station3_Fail);
            }

            break;

        case 4:
            damage = rand() % 100;

            if (damage < 95 and not GetStationFailed(Station4_Degr) and not GetStationFailed(Station4_Fail))
            {
                mFaults->SetFault(FaultClass::sms_fault, FaultClass::sta4, FaultClass::degr, FALSE);
                StationFailed(Station4_Degr);
            }
            else
            {
                if ( not GetStationFailed(Station4_Fail) and (GSoundsNFuel == 2 or GSoundsWFuel == 3))
                    mFaults->SetFault(FaultClass::sms_fault, FaultClass::sta4, FaultClass::fail, FALSE);

                StationFailed(Station4_Fail);
            }

            break;

        case 5:
            damage = rand() % 100;

            if (damage < 95 and not GetStationFailed(Station5_Degr) and not GetStationFailed(Station5_Fail))
            {
                mFaults->SetFault(FaultClass::sms_fault, FaultClass::sta5, FaultClass::degr, FALSE);
                StationFailed(Station5_Degr);
            }
            else
            {
                if ( not GetStationFailed(Station5_Fail) and (GSoundsNFuel == 2 or GSoundsWFuel == 3))
                    mFaults->SetFault(FaultClass::sms_fault, FaultClass::sta5, FaultClass::fail, FALSE);

                StationFailed(Station5_Fail);
            }

            break;

        case 6:
            damage = rand() % 100;

            if (damage < 95 and not GetStationFailed(Station6_Degr) and not GetStationFailed(Station6_Fail))
            {
                mFaults->SetFault(FaultClass::sms_fault, FaultClass::sta6, FaultClass::degr, FALSE);
                StationFailed(Station6_Degr);
            }
            else
            {
                if ( not GetStationFailed(Station6_Fail) and (GSoundsNFuel == 2 or GSoundsWFuel == 3))
                    mFaults->SetFault(FaultClass::sms_fault, FaultClass::sta6, FaultClass::fail, FALSE);

                StationFailed(Station6_Fail);
            }

            break;

        case 7:
            damage = rand() % 100;

            if (damage < 95 and not GetStationFailed(Station7_Degr) and not GetStationFailed(Station7_Fail))
            {
                mFaults->SetFault(FaultClass::sms_fault, FaultClass::sta7, FaultClass::degr, FALSE);
                StationFailed(Station7_Degr);
            }
            else
            {
                if ( not GetStationFailed(Station7_Fail) and (GSoundsNFuel == 2 or GSoundsWFuel == 3))
                    mFaults->SetFault(FaultClass::sms_fault, FaultClass::sta7, FaultClass::fail, FALSE);

                StationFailed(Station7_Fail);
            }

            break;

        case 8:
            damage = rand() % 100;

            if (damage < 95 and not GetStationFailed(Station8_Degr) and not GetStationFailed(Station8_Fail))
            {
                mFaults->SetFault(FaultClass::sms_fault, FaultClass::sta8, FaultClass::degr, FALSE);
                StationFailed(Station8_Degr);
            }
            else
            {
                if ( not GetStationFailed(Station8_Fail) and (GSoundsNFuel == 2 or GSoundsWFuel == 3))
                    mFaults->SetFault(FaultClass::sms_fault, FaultClass::sta8, FaultClass::fail, FALSE);

                StationFailed(Station8_Fail);
            }

            break;

        case 9:
            damage = rand() % 100;

            if (damage < 95 and not GetStationFailed(Station9_Degr) and not GetStationFailed(Station9_Fail))
            {
                mFaults->SetFault(FaultClass::sms_fault, FaultClass::sta9, FaultClass::degr, FALSE);
                StationFailed(Station9_Degr);
            }
            else
            {
                if ( not GetStationFailed(Station9_Fail) and (GSoundsNFuel == 2 or GSoundsWFuel == 3))
                    mFaults->SetFault(FaultClass::sms_fault, FaultClass::sta9, FaultClass::fail, FALSE);

                StationFailed(Station9_Fail);
            }

            break;

        default:
            break;
    }
}

void AircraftClass::StoreToDamage(WeaponClass thing)
{
    if ( not g_bRealisticAvionics or (PlayerOptions.Realism < 0.76 and not isDigital))
        return;

    if ( not Sms or not mFaults or not af)
        return;

    //Check which station to fail
    int center = (Sms->NumHardpoints() - 1) / 2 + 1;

    for (int i = 0; i < Sms->NumHardpoints(); i++)
    {
        // if its a tank - try and guess which one.
        if (Sms->hardPoint[i] and 
            Sms->hardPoint[i]->GetWeaponClass() == thing)
        {
            //tanks cause our Fuel Management System to fail.
            if (thing == wcTank)
            {
                if (GetNz() > af->curMaxGs + GToleranceTanks)
                {
                    AdjustTankG(1);
                    DoOverGSpeedDamage(i);

                    if ( not mFaults->GetFault(FaultClass::fms_fault))
                        mFaults->SetFault(FaultClass::fms_fault, FaultClass::bus, FaultClass::degr, FALSE);

                    if (GSoundsWFuel == 0)
                    {
                        DamageSounds();
                        GSoundsWFuel = 2;
                    }
                }

                if (GetNz() > af->curMaxGs + GToleranceTanks)
                {
                    AdjustTankG(2);
                    DoOverGSpeedDamage(i);

                    if ( not mFaults->GetFault(FaultClass::fms_fault))
                        mFaults->SetFault(FaultClass::fms_fault, FaultClass::bus, FaultClass::fail, FALSE);

                    if (GSoundsWFuel == 2)
                    {
                        DamageSounds();
                        GSoundsWFuel++;
                    }
                }

                if (GetNz() >= af->curMaxGs + GToleranceTanks)
                {
                    AdjustTankG(3);
                    DoOverGSpeedDamage(i);

                    if ( not mFaults->GetFault(FaultClass::flcs_fault))
                        mFaults->SetFault(FaultClass::flcs_fault, FaultClass::sngl, FaultClass::fail, FALSE);

                    if (GSoundsWFuel == 3)
                    {
                        DamageSounds();
                        GSoundsWFuel++;
                    }
                }

                if (GetKias() > af->curMaxStoreSpeed + SpeedToleranceTanks)
                {
                    AdjustTankSpeed(1);
                    DoOverGSpeedDamage(i);

                    if ( not mFaults->GetFault(FaultClass::fms_fault))
                        mFaults->SetFault(FaultClass::fms_fault, FaultClass::bus, FaultClass::fail, FALSE);

                    if (SpeedSoundsWFuel == 0)
                    {
                        DamageSounds();
                        SpeedSoundsWFuel++;
                    }
                }

                if (GetKias() > af->curMaxStoreSpeed + SpeedToleranceTanks)
                {
                    AdjustTankSpeed(2);
                    DoOverGSpeedDamage(i);

                    if ( not mFaults->GetFault(FaultClass::fms_fault))
                        mFaults->SetFault(FaultClass::fms_fault, FaultClass::bus, FaultClass::fail, FALSE);

                    if (SpeedSoundsWFuel == 1)
                    {
                        DamageSounds();
                        SpeedSoundsWFuel++;
                    }
                }

                if (af->mach >= 2.05f or GetKias() > af->curMaxStoreSpeed + SpeedToleranceTanks)
                {
                    AdjustTankSpeed(3);
                    DoOverGSpeedDamage(i);

                    if ( not mFaults->GetFault(FaultClass::flcs_fault))
                        mFaults->SetFault(FaultClass::flcs_fault, FaultClass::sngl, FaultClass::fail, FALSE);

                    if ( not mFaults->GetFault(FaultClass::cadc_fault))
                        mFaults->SetFault(FaultClass::cadc_fault, FaultClass::bus, FaultClass::degr, FALSE);

                    if (SpeedSoundsWFuel == 2)
                    {
                        DamageSounds();
                        SpeedSoundsWFuel++;
                    }
                }
            }

            if (thing == wcBombWpn or thing == wcRocketWpn or thing == wcAgmWpn or
                thing == wcHARMWpn or thing == wcSamWpn or thing == wcGbuWpn)
            {
                if (GetNz() > af->curMaxGs + GToleranceBombs)
                {
                    AdjustBombG(1);
                    DoOverGSpeedDamage(i);

                    if ( not mFaults->GetFault(FaultClass::isa_fault))
                        mFaults->SetFault(FaultClass::isa_fault, FaultClass::sngl, FaultClass::fail, FALSE);

                    if (GSoundsNFuel == 0)
                    {
                        DamageSounds();
                        GSoundsNFuel = 2;
                    }
                }

                if (GetNz() >= af->curMaxGs + GToleranceBombs)
                {
                    AdjustBombG(2);
                    DoOverGSpeedDamage(i);

                    if ( not mFaults->GetFault(FaultClass::sms_fault))
                        mFaults->SetFault(FaultClass::sms_fault, FaultClass::bus, FaultClass::degr, FALSE);

                    if (GSoundsNFuel == 2)
                    {
                        DamageSounds();
                        GSoundsNFuel++;
                    }
                }

                if (GetNz() >= af->curMaxGs + GToleranceBombs)
                {
                    AdjustBombG(3);
                    DoOverGSpeedDamage(i);

                    if ( not mFaults->GetFault(FaultClass::flcs_fault))
                        mFaults->SetFault(FaultClass::flcs_fault, FaultClass::dual, FaultClass::fail, FALSE);

                    if ( not mFaults->GetFault(FaultClass::sms_fault) bitand FaultClass::bus bitand FaultClass::fail)
                        mFaults->SetFault(FaultClass::sms_fault, FaultClass::bus, FaultClass::fail, FALSE);

                    if (GSoundsNFuel == 3)
                    {
                        DamageSounds();
                        GSoundsNFuel++;
                    }
                }

                if (GetKias() > af->curMaxStoreSpeed + SpeedToleranceBombs)
                {
                    AdjustBombSpeed(1);
                    DoOverGSpeedDamage(i);

                    if (SpeedSoundsNFuel == 0)
                    {
                        DamageSounds();
                        SpeedSoundsNFuel++;
                    }
                }

                if (GetKias() > af->curMaxStoreSpeed + SpeedToleranceBombs)
                {
                    AdjustBombSpeed(2);
                    DoOverGSpeedDamage(i);

                    if ( not mFaults->GetFault(FaultClass::fms_fault))
                        mFaults->SetFault(FaultClass::fms_fault, FaultClass::bus, FaultClass::fail, FALSE);

                    if ( not mFaults->GetFault(FaultClass::isa_fault))
                        mFaults->SetFault(FaultClass::isa_fault, FaultClass::sngl, FaultClass::fail, FALSE);

                    if (SpeedSoundsNFuel == 1)
                    {
                        DamageSounds();
                        SpeedSoundsNFuel++;
                    }
                }

                if (af->mach >= 2.05f or GetKias() > af->curMaxStoreSpeed + SpeedToleranceBombs)
                {
                    AdjustBombSpeed(3);
                    DoOverGSpeedDamage(i);

                    if ( not mFaults->GetFault(FaultClass::flcs_fault))
                        mFaults->SetFault(FaultClass::flcs_fault, FaultClass::sngl, FaultClass::fail, FALSE);

                    if ( not mFaults->GetFault(FaultClass::cadc_fault))
                        mFaults->SetFault(FaultClass::cadc_fault, FaultClass::bus, FaultClass::degr, FALSE);

                    if ( not mFaults->GetFault(FaultClass::amux_fault))
                        mFaults->SetFault(FaultClass::amux_fault, FaultClass::bus, FaultClass::degr, FALSE);

                    if ( not mFaults->GetFault(FaultClass::fcc_fault))
                        mFaults->SetFault(FaultClass::fcc_fault, FaultClass::bus, FaultClass::degr, FALSE);

                    if (SpeedSoundsNFuel == 2)
                    {
                        DamageSounds();
                        SpeedSoundsNFuel++;
                    }
                }
            }
        }
    }
}

void AircraftClass::SetExternalData(void)
{

    // MD -- 20031113: Adding support for the MAL IND button the test panel to update the
    // shared memory bit preperly.  Also play the VMS in accordance with the dash one; technically
    // this should mean saying each of the words once each while the button is held in the test
    // position but this doesn't seem to be possible without new sounds for this purpose.
    // MD -- 20031216: oops forgot the AVTR lamp in HsiBits
    AircraftClass *playerAC = SimDriver.GetPlayerAircraft();

    if (playerAC == NULL)
    {
        // sfr: NULL check
        return;
    }

    if (playerAC->TestLights not_eq NULL)
    {
        cockpitFlightData.lightBits  = FlightData::AllLampBitsOn;   // All current lamp related lightBits  to ON
        cockpitFlightData.lightBits2 = FlightData::AllLampBits2On;  // All current lamp related lightBits2 to ON
        cockpitFlightData.lightBits3 = FlightData::AllLampBits3On;  // All current lamp related lightBits3 to ON
        cockpitFlightData.hsiBits = FlightData::AllLampHsiBitsOn;   // All current lamp related HsiBits to ON
        //if( not F4SoundFXPlaying(SFX_BB_ALLWORDS))
        // F4SoundFXSetDist(SFX_BB_ALLWORDS, TRUE, 0.0f, 1.0f );
        SoundPos.Sfx(SFX_BB_ALLWORDS); // MLR 5/16/2004 -
        return;
    }

    /* // MLR 5/16/2004 -
    else {
     if (F4SoundFXPlaying(SFX_BB_ALLWORDS))  // stop the littany if player lets up on the MAL/IND switch
     F4StopSound(SFX_DEF[SFX_BB_ALLWORDS].handle);
    }
    */

    // Master Caution
    //if (OTWDriver.pCockpitManager->mMiscStates.GetMasterCautionLight())
    // MD -- 20031007: don't look at the cockpit art light, look at the fault state to
    // determine whether to set the sh.mem value.  This makes sure that it goes on and
    // off even if the lamp is not in the current field of view.
    if (playerAC->mFaults->MasterCaution())
    {
        cockpitFlightData.SetLightBit(FlightData::MasterCaution);
    }
    else
    {
        cockpitFlightData.ClearLightBit(FlightData::MasterCaution);
    }

    // Oil Pressure
    if ((af->rpm * 37.0F) < 15.0F or mFaults->GetFault(FaultClass::eng_fault))
        cockpitFlightData.SetLightBit(FlightData::OIL);
    else
        cockpitFlightData.ClearLightBit(FlightData::OIL);

    if ( not af->HydraulicOK() and ( not (((AircraftClass*)(playerAC))->MainPower() == AircraftClass::MainPowerOff)))
        cockpitFlightData.SetLightBit(FlightData::HYD);
    else
        cockpitFlightData.ClearLightBit(FlightData::HYD);

    // Cabin Pressure
    if (ZPos() < 27000.0F and mFaults->GetFault(FaultClass::eng_fault))
        cockpitFlightData.SetLightBit(FlightData::CabinPress);
    else
        cockpitFlightData.ClearLightBit(FlightData::CabinPress);

    // Canopy Light
    if (mFaults->GetFault(FaultClass::hud_fault) and mFaults->GetFault(FaultClass::fcc_fault))
        cockpitFlightData.SetLightBit(FlightData::CAN);
    else
        cockpitFlightData.ClearLightBit(FlightData::CAN);

    // FLCS
    if (mFaults->GetFault(FaultClass::fcc_fault))
        cockpitFlightData.SetLightBit(FlightData::DUAL);
    else
        cockpitFlightData.ClearLightBit(FlightData::DUAL);

    // Avioncs Caution
    if ( not g_bRealisticAvionics)
    {
        if (mFaults->GetFault(FaultClass::amux_fault) or mFaults->GetFault(FaultClass::bmux_fault))
            cockpitFlightData.SetLightBit(FlightData::Avionics);
        else
            cockpitFlightData.ClearLightBit(FlightData::Avionics);
    }
    else
    {
        if (mFaults->NeedAckAvioncFault)
            cockpitFlightData.SetLightBit(FlightData::Avionics);
        else
            cockpitFlightData.ClearLightBit(FlightData::Avionics);
    }

    // Radar altimeter
    if (mFaults->GetFault(radar_alt_fault))
        cockpitFlightData.SetLightBit(FlightData::RadarAlt);
    else
        cockpitFlightData.ClearLightBit(FlightData::RadarAlt);

    // IFF Fault
    if (mFaults->GetFault(FaultClass::iff_fault))
        cockpitFlightData.SetLightBit(FlightData::IFF);
    else
        cockpitFlightData.ClearLightBit(FlightData::IFF);

    // AOA Indicator lights
    if (cockpitFlightData.alpha >= 14.0F)
    {
        cockpitFlightData.SetLightBit(FlightData::AOAAbove);
        cockpitFlightData.ClearLightBit(FlightData::AOAOn);
        cockpitFlightData.ClearLightBit(FlightData::AOABelow);
    }
    else if ((cockpitFlightData.alpha < 14.0F) and (cockpitFlightData.alpha >= 11.5F))
    {
        cockpitFlightData.ClearLightBit(FlightData::AOAAbove);
        cockpitFlightData.SetLightBit(FlightData::AOAOn);
        cockpitFlightData.ClearLightBit(FlightData::AOABelow);
    }
    else
    {
        cockpitFlightData.ClearLightBit(FlightData::AOAAbove);
        cockpitFlightData.ClearLightBit(FlightData::AOAOn);
        cockpitFlightData.SetLightBit(FlightData::AOABelow);
    }

    //Commented out by JPG - 1/1/04 - The AoA indexer is operational regardless of the gear being up
    // or down - per the -1
    //MI only operational with gear down
    /*if(g_bRealisticAvionics and af and af->gearPos < 0.8F)
    {
     cockpitFlightData.ClearLightBit(FlightData::AOAOn);
     cockpitFlightData.ClearLightBit(FlightData::AOABelow);
     cockpitFlightData.ClearLightBit(FlightData::AOAAbove);
    }*/

    // Nose Wheel Steering
    // MD -- 20031215: this was pretty broken in that it only recorded what happens to
    // the NWS function.  Adding refueling status indications now.

    // For 3 seconds after disconnect the DISC light comes on
    // cross reference to cblights.cpp where this check used to be
    // This is probably not a great place for this but it should at
    // least work properly.  Leaving this over in cblights would mean that
    // the timecheck would only be preformed if the lamp is on the screen.

    if (OTWDriver.pCockpitManager->mMiscStates.mRefuelState == 3 and (vuxGameTime > (OTWDriver.pCockpitManager->mMiscStates.mRefuelTimer + 3000)))
    {
        OTWDriver.pCockpitManager->mMiscStates.SetRefuelState(0);
    }

    if (playerAC->af->IsSet(AirframeClass::NoseSteerOn) or
        (OTWDriver.pCockpitManager->mMiscStates.mRefuelState == 2))  // contact
        cockpitFlightData.SetLightBit(FlightData::RefuelAR);
    else
        cockpitFlightData.ClearLightBit(FlightData::RefuelAR);

    if (playerAC->af->IsEngineFlag(AirframeClass::FuelDoorOpen) and 
        (OTWDriver.pCockpitManager->mMiscStates.mRefuelState <= 1))  // ready to refuel
        cockpitFlightData.SetLightBit(FlightData::RefuelRDY);
    else
        cockpitFlightData.ClearLightBit(FlightData::RefuelRDY);

    if (OTWDriver.pCockpitManager->mMiscStates.mRefuelState == 3)
        cockpitFlightData.SetLightBit(FlightData::RefuelDSC);
    else
        cockpitFlightData.ClearLightBit(FlightData::RefuelDSC);


    // FLCS
    if (mFaults->GetFault(FaultClass::flcs_fault))
        cockpitFlightData.SetLightBit(FlightData::FltControlSys);
    else
        cockpitFlightData.ClearLightBit(FlightData::FltControlSys);

    // Engine Fault
    if (mFaults->GetFault(FaultClass::eng_fault))
        cockpitFlightData.SetLightBit(FlightData::EngineFault);
    else
        cockpitFlightData.ClearLightBit(FlightData::EngineFault);

    // Overheat Fault
    if (mFaults->GetFault(FaultClass::eng_fault) and af->rpm <= 0.75)
        cockpitFlightData.SetLightBit(FlightData::Overheat);
    else
        cockpitFlightData.ClearLightBit(FlightData::Overheat);

    // These are not faults, they are cautions
    if (mFaults->GetFault(FaultClass::eng_fault) bitand FaultClass::efire)
        cockpitFlightData.SetLightBit(FlightData::ENG_FIRE);
    else
        cockpitFlightData.ClearLightBit(FlightData::ENG_FIRE);

    // TJL 01/24/04 multi-engine
    // These are not faults, they are cautions
    if (mFaults->GetFault(FaultClass::eng2_fault) bitand FaultClass::efire)
        cockpitFlightData.SetLightBit3(FlightData::Eng2_Fire);
    else
        cockpitFlightData.ClearLightBit3(FlightData::Eng2_Fire);

    //MI
    if (mFaults->GetFault(stores_config_fault))
        cockpitFlightData.SetLightBit(FlightData::CONFIG);
    else
        cockpitFlightData.ClearLightBit(FlightData::CONFIG);

    // Caution TO/LDG Config
    // MD -- 20031120: replace test with fault check
    if (mFaults->GetFault(to_ldg_config))
        cockpitFlightData.SetLightBit(FlightData::T_L_CFG);
    else
        cockpitFlightData.ClearLightBit(FlightData::T_L_CFG);

    if (mFaults->GetFault(nws_fault))
        cockpitFlightData.SetLightBit(FlightData::NWSFail);
    else
        cockpitFlightData.ClearLightBit(FlightData::NWSFail);

    if (mFaults->GetFault(cabin_press_fault))
        cockpitFlightData.SetLightBit(FlightData::CabinPress);
    else
        cockpitFlightData.ClearLightBit(FlightData::CabinPress);

    // MD -- 20031101: Adding a check for Weight on Wheels.  If the a/c is on the ground
    // and the gear is down and there are no gear faults WoW switch is ""on""
    // this is not used elsewhere in the game but several places do use the OnGround() routine
    // to implement correct WoW behavior.
    if (playerAC->OnGround() and (af->gearPos == 1.0F) and 
        ( not playerAC->mFaults->GetFault(FaultClass::gear_fault)))
        cockpitFlightData.SetLightBit(FlightData::WOW);
    else
        cockpitFlightData.ClearLightBit(FlightData::WOW);

    // MD -- 20031125: adding a bit to show if the autopilot is engaged or not.  This will be
    // useful for cockpit builders that implement the rightmost AP switch with the same kind of
    // switch that is used in the F-16: a three place momentary that has the off-center positions
    // magnetically captured to hold the swithc out of the off position while the AP is functioning
    // within its operating limits.  Use this bit to turn on the solenoid if your switch has one

    if ((playerAC->IsOn(AircraftClass::AttHold)) or (playerAC->IsOn(AircraftClass::AltHold)))
        cockpitFlightData.SetLightBit(FlightData::AutoPilotOn);
    else
        cockpitFlightData.ClearLightBit(FlightData::AutoPilotOn);

    if (mFaults->GetFault(oxy_low_fault))
        cockpitFlightData.SetLightBit2(FlightData::OXY_LOW);
    else
        cockpitFlightData.ClearLightBit2(FlightData::OXY_LOW);

    if (mFaults->GetFault(fwd_fuel_low_fault))
        cockpitFlightData.SetLightBit2(FlightData::FwdFuelLow);
    else
        cockpitFlightData.ClearLightBit2(FlightData::FwdFuelLow);

    if (mFaults->GetFault(aft_fuel_low_fault))
        cockpitFlightData.SetLightBit2(FlightData::AftFuelLow);
    else
        cockpitFlightData.ClearLightBit2(FlightData::AftFuelLow);

    if (mFaults->GetFault(sec_fault))
        cockpitFlightData.SetLightBit2(FlightData::SEC);
    else
        cockpitFlightData.ClearLightBit2(FlightData::SEC);

    if (mFaults->GetFault(probeheat_fault))
        cockpitFlightData.SetLightBit2(FlightData::PROBEHEAT);
    else
        cockpitFlightData.ClearLightBit2(FlightData::PROBEHEAT);

    if (mFaults->GetFault(buc_fault))
        cockpitFlightData.SetLightBit2(FlightData::BUC);
    else
        cockpitFlightData.ClearLightBit2(FlightData::BUC);

    if (mFaults->GetFault(fueloil_hot_fault))
        cockpitFlightData.SetLightBit2(FlightData::FUEL_OIL_HOT);
    else
        cockpitFlightData.ClearLightBit2(FlightData::FUEL_OIL_HOT);

    if (mFaults->GetFault(anti_skid_fault))
        cockpitFlightData.SetLightBit2(FlightData::ANTI_SKID);
    else
        cockpitFlightData.ClearLightBit2(FlightData::ANTI_SKID);

    if (mFaults->GetFault(seat_notarmed_fault))
        cockpitFlightData.SetLightBit2(FlightData::SEAT_ARM);
    else
        cockpitFlightData.ClearLightBit2(FlightData::SEAT_ARM);

    // MD -- 20031011: Moved all the SetLightBit2() calls from cblights.cpp to here
    // which will ensure the bits in the flightData structure are consistent with the
    // state of the jet regardless of the OTW view state.

    if (playerAC->IsSetFlag(ECM_ON))
        cockpitFlightData.SetLightBit2(FlightData::EcmPwr);
    else
        cockpitFlightData.ClearLightBit2(FlightData::EcmPwr);

    if (playerAC->mFaults->GetFault(FaultClass::epod_fault) or
        playerAC->mFaults->GetFault(FaultClass::blkr_fault))
        cockpitFlightData.SetLightBit2(FlightData::EcmFail);
    else
        cockpitFlightData.ClearLightBit2(FlightData::EcmFail);

    PlayerRwrClass* theRwr = (PlayerRwrClass*)FindSensor(playerAC, SensorClass::RWR);

    if (theRwr) // MLR Somewhere inside here crashed.
    {
        if (theRwr->HasActivity())
            cockpitFlightData.SetLightBit2(FlightData::AuxAct);
        else
            cockpitFlightData.ClearLightBit2(FlightData::AuxAct);

        if (theRwr->LaunchIndication())
            cockpitFlightData.SetLightBit2(FlightData::Launch);
        else
            cockpitFlightData.ClearLightBit2(FlightData::Launch);

        if (theRwr->ManualSelect())
            cockpitFlightData.SetLightBit2(FlightData::HandOff);
        else
            cockpitFlightData.ClearLightBit2(FlightData::HandOff);

        if (theRwr->IsPriority())
            cockpitFlightData.SetLightBit2(FlightData::PriMode);
        else
            cockpitFlightData.ClearLightBit2(FlightData::PriMode);

        if (theRwr->LightUnknowns())
            cockpitFlightData.SetLightBit2(FlightData::Unk);
        else
            cockpitFlightData.ClearLightBit2(FlightData::Unk);

        if (theRwr->ShowNaval())
            cockpitFlightData.SetLightBit2(FlightData::Naval);
        else
            cockpitFlightData.ClearLightBit2(FlightData::Naval);

        if (theRwr->TargetSep())
            cockpitFlightData.SetLightBit2(FlightData::TgtSep);
        else
            cockpitFlightData.ClearLightBit2(FlightData::TgtSep);

        if (theRwr->LightSearch())
            cockpitFlightData.SetLightBit2(FlightData::AuxSrch);
        else
            cockpitFlightData.ClearLightBit2(FlightData::AuxSrch);

        if (theRwr->LowAltPriority())
            cockpitFlightData.SetLightBit2(FlightData::AuxLow);
        else
            cockpitFlightData.ClearLightBit2(FlightData::AuxLow);

        if (theRwr->IsOn())
            cockpitFlightData.SetLightBit2(FlightData::AuxPwr);
        else
            cockpitFlightData.ClearLightBit2(FlightData::AuxPwr);
    }

    if (((AircraftClass*)(playerAC))->AutopilotType() == AircraftClass::LantirnAP)
        cockpitFlightData.SetLightBit2(FlightData::TFR_ENGAGED);
    else
        cockpitFlightData.ClearLightBit2(FlightData::TFR_ENGAGED);

    // MD -- 20031207: This isn't exactly how the STBY light works in the real thing but given that the
    // LANTIRN implementation isn't complete and blended TF/AP pitch mode isn't implemented, this will
    // have to do for now.
    // Lamp should be on if the TFR mode is standby or if the AP Override is being held during TFR operation.

    if ((theLantirn and (theLantirn->GetTFRMode() == LantirnClass::TFR_STBY)) or
        ((playerAC->lastapType == AircraftClass::LantirnAP) and playerAC->IsOn(AircraftClass::Override)))
        cockpitFlightData.SetLightBit(FlightData::TFR_STBY);
    else
        cockpitFlightData.ClearLightBit(FlightData::TFR_STBY);

    // MD -- 20031011: this is a different logic flow that is used when looking at the cockpit
    // because here we only care about the lamp state not where the handle is (up/down)
    if (playerAC->mFaults->GetFault(FaultClass::gear_fault) or
        (playerAC->mFaults->GetFault(to_ldg_config) and playerAC->af->gearPos == 0.0F) or
        ((playerAC->af->gearPos not_eq 0.0F) and (playerAC->af->gearPos not_eq 1.0F)))
        cockpitFlightData.SetLightBit2(FlightData::GEARHANDLE);
    else
        cockpitFlightData.ClearLightBit2(FlightData::GEARHANDLE);

    // MD -- 20021011: end of lightBits2 fixes

    if (af->EpuIsAir())
        cockpitFlightData.SetLightBit3(FlightData::Air);
    else
        cockpitFlightData.ClearLightBit3(FlightData::Air);

    if (af->EpuIsHydrazine())
        cockpitFlightData.SetLightBit3(FlightData::Hydrazine);
    else
        cockpitFlightData.ClearLightBit3(FlightData::Hydrazine);

    if (ElecIsSet(AircraftClass::ElecFlcsPmg))
        cockpitFlightData.SetLightBit3(FlightData::FlcsPmg);
    else
        cockpitFlightData.ClearLightBit3(FlightData::FlcsPmg);

    if (ElecIsSet(AircraftClass::ElecEpuGen))
        cockpitFlightData.SetLightBit3(FlightData::EpuGen);
    else
        cockpitFlightData.ClearLightBit3(FlightData::EpuGen);

    if (ElecIsSet(AircraftClass::ElecEpuPmg))
        cockpitFlightData.SetLightBit3(FlightData::EpuPmg);
    else
        cockpitFlightData.ClearLightBit3(FlightData::EpuPmg);

    if (ElecIsSet(AircraftClass::ElecToFlcs))
        cockpitFlightData.SetLightBit3(FlightData::ToFlcs);
    else
        cockpitFlightData.ClearLightBit3(FlightData::ToFlcs);

    if (ElecIsSet(AircraftClass::ElecFlcsRly))
        cockpitFlightData.SetLightBit3(FlightData::FlcsRly);
    else
        cockpitFlightData.ClearLightBit3(FlightData::FlcsRly);

    if (ElecIsSet(AircraftClass::ElecBatteryFail))
        cockpitFlightData.SetLightBit3(FlightData::BatFail);
    else
        cockpitFlightData.ClearLightBit3(FlightData::BatFail);

    if (af->IsSet(AirframeClass::JfsStart))
        cockpitFlightData.SetLightBit2(FlightData::JFSOn);
    else
        cockpitFlightData.ClearLightBit2(FlightData::JFSOn);

    // JPO Is EPU running.
    if (af->GeneratorRunning(AirframeClass::GenEpu))
        cockpitFlightData.SetLightBit2(FlightData::EPUOn);
    else
        cockpitFlightData.ClearLightBit2(FlightData::EPUOn);

    // MD -- 20031221: This one is for Mirv -- separate light for the lower half of the ENG FIRE/ENGINE split face
    // lamp on the right side of the glareshield.
    if (((af->rpm <= 0.6F) and (((AircraftClass*)(playerAC))->MainPower() == AircraftClass::MainPowerMain)) or
        (cockpitFlightData.ftit > 1100.0F))
        cockpitFlightData.SetLightBit2(FlightData::ENGINE);
    else
        cockpitFlightData.ClearLightBit2(FlightData::ENGINE);

    // MD -- 20031011: this lights come on if the generator is *not* running
    // but only set this to on if the main power switch is not in the off position
    if ( not af->GeneratorRunning(AirframeClass::GenMain) and 
        ( not (((AircraftClass*)(playerAC))->MainPower() == AircraftClass::MainPowerOff)))
        cockpitFlightData.SetLightBit3(FlightData::MainGen);
    else
        cockpitFlightData.ClearLightBit3(FlightData::MainGen);

    // MD -- 20031011: this lights come on if the generator is *not* running
    // but only set this to on if the main power switch is not in the off position
    if ( not af->GeneratorRunning(AirframeClass::GenStdby) and 
        ( not (((AircraftClass*)(playerAC))->MainPower() == AircraftClass::MainPowerOff)))
        cockpitFlightData.SetLightBit3(FlightData::StbyGen);
    else
        cockpitFlightData.ClearLightBit3(FlightData::StbyGen);

    //MI RF In SILENT gives TF FAIL
    // MD -- 20031011: make the pattern consistent and ensure that if tf_fail is ever set anywhere else
    // in future, the caution light will get lit properly.
    //if(RFState == 2)
    if (mFaults->GetFault(tf_fail))
        cockpitFlightData.SetLightBit(FlightData::TF);
    else
        cockpitFlightData.ClearLightBit(FlightData::TF);

    if (mFaults->GetFault(elec_fault))
        cockpitFlightData.SetLightBit3(FlightData::Elec_Fault);
    else
        cockpitFlightData.ClearLightBit3(FlightData::Elec_Fault);

    if (mFaults->GetFault(alt_low))
        cockpitFlightData.SetLightBit(FlightData::ALT);
    else
        cockpitFlightData.ClearLightBit(FlightData::ALT);

    if (mFaults->GetFault(le_flaps_fault))
        cockpitFlightData.SetLightBit(FlightData::LEFlaps);
    else
        cockpitFlightData.ClearLightBit(FlightData::LEFlaps);

    if (mFaults->GetFault(ecm_fault))
        cockpitFlightData.SetLightBit(FlightData::ECM);
    else
        cockpitFlightData.ClearLightBit(FlightData::ECM);

    if (mFaults->GetFault(hook_fault))
        cockpitFlightData.SetLightBit(FlightData::Hook);
    else
        cockpitFlightData.ClearLightBit(FlightData::Hook);

    if (mFaults->GetFault(lef_fault))
        cockpitFlightData.SetLightBit3(FlightData::Lef_Fault);
    else
        cockpitFlightData.ClearLightBit3(FlightData::Lef_Fault);

    // MD -- 20031208: adding a bit for power off -- set if there is no electrical power

    if (((AircraftClass*)(playerAC))->MainPower() == AircraftClass::MainPowerOff)
        cockpitFlightData.SetLightBit3(FlightData::Power_Off);
    else
        cockpitFlightData.ClearLightBit3(FlightData::Power_Off);

    // MD -- 20040301: adding bits for the gear down and locked so you can see for sure
    // what the individual strut state looks like.
    if (GetDOFValue(ComplexGearDOF[0]) == (af->GetAeroData(AeroDataSet::NosGearRng) * DTR))
        cockpitFlightData.SetLightBit3(FlightData::NoseGearDown);
    else
        cockpitFlightData.ClearLightBit3(FlightData::NoseGearDown);

    if (GetDOFValue(ComplexGearDOF[1]) == (af->GetAeroData(AeroDataSet::NosGearRng + 4) * DTR))
        cockpitFlightData.SetLightBit3(FlightData::LeftGearDown);
    else
        cockpitFlightData.ClearLightBit3(FlightData::LeftGearDown);

    if (GetDOFValue(ComplexGearDOF[2]) == (af->GetAeroData(AeroDataSet::NosGearRng + 8) * DTR))
        cockpitFlightData.SetLightBit3(FlightData::RightGearDown);
    else
        cockpitFlightData.ClearLightBit3(FlightData::RightGearDown);

}

void AircraftClass::GSounds(void)
{
    //not if we're going down
    if ( not IsExploding() and not IsDead())
    {
        //F4SoundFXSetDist(af->auxaeroData->sndOverSpeed1, TRUE, 0.0f, 1.0f);
        //RV - I-Hawk - Added 0, 2, -1000 parameters to lower volume for such overG sound
        SoundPos.Sfx(af->auxaeroData->sndOverSpeed1, 0, 2, -1000); // MLR 5/16/2004 -
    }
}

void AircraftClass::SSounds(void)
{
    if ( not IsExploding() and not IsDead())
    {
        //F4SoundFXSetDist(af->auxaeroData->sndOverSpeed2, TRUE, 0.0f, (GetKias() - af->curMaxStoreSpeed) / 25);
        if (af->curMaxStoreSpeed)
        {
            float v;

            //v = k - l / (h-l)
            /*
            v = (GetKias() - af->curMaxStoreSpeed) / 50 ;
            if(v<0)
             v=0;
            else
             if(v>1)
             v=1;

            v=(1-v) * -2000;
            */

            v = -2000;
            v += ((GetKias() - af->curMaxStoreSpeed) / 50) * 250 ;

            //F4SoundFXSetDist(af->auxaeroData->sndOverSpeed2, TRUE, v, ( (GetKias() - af->curMaxStoreSpeed)) / 25);
            SoundPos.Sfx(af->auxaeroData->sndOverSpeed2, 0, 2 , v); // MLR 5/16/2004 -
        }
    }
}

void AircraftClass::AdjustTankSpeed(int level)
{
    //adjust for OverG/Speed
    switch (level)
    {
        case 1:
            SpeedToleranceTanks = OverSpeedToleranceTanks[1];
            break;

        case 2:
            SpeedToleranceTanks = OverSpeedToleranceTanks[2];
            break;

        case 3:
            SpeedToleranceTanks = 100; //No more damage
            break;

        default:
            break;
    }
}

void AircraftClass::AdjustBombSpeed(int level)
{
    //adjust for OverG/Speed
    switch (level)
    {
        case 1:
            SpeedToleranceBombs = OverSpeedToleranceBombs[1];
            break;

        case 2:
            SpeedToleranceBombs = OverSpeedToleranceBombs[2];
            break;

        case 3:
            SpeedToleranceBombs = 100; //No more damage
            break;

        default:
            break;
    }
}

void AircraftClass::AdjustTankG(int level)
{
    //adjust for OverG/Speed
    switch (level)
    {
        case 1:
            GToleranceTanks = float(OverGToleranceTanks[1]) / 10.0f;
            break;

        case 2:
            GToleranceTanks = float(OverGToleranceTanks[2]) / 10.0f;
            break;

        case 3:
            GToleranceTanks = 100; //No more damage
            break;

        default:
            break;
    }
}

void AircraftClass::AdjustBombG(int level)
{
    //adjust for OverG/Speed
    switch (level)
    {
        case 1:
            GToleranceBombs = float(OverGToleranceBombs[1]) / 10.0f;
            break;

        case 2:
            GToleranceBombs = float(OverGToleranceBombs[2]) / 10.0f;
            break;

        case 3:
            GToleranceBombs = 100; //No more damage
            break;

        default:
            break;
    }
}
",16182,True,3321.265665175336,median
"[[netty-component]]
= Netty Component
//THIS FILE IS COPIED: EDIT THE SOURCE FILE:
:page-source: components/camel-netty/src/main/docs/netty-component.adoc
:docTitle: Netty
:artifactId: camel-netty
:description: Socket level networking using TCP or UDP with the Netty 4.x.
:since: 2.14
:supportLevel: Stable
:component-header: Both producer and consumer are supported
include::{cq-version}@camel-quarkus:ROOT:partial$reference/components/netty.adoc[opts=optional]

*Since Camel {since}*

*{component-header}*

The Netty component in Camel is a socket communication component,
based on the http://netty.io/[Netty] project version 4. +
 Netty is a NIO client server framework which enables quick and easy
development of networkServerInitializerFactory applications such as
protocol servers and clients. +
 Netty greatly simplifies and streamlines network programming such as
TCP and UDP socket server.

This camel component supports both producer and consumer endpoints.

The Netty component has several options and allows fine-grained control
of a number of TCP/UDP communication parameters (buffer sizes,
keepAlives, tcpNoDelay, etc) and facilitates both In-Only and In-Out
communication on a Camel route.

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-netty</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>
----

== URI format

The URI scheme for a netty component is as follows

[source,text]
----
netty:tcp://0.0.0.0:99999[?options]
netty:udp://remotehost:99999/[?options]
----

This component supports producer and consumer endpoints for both TCP and
UDP.

You can append query options to the URI in the following format,
`?option=value&option=value&...`

== Options

// component options: START
The Netty component supports 73 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *configuration* (common) | To use the NettyConfiguration as configuration when creating endpoints. |  | NettyConfiguration
| *disconnect* (common) | Whether or not to disconnect(close) from Netty Channel right after use. Can be used for both consumer and producer. | false | boolean
| *keepAlive* (common) | Setting to ensure socket is not closed due to inactivity | true | boolean
| *reuseAddress* (common) | Setting to facilitate socket multiplexing | true | boolean
| *reuseChannel* (common) | This option allows producers and consumers (in client mode) to reuse the same Netty Channel for the lifecycle of processing the Exchange. This is useful if you need to call a server multiple times in a Camel route and want to use the same network connection. When using this, the channel is not returned to the connection pool until the Exchange is done; or disconnected if the disconnect option is set to true. The reused Channel is stored on the Exchange as an exchange property with the key NettyConstants#NETTY_CHANNEL which allows you to obtain the channel during routing and use it as well. | false | boolean
| *sync* (common) | Setting to set endpoint as one-way or request-response | true | boolean
| *tcpNoDelay* (common) | Setting to improve TCP protocol performance | true | 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
| *broadcast* (consumer) | Setting to choose Multicast over UDP | false | boolean
| *clientMode* (consumer) | If the clientMode is true, netty consumer will connect the address as a TCP client. | false | boolean
| *reconnect* (consumer) | Used only in clientMode in consumer, the consumer will attempt to reconnect on disconnection if this is enabled | true | boolean
| *reconnectInterval* (consumer) | Used if reconnect and clientMode is enabled. The interval in milli seconds to attempt reconnection | 10000 | int
| *backlog* (consumer) | Allows to configure a backlog for netty consumer (server). Note the backlog is just a best effort depending on the OS. Setting this option to a value such as 200, 500 or 1000, tells the TCP stack how long the accept queue can be If this option is not configured, then the backlog depends on OS setting. |  | int
| *bossCount* (consumer) | When netty works on nio mode, it uses default bossCount parameter from Netty, which is 1. User can use this option to override the default bossCount from Netty | 1 | int
| *bossGroup* (consumer) | Set the BossGroup which could be used for handling the new connection of the server side across the NettyEndpoint |  | EventLoopGroup
| *disconnectOnNoReply* (consumer) | If sync is enabled then this option dictates NettyConsumer if it should disconnect where there is no reply to send back. | true | boolean
| *executorService* (consumer) | To use the given EventExecutorGroup. |  | EventExecutorGroup
| *maximumPoolSize* (consumer) | Sets a maximum thread pool size for the netty consumer ordered thread pool. The default size is 2 x cpu_core plus 1. Setting this value to eg 10 will then use 10 threads unless 2 x cpu_core plus 1 is a higher value, which then will override and be used. For example if there are 8 cores, then the consumer thread pool will be 17. This thread pool is used to route messages received from Netty by Camel. We use a separate thread pool to ensure ordering of messages and also in case some messages will block, then nettys worker threads (event loop) wont be affected. |  | int
| *nettyServerBootstrapFactory* (consumer) | To use a custom NettyServerBootstrapFactory |  | NettyServerBootstrapFactory
| *networkInterface* (consumer) | When using UDP then this option can be used to specify a network interface by its name, such as eth0 to join a multicast group. |  | String
| *noReplyLogLevel* (consumer) | If sync is enabled this option dictates NettyConsumer which logging level to use when logging a there is no reply to send back. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverClosedChannelException{zwsp}CaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an java.nio.channels.ClosedChannelException then its logged using this logging level. This is used to avoid logging the closed channel exceptions, as clients can disconnect abruptly and then cause a flood of closed exceptions in the Netty server. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | DEBUG | LoggingLevel
| *serverExceptionCaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an exception then its logged using this logging level. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverInitializerFactory* (consumer) | To use a custom ServerInitializerFactory |  | ServerInitializerFactory
| *usingExecutorService* (consumer) | Whether to use ordered thread pool, to ensure events are processed orderly on the same channel. | true | boolean
| *connectTimeout* (producer) | Time to wait for a socket connection to be available. Value is in milliseconds. | 10000 | int
| *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
| *requestTimeout* (producer) | Allows to use a timeout for the Netty producer when calling a remote server. By default no timeout is in use. The value is in milli seconds, so eg 30000 is 30 seconds. The requestTimeout is using Netty's ReadTimeoutHandler to trigger the timeout. |  | long
| *clientInitializerFactory* (producer) | To use a custom ClientInitializerFactory |  | ClientInitializerFactory
| *correlationManager* (producer) | To use a custom correlation manager to manage how request and reply messages are mapped when using request/reply with the netty producer. This should only be used if you have a way to map requests together with replies such as if there is correlation ids in both the request and reply messages. This can be used if you want to multiplex concurrent messages on the same channel (aka connection) in netty. When doing this you must have a way to correlate the request and reply messages so you can store the right reply on the inflight Camel Exchange before its continued routed. We recommend extending the TimeoutCorrelationManagerSupport when you build custom correlation managers. This provides support for timeout and other complexities you otherwise would need to implement as well. See also the producerPoolEnabled option for more details. |  | NettyCamelStateCorrelationManager
| *lazyChannelCreation* (producer) | Channels can be lazily created to avoid exceptions, if the remote server is not up and running when the Camel producer is started. | true | boolean
| *producerPoolEnabled* (producer) | Whether producer pool is enabled or not. Important: If you turn this off then a single shared connection is used for the producer, also if you are doing request/reply. That means there is a potential issue with interleaved responses if replies comes back out-of-order. Therefore you need to have a correlation id in both the request and reply messages so you can properly correlate the replies to the Camel callback that is responsible for continue processing the message in Camel. To do this you need to implement NettyCamelStateCorrelationManager as correlation manager and configure it via the correlationManager option. See also the correlationManager option for more details. | true | boolean
| *producerPoolMaxActive* (producer) | Sets the cap on the number of objects that can be allocated by the pool (checked out to clients, or idle awaiting checkout) at a given time. Use a negative value for no limit. | -1 | int
| *producerPoolMaxIdle* (producer) | Sets the cap on the number of idle instances in the pool. | 100 | int
| *producerPoolMinEvictableIdle* (producer) | Sets the minimum amount of time (value in millis) an object may sit idle in the pool before it is eligible for eviction by the idle object evictor. | 300000 | long
| *producerPoolMinIdle* (producer) | Sets the minimum number of instances allowed in the producer pool before the evictor thread (if active) spawns new objects. |  | int
| *udpConnectionlessSending* (producer) | This option supports connection less udp sending which is a real fire and forget. A connected udp send receive the PortUnreachableException if no one is listen on the receiving port. | false | boolean
| *useByteBuf* (producer) | If the useByteBuf is true, netty producer will turn the message body into ByteBuf before sending it out. | false | boolean
| *hostnameVerification* ( security) | To enable/disable hostname verification on SSLEngine | false | boolean
| *allowSerializedHeaders* (advanced) | Only used for TCP when transferExchange is true. When set to true, serializable objects in headers and properties will be added to the exchange. Otherwise Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *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
| *channelGroup* (advanced) | To use a explicit ChannelGroup. |  | ChannelGroup
| *nativeTransport* (advanced) | Whether to use native transport instead of NIO. Native transport takes advantage of the host operating system and is only supported on some platforms. You need to add the netty JAR for the host operating system you are using. See more details at: \\http://netty.io/wiki/native-transports.html | false | boolean
| *options* (advanced) | Allows to configure additional netty options using option. as prefix. For example option.child.keepAlive=false to set the netty option child.keepAlive=false. See the Netty documentation for possible options that can be used. |  | Map
| *receiveBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during inbound communication. Size is bytes. | 65536 | int
| *receiveBufferSizePredictor* (advanced) | Configures the buffer size predictor. See details at Jetty documentation and this mail thread. |  | int
| *sendBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during outbound communication. Size is bytes. | 65536 | int
| *transferExchange* (advanced) | Only used for TCP. You can transfer the exchange over the wire instead of just the body. The following fields are transferred: In body, Out body, fault body, In headers, Out headers, fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *udpByteArrayCodec* (advanced) | For UDP only. If enabled the using byte array codec instead of Java serialization protocol. | false | boolean
| *workerCount* (advanced) | When netty works on nio mode, it uses default workerCount parameter from Netty (which is cpu_core_threads x 2). User can use this option to override the default workerCount from Netty. |  | int
| *workerGroup* (advanced) | To use a explicit EventLoopGroup as the boss thread pool. For example to share a thread pool with multiple consumers or producers. By default each consumer or producer has their own worker pool with 2 x cpu count core threads. |  | EventLoopGroup
| *allowDefaultCodec* (codec) | The netty component installs a default codec if both, encoder/decoder is null and textline is false. Setting allowDefaultCodec to false prevents the netty component from installing a default codec as the first element in the filter chain. | true | boolean
| *autoAppendDelimiter* (codec) | Whether or not to auto append missing end delimiter when sending using the textline codec. | true | boolean
| *decoderMaxLineLength* (codec) | The max line length to use for the textline codec. | 1024 | int
| *decoders* (codec) | A list of decoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *delimiter* (codec) | The delimiter to use for the textline codec. Possible values are LINE and NULL. There are 2 enums and the value can be one of: LINE, NULL | LINE | TextLineDelimiter
| *encoders* (codec) | A list of encoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *encoding* (codec) | The encoding (a charset name) to use for the textline codec. If not provided, Camel will use the JVM default Charset. |  | String
| *textline* (codec) | Only used for TCP. If no codec is specified, you can use this flag to indicate a text line based codec; if not specified or the value is false, then Object Serialization is assumed over TCP - however only Strings are allowed to be serialized by default. | false | boolean
| *enabledProtocols* (security) | Which protocols to enable when using SSL | TLSv1,TLSv1.1,TLSv1.2 | String
| *keyStoreFile* (security) | Client side certificate keystore to be used for encryption |  | File
| *keyStoreFormat* (security) | Keystore format to be used for payload encryption. Defaults to JKS if not set |  | String
| *keyStoreResource* (security) | Client side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
| *needClientAuth* (security) | Configures whether the server needs client authentication when using SSL. | false | boolean
| *passphrase* (security) | Password setting to use in order to encrypt/decrypt payloads sent using SSH |  | String
| *securityProvider* (security) | Security provider to be used for payload encryption. Defaults to SunX509 if not set. |  | String
| *ssl* (security) | Setting to specify whether SSL encryption is applied to this endpoint | false | boolean
| *sslClientCertHeaders* (security) | When enabled and in SSL mode, then the Netty consumer will enrich the Camel Message with headers having information about the client certificate such as subject name, issuer name, serial number, and the valid date range. | false | boolean
| *sslContextParameters* (security) | To configure security using SSLContextParameters |  | SSLContextParameters
| *sslHandler* (security) | Reference to a class that could be used to return an SSL Handler |  | SslHandler
| *trustStoreFile* (security) | Server side certificate keystore to be used for encryption |  | File
| *trustStoreResource* (security) | Server side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
| *useGlobalSslContextParameters* (security) | Enable usage of global SSL context parameters. | false | boolean
|===
// component options: END


// endpoint options: START
The Netty endpoint is configured using URI syntax:

----
netty:protocol://host:port
----

with the following path and query parameters:

=== Path Parameters (3 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *protocol* | *Required* The protocol to use which can be tcp or udp. There are 2 enums and the value can be one of: tcp, udp |  | String
| *host* | *Required* The hostname. For the consumer the hostname is localhost or 0.0.0.0. For the producer the hostname is the remote host to connect to |  | String
| *port* | *Required* The host port number |  | int
|===


=== Query Parameters (71 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *disconnect* (common) | Whether or not to disconnect(close) from Netty Channel right after use. Can be used for both consumer and producer. | false | boolean
| *keepAlive* (common) | Setting to ensure socket is not closed due to inactivity | true | boolean
| *reuseAddress* (common) | Setting to facilitate socket multiplexing | true | boolean
| *reuseChannel* (common) | This option allows producers and consumers (in client mode) to reuse the same Netty Channel for the lifecycle of processing the Exchange. This is useful if you need to call a server multiple times in a Camel route and want to use the same network connection. When using this, the channel is not returned to the connection pool until the Exchange is done; or disconnected if the disconnect option is set to true. The reused Channel is stored on the Exchange as an exchange property with the key NettyConstants#NETTY_CHANNEL which allows you to obtain the channel during routing and use it as well. | false | boolean
| *sync* (common) | Setting to set endpoint as one-way or request-response | true | boolean
| *tcpNoDelay* (common) | Setting to improve TCP protocol performance | true | 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
| *broadcast* (consumer) | Setting to choose Multicast over UDP | false | boolean
| *clientMode* (consumer) | If the clientMode is true, netty consumer will connect the address as a TCP client. | false | boolean
| *reconnect* (consumer) | Used only in clientMode in consumer, the consumer will attempt to reconnect on disconnection if this is enabled | true | boolean
| *reconnectInterval* (consumer) | Used if reconnect and clientMode is enabled. The interval in milli seconds to attempt reconnection | 10000 | int
| *backlog* (consumer) | Allows to configure a backlog for netty consumer (server). Note the backlog is just a best effort depending on the OS. Setting this option to a value such as 200, 500 or 1000, tells the TCP stack how long the accept queue can be If this option is not configured, then the backlog depends on OS setting. |  | int
| *bossCount* (consumer) | When netty works on nio mode, it uses default bossCount parameter from Netty, which is 1. User can use this option to override the default bossCount from Netty | 1 | int
| *bossGroup* (consumer) | Set the BossGroup which could be used for handling the new connection of the server side across the NettyEndpoint |  | EventLoopGroup
| *disconnectOnNoReply* (consumer) | If sync is enabled then this option dictates NettyConsumer if it should disconnect where there is no reply to send back. | true | 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. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut |  | ExchangePattern
| *nettyServerBootstrapFactory* (consumer) | To use a custom NettyServerBootstrapFactory |  | NettyServerBootstrapFactory
| *networkInterface* (consumer) | When using UDP then this option can be used to specify a network interface by its name, such as eth0 to join a multicast group. |  | String
| *noReplyLogLevel* (consumer) | If sync is enabled this option dictates NettyConsumer which logging level to use when logging a there is no reply to send back. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverClosedChannelException{zwsp}CaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an java.nio.channels.ClosedChannelException then its logged using this logging level. This is used to avoid logging the closed channel exceptions, as clients can disconnect abruptly and then cause a flood of closed exceptions in the Netty server. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | DEBUG | LoggingLevel
| *serverExceptionCaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an exception then its logged using this logging level. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverInitializerFactory* (consumer) | To use a custom ServerInitializerFactory |  | ServerInitializerFactory
| *usingExecutorService* (consumer) | Whether to use ordered thread pool, to ensure events are processed orderly on the same channel. | true | boolean
| *connectTimeout* (producer) | Time to wait for a socket connection to be available. Value is in milliseconds. | 10000 | int
| *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
| *requestTimeout* (producer) | Allows to use a timeout for the Netty producer when calling a remote server. By default no timeout is in use. The value is in milli seconds, so eg 30000 is 30 seconds. The requestTimeout is using Netty's ReadTimeoutHandler to trigger the timeout. |  | long
| *clientInitializerFactory* (producer) | To use a custom ClientInitializerFactory |  | ClientInitializerFactory
| *correlationManager* (producer) | To use a custom correlation manager to manage how request and reply messages are mapped when using request/reply with the netty producer. This should only be used if you have a way to map requests together with replies such as if there is correlation ids in both the request and reply messages. This can be used if you want to multiplex concurrent messages on the same channel (aka connection) in netty. When doing this you must have a way to correlate the request and reply messages so you can store the right reply on the inflight Camel Exchange before its continued routed. We recommend extending the TimeoutCorrelationManagerSupport when you build custom correlation managers. This provides support for timeout and other complexities you otherwise would need to implement as well. See also the producerPoolEnabled option for more details. |  | NettyCamelStateCorrelationManager
| *lazyChannelCreation* (producer) | Channels can be lazily created to avoid exceptions, if the remote server is not up and running when the Camel producer is started. | true | boolean
| *producerPoolEnabled* (producer) | Whether producer pool is enabled or not. Important: If you turn this off then a single shared connection is used for the producer, also if you are doing request/reply. That means there is a potential issue with interleaved responses if replies comes back out-of-order. Therefore you need to have a correlation id in both the request and reply messages so you can properly correlate the replies to the Camel callback that is responsible for continue processing the message in Camel. To do this you need to implement NettyCamelStateCorrelationManager as correlation manager and configure it via the correlationManager option. See also the correlationManager option for more details. | true | boolean
| *producerPoolMaxActive* (producer) | Sets the cap on the number of objects that can be allocated by the pool (checked out to clients, or idle awaiting checkout) at a given time. Use a negative value for no limit. | -1 | int
| *producerPoolMaxIdle* (producer) | Sets the cap on the number of idle instances in the pool. | 100 | int
| *producerPoolMinEvictableIdle* (producer) | Sets the minimum amount of time (value in millis) an object may sit idle in the pool before it is eligible for eviction by the idle object evictor. | 300000 | long
| *producerPoolMinIdle* (producer) | Sets the minimum number of instances allowed in the producer pool before the evictor thread (if active) spawns new objects. |  | int
| *udpConnectionlessSending* (producer) | This option supports connection less udp sending which is a real fire and forget. A connected udp send receive the PortUnreachableException if no one is listen on the receiving port. | false | boolean
| *useByteBuf* (producer) | If the useByteBuf is true, netty producer will turn the message body into ByteBuf before sending it out. | false | boolean
| *hostnameVerification* ( security) | To enable/disable hostname verification on SSLEngine | false | boolean
| *allowSerializedHeaders* (advanced) | Only used for TCP when transferExchange is true. When set to true, serializable objects in headers and properties will be added to the exchange. Otherwise Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *channelGroup* (advanced) | To use a explicit ChannelGroup. |  | ChannelGroup
| *nativeTransport* (advanced) | Whether to use native transport instead of NIO. Native transport takes advantage of the host operating system and is only supported on some platforms. You need to add the netty JAR for the host operating system you are using. See more details at: \\http://netty.io/wiki/native-transports.html | false | boolean
| *options* (advanced) | Allows to configure additional netty options using option. as prefix. For example option.child.keepAlive=false to set the netty option child.keepAlive=false. See the Netty documentation for possible options that can be used. |  | Map
| *receiveBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during inbound communication. Size is bytes. | 65536 | int
| *receiveBufferSizePredictor* (advanced) | Configures the buffer size predictor. See details at Jetty documentation and this mail thread. |  | int
| *sendBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during outbound communication. Size is bytes. | 65536 | int
| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used | false | boolean
| *transferExchange* (advanced) | Only used for TCP. You can transfer the exchange over the wire instead of just the body. The following fields are transferred: In body, Out body, fault body, In headers, Out headers, fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *udpByteArrayCodec* (advanced) | For UDP only. If enabled the using byte array codec instead of Java serialization protocol. | false | boolean
| *workerCount* (advanced) | When netty works on nio mode, it uses default workerCount parameter from Netty (which is cpu_core_threads x 2). User can use this option to override the default workerCount from Netty. |  | int
| *workerGroup* (advanced) | To use a explicit EventLoopGroup as the boss thread pool. For example to share a thread pool with multiple consumers or producers. By default each consumer or producer has their own worker pool with 2 x cpu count core threads. |  | EventLoopGroup
| *allowDefaultCodec* (codec) | The netty component installs a default codec if both, encoder/decoder is null and textline is false. Setting allowDefaultCodec to false prevents the netty component from installing a default codec as the first element in the filter chain. | true | boolean
| *autoAppendDelimiter* (codec) | Whether or not to auto append missing end delimiter when sending using the textline codec. | true | boolean
| *decoderMaxLineLength* (codec) | The max line length to use for the textline codec. | 1024 | int
| *decoders* (codec) | A list of decoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *delimiter* (codec) | The delimiter to use for the textline codec. Possible values are LINE and NULL. There are 2 enums and the value can be one of: LINE, NULL | LINE | TextLineDelimiter
| *encoders* (codec) | A list of encoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *encoding* (codec) | The encoding (a charset name) to use for the textline codec. If not provided, Camel will use the JVM default Charset. |  | String
| *textline* (codec) | Only used for TCP. If no codec is specified, you can use this flag to indicate a text line based codec; if not specified or the value is false, then Object Serialization is assumed over TCP - however only Strings are allowed to be serialized by default. | false | boolean
| *enabledProtocols* (security) | Which protocols to enable when using SSL | TLSv1,TLSv1.1,TLSv1.2 | String
| *keyStoreFile* (security) | Client side certificate keystore to be used for encryption |  | File
| *keyStoreFormat* (security) | Keystore format to be used for payload encryption. Defaults to JKS if not set |  | String
| *keyStoreResource* (security) | Client side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
| *needClientAuth* (security) | Configures whether the server needs client authentication when using SSL. | false | boolean
| *passphrase* (security) | Password setting to use in order to encrypt/decrypt payloads sent using SSH |  | String
| *securityProvider* (security) | Security provider to be used for payload encryption. Defaults to SunX509 if not set. |  | String
| *ssl* (security) | Setting to specify whether SSL encryption is applied to this endpoint | false | boolean
| *sslClientCertHeaders* (security) | When enabled and in SSL mode, then the Netty consumer will enrich the Camel Message with headers having information about the client certificate such as subject name, issuer name, serial number, and the valid date range. | false | boolean
| *sslContextParameters* (security) | To configure security using SSLContextParameters |  | SSLContextParameters
| *sslHandler* (security) | Reference to a class that could be used to return an SSL Handler |  | SslHandler
| *trustStoreFile* (security) | Server side certificate keystore to be used for encryption |  | File
| *trustStoreResource* (security) | Server side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
|===
// endpoint options: END



== Registry based Options

Codec Handlers and SSL Keystores can be enlisted in the Registry, such as in the Spring XML file.
The values that could be passed in, are the following:

[width=""100%"",cols=""10%,90%"",options=""header"",]
|===
|Name |Description

|`passphrase` |password setting to use in order to encrypt/decrypt payloads sent using
SSH

|`keyStoreFormat` |keystore format to be used for payload encryption. Defaults to ""JKS"" if
not set

|`securityProvider` |Security provider to be used for payload encryption. Defaults to
""SunX509"" if not set.

|`keyStoreFile` |*deprecated:* Client side certificate keystore to be used for encryption

|`trustStoreFile` |*deprecated:* Server side certificate keystore to be used for encryption

|`keyStoreResource` |Client side certificate keystore to be used for
encryption. Is loaded by default from classpath, but you can prefix with
`""classpath:""`, `""file:""`, or `""http:""` to load the resource from
different systems.

|`trustStoreResource` |Server side certificate keystore to be used for
encryption. Is loaded by default from classpath, but you can prefix with
`""classpath:""`, `""file:""`, or `""http:""` to load the resource from
different systems.

|`sslHandler` |Reference to a class that could be used to return an SSL Handler

|`encoder` |A custom `ChannelHandler` class that can be used to perform special
marshalling of outbound payloads. Must override
io.netty.channel.ChannelInboundHandlerAdapter.

|`encoders` |A list of encoders to be used. You can use a String which have values
separated by comma, and have the values be looked up in the
Registry. Just remember to prefix the value with #
so Camel knows it should lookup.

|`decoder` |A custom `ChannelHandler` class that can be used to perform special
marshalling of inbound payloads. Must override
io.netty.channel.ChannelOutboundHandlerAdapter.

|`decoders` |A list of decoders to be used. You can use a String which have values
separated by comma, and have the values be looked up in the
Registry. Just remember to prefix the value with #
so Camel knows it should lookup.
|===

[NOTE]
====
Read below about using non shareable encoders/decoders.
====

=== Using non shareable encoders or decoders

If your encoders or decoders are not shareable (e.g. they don't have the
@Shareable class annotation), then your encoder/decoder must implement
the `org.apache.camel.component.netty.ChannelHandlerFactory` interface,
and return a new instance in the `newChannelHandler` method. This is to
ensure the encoder/decoder can safely be used. If this is not the case,
then the Netty component will log a WARN when an endpoint is created.

The Netty component offers a
`org.apache.camel.component.netty.ChannelHandlerFactories` factory
class, that has a number of commonly used methods.

== Sending Messages to/from a Netty endpoint

=== Netty Producer

In Producer mode, the component provides the ability to send payloads to
a socket endpoint using either TCP or UDP protocols (with optional SSL support).

The producer mode supports both one-way and request-response based operations.

=== Netty Consumer

In Consumer mode, the component provides the ability to:

* listen on a specified socket using either TCP or UDP protocols (with
optional SSL support),
* receive requests on the socket using text/xml, binary and serialized
object based payloads and
* send them along on a route as message exchanges.

The consumer mode supports both one-way and request-response based
operations.

== Examples

=== A UDP Netty endpoint using Request-Reply and serialized object payload

Note that Object serialization is not allowed by default, and so a decoder must be configured.

[source,java]
----
@BindToRegistry(""decoder"")
public ChannelHandler getDecoder() throws Exception {
    return new DefaultChannelHandlerFactory() {
        @Override
        public ChannelHandler newChannelHandler() {
            return new DatagramPacketObjectDecoder(ClassResolvers.weakCachingResolver(null));
        }
    };
}

RouteBuilder builder = new RouteBuilder() {
  public void configure() {
    from(""netty:udp://0.0.0.0:5155?sync=true&decoders=#decoder"")
      .process(new Processor() {
         public void process(Exchange exchange) throws Exception {
           Poetry poetry = (Poetry) exchange.getIn().getBody();
           // Process poetry in some way
           exchange.getOut().setBody(""Message received);
         }
       }
    }
};
----

=== A TCP based Netty consumer endpoint using One-way communication

[source,java]
----
RouteBuilder builder = new RouteBuilder() {
  public void configure() {
       from(""netty:tcp://0.0.0.0:5150"")
           .to(""mock:result"");
  }
};
----

=== An SSL/TCP based Netty consumer endpoint using Request-Reply communication

[[Netty-UsingtheJSSEConfigurationUtility]]
Using the JSSE Configuration Utility

The Netty component supports SSL/TLS configuration
through the xref:manual::camel-configuration-utilities.adoc[Camel JSSE
Configuration Utility].  This utility greatly decreases the amount of
component specific code you need to write and is configurable at the
endpoint and component levels.  The following examples demonstrate how
to use the utility with the Netty component.

[[Netty-Programmaticconfigurationofthecomponent]]
Programmatic configuration of the component

[source,java]
----
KeyStoreParameters ksp = new KeyStoreParameters();
ksp.setResource(""/users/home/server/keystore.jks"");
ksp.setPassword(""keystorePassword"");

KeyManagersParameters kmp = new KeyManagersParameters();
kmp.setKeyStore(ksp);
kmp.setKeyPassword(""keyPassword"");

SSLContextParameters scp = new SSLContextParameters();
scp.setKeyManagers(kmp);

NettyComponent nettyComponent = getContext().getComponent(""netty"", NettyComponent.class);
nettyComponent.setSslContextParameters(scp);
----

[[Netty-SpringDSLbasedconfigurationofendpoint]]
Spring DSL based configuration of endpoint

[source,xml]
----
...
  <camel:sslContextParameters
      id=""sslContextParameters"">
    <camel:keyManagers
        keyPassword=""keyPassword"">
      <camel:keyStore
          resource=""/users/home/server/keystore.jks""
          password=""keystorePassword""/>
    </camel:keyManagers>
  </camel:sslContextParameters>...
...
  <to uri=""netty:tcp://0.0.0.0:5150?sync=true&ssl=true&sslContextParameters=#sslContextParameters""/>
...
----

[[Netty-UsingBasicSSLTLSconfigurationontheJettyComponent]]
Using Basic SSL/TLS configuration on the Jetty Component

[source,java]
----
Registry registry = context.getRegistry();
registry.bind(""password"", ""changeit"");
registry.bind(""ksf"", new File(""src/test/resources/keystore.jks""));
registry.bind(""tsf"", new File(""src/test/resources/keystore.jks""));

context.addRoutes(new RouteBuilder() {
  public void configure() {
      String netty_ssl_endpoint =
         ""netty:tcp://0.0.0.0:5150?sync=true&ssl=true&passphrase=#password""
         + ""&keyStoreFile=#ksf&trustStoreFile=#tsf"";
      String return_string =
         ""When You Go Home, Tell Them Of Us And Say,""
         + ""For Your Tomorrow, We Gave Our Today."";

      from(netty_ssl_endpoint)
       .process(new Processor() {
          public void process(Exchange exchange) throws Exception {
            exchange.getOut().setBody(return_string);
          }
       }
  }
});
----

[[Netty-GettingaccesstoSSLSessionandtheclientcertificate]]
Getting access to SSLSession and the client certificate

You can get access to the `javax.net.ssl.SSLSession` if you eg need to
get details about the client certificate. When `ssl=true` then the
xref:netty-component.adoc[Netty] component will store the `SSLSession` as a
header on the Camel Message as shown below:

[source,java]
----
SSLSession session = exchange.getIn().getHeader(NettyConstants.NETTY_SSL_SESSION, SSLSession.class);
// get the first certificate which is client certificate
javax.security.cert.X509Certificate cert = session.getPeerCertificateChain()[0];
Principal principal = cert.getSubjectDN();
----

Remember to set `needClientAuth=true` to authenticate the client,
otherwise `SSLSession` cannot access information about the client
certificate, and you may get an exception
`javax.net.ssl.SSLPeerUnverifiedException: peer not authenticated`. You
may also get this exception if the client certificate is expired or not
valid etc.

[TIP]
====
The option `sslClientCertHeaders` can be set to `true` which then
enriches the Camel Message with headers having
details about the client certificate. For example the subject name is
readily available in the header `CamelNettySSLClientCertSubjectName`.
====

=== Using Multiple Codecs

In certain cases it may be necessary to add chains of encoders and
decoders to the netty pipeline. To add multpile codecs to a camel netty
endpoint the 'encoders' and 'decoders' uri parameters should be used.
Like the 'encoder' and 'decoder' parameters they are used to supply
references (lists of ChannelUpstreamHandlers and
ChannelDownstreamHandlers) that should be added to the pipeline. Note
that if encoders is specified then the encoder param will be ignored,
similarly for decoders and the decoder param.

[NOTE]
====
Read further above about using non shareable encoders/decoders.
====

The lists of codecs need to be added to the Camel's registry so they can
be resolved when the endpoint is created.

[source,java]
----
ChannelHandlerFactory lengthDecoder = ChannelHandlerFactories.newLengthFieldBasedFrameDecoder(1048576, 0, 4, 0, 4);

StringDecoder stringDecoder = new StringDecoder();
registry.bind(""length-decoder"", lengthDecoder);
registry.bind(""string-decoder"", stringDecoder);

LengthFieldPrepender lengthEncoder = new LengthFieldPrepender(4);
StringEncoder stringEncoder = new StringEncoder();
registry.bind(""length-encoder"", lengthEncoder);
registry.bind(""string-encoder"", stringEncoder);

List<ChannelHandler> decoders = new ArrayList<ChannelHandler>();
decoders.add(lengthDecoder);
decoders.add(stringDecoder);

List<ChannelHandler> encoders = new ArrayList<ChannelHandler>();
encoders.add(lengthEncoder);
encoders.add(stringEncoder);

registry.bind(""encoders"", encoders);
registry.bind(""decoders"", decoders);
----

Spring's native collections support can be used to specify the codec
lists in an application context

[source,xml]
----
<util:list id=""decoders"" list-class=""java.util.LinkedList"">
        <bean class=""org.apache.camel.component.netty.ChannelHandlerFactories"" factory-method=""newLengthFieldBasedFrameDecoder"">
            <constructor-arg value=""1048576""/>
            <constructor-arg value=""0""/>
            <constructor-arg value=""4""/>
            <constructor-arg value=""0""/>
            <constructor-arg value=""4""/>
        </bean>
        <bean class=""io.netty.handler.codec.string.StringDecoder""/>
    </util:list>

    <util:list id=""encoders"" list-class=""java.util.LinkedList"">
        <bean class=""io.netty.handler.codec.LengthFieldPrepender"">
            <constructor-arg value=""4""/>
        </bean>
        <bean class=""io.netty.handler.codec.string.StringEncoder""/>
    </util:list>

    <bean id=""length-encoder"" class=""io.netty.handler.codec.LengthFieldPrepender"">
        <constructor-arg value=""4""/>
    </bean>
    <bean id=""string-encoder"" class=""io.netty.handler.codec.string.StringEncoder""/>

    <bean id=""length-decoder"" class=""org.apache.camel.component.netty.ChannelHandlerFactories"" factory-method=""newLengthFieldBasedFrameDecoder"">
        <constructor-arg value=""1048576""/>
        <constructor-arg value=""0""/>
        <constructor-arg value=""4""/>
        <constructor-arg value=""0""/>
        <constructor-arg value=""4""/>
    </bean>
    <bean id=""string-decoder"" class=""io.netty.handler.codec.string.StringDecoder""/>
----

The bean names can then be used in netty endpoint definitions either as
a comma separated list or contained in a List e.g.

[source,java]
----
 from(""direct:multiple-codec"").to(""netty:tcp://0.0.0.0:{{port}}?encoders=#encoders&sync=false"");

 from(""netty:tcp://0.0.0.0:{{port}}?decoders=#length-decoder,#string-decoder&sync=false"").to(""mock:multiple-codec"");
----

or via XML.

[source,xml]
----
<camelContext id=""multiple-netty-codecs-context"" xmlns=""http://camel.apache.org/schema/spring"">
    <route>
        <from uri=""direct:multiple-codec""/>
        <to uri=""netty:tcp://0.0.0.0:5150?encoders=#encoders&amp;sync=false""/>
    </route>
    <route>
        <from uri=""netty:tcp://0.0.0.0:5150?decoders=#length-decoder,#string-decoder&amp;sync=false""/>
        <to uri=""mock:multiple-codec""/>
    </route>
</camelContext>
----

== Closing Channel When Complete

When acting as a server you sometimes want to close the channel when,
for example, a client conversion is finished. +
 You can do this by simply setting the endpoint option
`disconnect=true`.

However you can also instruct Camel on a per message basis as follows. +
 To instruct Camel to close the channel, you should add a header with
the key `CamelNettyCloseChannelWhenComplete` set to a boolean `true`
value. +
 For instance, the example below will close the channel after it has
written the bye message back to the client:

[source,java]
----
from(""netty:tcp://0.0.0.0:8080"").process(new Processor() {
    public void process(Exchange exchange) throws Exception {
        String body = exchange.getIn().getBody(String.class);
        exchange.getOut().setBody(""Bye "" + body);
        // some condition which determines if we should close
        if (close) {
            exchange.getOut().setHeader(NettyConstants.NETTY_CLOSE_CHANNEL_WHEN_COMPLETE, true);
        }
    }
});
----

[[Netty-Addingcustomchannelpipelinefactoriestogaincompletecontroloveracreatedpipeline]]
Adding custom channel pipeline factories to gain complete control over a created pipeline

== Custom pipeline

Custom channel pipelines provide complete control to the user over the
handler/interceptor chain by inserting custom handler(s), encoder(s) &
decoder(s) without having to specify them in the Netty Endpoint URL in a
very simple way.

In order to add a custom pipeline, a custom channel pipeline factory
must be created and registered with the context via the context registry
(Registry, or the camel-spring ApplicationContextRegistry etc).

A custom pipeline factory must be constructed as follows

* A Producer linked channel pipeline factory must extend the abstract
class `ClientPipelineFactory`.
* A Consumer linked channel pipeline factory must extend the abstract
class `ServerInitializerFactory`.
* The classes should override the initChannel() method in order to
insert custom handler(s), encoder(s) and decoder(s). Not overriding the
`initChannel()` method creates a pipeline with no handlers, encoders or
decoders wired to the pipeline.

The example below shows how ServerInitializerFactory factory may be
created

=== Using custom pipeline factory

[source,java]
----
public class SampleServerInitializerFactory extends ServerInitializerFactory {
    private int maxLineSize = 1024;

    protected void initChannel(Channel ch) throws Exception {
        ChannelPipeline channelPipeline = ch.pipeline();

        channelPipeline.addLast(""encoder-SD"", new StringEncoder(CharsetUtil.UTF_8));
        channelPipeline.addLast(""decoder-DELIM"", new DelimiterBasedFrameDecoder(maxLineSize, true, Delimiters.lineDelimiter()));
        channelPipeline.addLast(""decoder-SD"", new StringDecoder(CharsetUtil.UTF_8));
        // here we add the default Camel ServerChannelHandler for the consumer, to allow Camel to route the message etc.
        channelPipeline.addLast(""handler"", new ServerChannelHandler(consumer));
    }
}
----

The custom channel pipeline factory can then be added to the registry
and instantiated/utilized on a camel route in the following way

[source,java]
----
Registry registry = camelContext.getRegistry();
ServerInitializerFactory factory = new TestServerInitializerFactory();
registry.bind(""spf"", factory);
context.addRoutes(new RouteBuilder() {
  public void configure() {
      String netty_ssl_endpoint =
         ""netty:tcp://0.0.0.0:5150?serverInitializerFactory=#spf""
      String return_string =
         ""When You Go Home, Tell Them Of Us And Say,""
         + ""For Your Tomorrow, We Gave Our Today."";

      from(netty_ssl_endpoint)
       .process(new Processor() {
          public void process(Exchange exchange) throws Exception {
            exchange.getOut().setBody(return_string);
          }
       }
  }
});
----

== Reusing Netty boss and worker thread pools

Netty has two kind of thread pools: boss and worker. By default each
Netty consumer and producer has their private thread pools. If you want
to reuse these thread pools among multiple consumers or producers then
the thread pools must be created and enlisted in the
Registry.

For example using Spring XML we can create a shared worker thread pool
using the `NettyWorkerPoolBuilder` with 2 worker threads as shown below:

[source,xml]
----
<!-- use the worker pool builder to help create the shared thread pool -->
<bean id=""poolBuilder"" class=""org.apache.camel.component.netty.NettyWorkerPoolBuilder"">
  <property name=""workerCount"" value=""2""/>
</bean>

<!-- the shared worker thread pool -->
<bean id=""sharedPool"" class=""org.jboss.netty.channel.socket.nio.WorkerPool""
      factory-bean=""poolBuilder"" factory-method=""build"" destroy-method=""shutdown"">
</bean>
----

[TIP]
====
For boss thread pool there is a
`org.apache.camel.component.netty.NettyServerBossPoolBuilder` builder
for Netty consumers, and a
`org.apache.camel.component.netty.NettyClientBossPoolBuilder` for the
Netty producers.
====

Then in the Camel routes we can refer to this worker pools by
configuring the `workerPool` option in the URI as shown below:

[source,xml]
----
<route>
  <from uri=""netty:tcp://0.0.0.0:5021?textline=true&amp;sync=true&amp;workerPool=#sharedPool&amp;usingExecutorService=false""/>
  <to uri=""log:result""/>
  ...
</route>
----

And if we have another route we can refer to the shared worker pool:

[source,xml]
----
<route>
  <from uri=""netty:tcp://0.0.0.0:5022?textline=true&amp;sync=true&amp;workerPool=#sharedPool&amp;usingExecutorService=false""/>
  <to uri=""log:result""/>
  ...
</route>
----

and so forth.

== Multiplexing concurrent messages over a single connection with request/reply

When using Netty for request/reply messaging via the netty producer then by default each
message is sent via a non-shared connection (pooled). This ensures that replies are
automatic being able to map to the correct request thread for further routing in Camel.
In other words correlation between request/reply messages happens out-of-the-box because
the replies comes back on the same connection that was used for sending the request;
and this connection is not shared with others. When the response comes back, the connection
is returned back to the connection pool, where it can be reused by others.

However if you want to multiplex concurrent request/responses on a single shared connection,
then you need to turn off the connection pooling by setting `producerPoolEnabled=false`.
Now this means there is a potential issue with interleaved responses if replies comes back out-of-order.
Therefore you need to have a correlation id in both the request and reply messages so you can properly
correlate the replies to the Camel callback that is responsible for continue processing the message in Camel.
To do this you need to implement `NettyCamelStateCorrelationManager` as correlation manager and configure
it via the `correlationManager=#myManager` option.

[NOTE]
====
We recommend extending the `TimeoutCorrelationManagerSupport` when you build custom correlation managers.
This provides support for timeout and other complexities you otherwise would need to implement as well.
====

You can find an example with the Apache Camel source code in the examples directory
under the `camel-example-netty-custom-correlation` directory.


include::{page-component-version}@camel-spring-boot::page$netty-starter.adoc[]
",12512,False,2346.278836494685,median
"#include <glm/integer.hpp>
#include <glm/vector_relational.hpp>
#include <glm/gtc/vec1.hpp>
#include <vector>
#include <ctime>
#include <cstdio>

enum result
{
	SUCCESS,
	FAIL,
	ASSERT,
	STATIC_ASSERT
};

namespace bitfieldInsert
{
	template<typename genType>
	struct type
	{
		genType		Base;
		genType		Insert;
		int			Offset;
		int			Bits;
		genType		Return;
	};

	typedef type<glm::uint> typeU32;

	typeU32 const Data32[] =
	{
		{0x00000000, 0xffffffff,  0, 32, 0xffffffff},
		{0x00000000, 0xffffffff,  0, 31, 0x7fffffff},
		{0x00000000, 0xffffffff,  0,  0, 0x00000000},
		{0xff000000, 0x0000ff00,  8,  8, 0xff00ff00},
		{0xffff0000, 0x0000ffff, 16, 16, 0x00000000},
		{0x0000ffff, 0xffff0000, 16, 16, 0xffffffff}
	};

	static int test()
	{
		int Error = 0;
		glm::uint count = sizeof(Data32) / sizeof(typeU32);
		
		for(glm::uint i = 0; i < count; ++i)
		{
			glm::uint Return = glm::bitfieldInsert(
				Data32[i].Base,
				Data32[i].Insert,
				Data32[i].Offset,
				Data32[i].Bits);

			Error += Data32[i].Return == Return ? 0 : 1;
		}
		
		return Error;
	}
}//bitfieldInsert

namespace bitfieldExtract
{
	template<typename genType>
	struct type
	{
		genType		Value;
		int			Offset;
		int			Bits;
		genType		Return;
		result		Result;
	};

	typedef type<glm::uint> typeU32;

	typeU32 const Data32[] =
	{
		{0xffffffff, 0,32, 0xffffffff, SUCCESS},
		{0xffffffff, 8, 0, 0x00000000, SUCCESS},
		{0x00000000, 0,32, 0x00000000, SUCCESS},
		{0x0f0f0f0f, 0,32, 0x0f0f0f0f, SUCCESS},
		{0x00000000, 8, 0, 0x00000000, SUCCESS},
		{0x80000000,31, 1, 0x00000001, SUCCESS},
		{0x7fffffff,31, 1, 0x00000000, SUCCESS},
		{0x00000300, 8, 8, 0x00000003, SUCCESS},
		{0x0000ff00, 8, 8, 0x000000ff, SUCCESS},
		{0xfffffff0, 0, 5, 0x00000010, SUCCESS},
		{0x000000ff, 1, 3, 0x00000007, SUCCESS},
		{0x000000ff, 0, 3, 0x00000007, SUCCESS},
		{0x00000000, 0, 2, 0x00000000, SUCCESS},
		{0xffffffff, 0, 8, 0x000000ff, SUCCESS},
		{0xffff0000,16,16, 0x0000ffff, SUCCESS},
		{0xfffffff0, 0, 8, 0x00000000, FAIL},
		{0xffffffff,16,16, 0x00000000, FAIL},
		//{0xffffffff,32, 1, 0x00000000, ASSERT}, // Throw an assert 
		//{0xffffffff, 0,33, 0x00000000, ASSERT}, // Throw an assert 
		//{0xffffffff,16,16, 0x00000000, ASSERT}, // Throw an assert 
	};

	static int test()
	{
		int Error = 0;

		glm::uint count = sizeof(Data32) / sizeof(typeU32);

		for(glm::uint i = 0; i < count; ++i)
		{
			glm::uint Return = glm::bitfieldExtract(
				Data32[i].Value, 
				Data32[i].Offset, 
				Data32[i].Bits);
			
			bool Compare = Data32[i].Return == Return;

			if(Data32[i].Result == SUCCESS && Compare)
				continue;
			else if(Data32[i].Result == FAIL && !Compare)
				continue;

			Error += 1;
		}

		return Error;
	}
}//extractField

namespace bitfieldReverse
{
/*
	GLM_FUNC_QUALIFIER unsigned int bitfieldReverseLoop(unsigned int v)
	{
		unsigned int Result(0);
		unsigned int const BitSize = static_cast<unsigned int>(sizeof(unsigned int) * 8);
		for(unsigned int i = 0; i < BitSize; ++i)
		{
			unsigned int const BitSet(v & (static_cast<unsigned int>(1) << i));
			unsigned int const BitFirst(BitSet >> i);
			Result |= BitFirst << (BitSize - 1 - i);
		}
		return Result;
	}

	GLM_FUNC_QUALIFIER glm::uint64_t bitfieldReverseLoop(glm::uint64_t v)
	{
		glm::uint64_t Result(0);
		glm::uint64_t const BitSize = static_cast<glm::uint64_t>(sizeof(unsigned int) * 8);
		for(glm::uint64_t i = 0; i < BitSize; ++i)
		{
			glm::uint64_t const BitSet(v & (static_cast<glm::uint64_t>(1) << i));
			glm::uint64_t const BitFirst(BitSet >> i);
			Result |= BitFirst << (BitSize - 1 - i);
		}
		return Result;
	}
*/
	template<glm::length_t L, typename T, glm::precision P, template<glm::length_t, typename, glm::precision> class vecType>
	GLM_FUNC_QUALIFIER vecType<L, T, P> bitfieldReverseLoop(vecType<L, T, P> const & v)
	{
		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, ""'bitfieldReverse' only accept integer values"");

		vecType<L, T, P> Result(0);
		T const BitSize = static_cast<T>(sizeof(T) * 8);
		for(T i = 0; i < BitSize; ++i)
		{
			vecType<L, T, P> const BitSet(v & (static_cast<T>(1) << i));
			vecType<L, T, P> const BitFirst(BitSet >> i);
			Result |= BitFirst << (BitSize - 1 - i);
		}
		return Result;
	}

	template<typename T>
	GLM_FUNC_QUALIFIER T bitfieldReverseLoop(T v)
	{
		return bitfieldReverseLoop(glm::vec<1, T>(v)).x;
	}

	GLM_FUNC_QUALIFIER glm::uint32_t bitfieldReverseUint32(glm::uint32_t x)
	{
		x = (x & 0x55555555) <<  1 | (x & 0xAAAAAAAA) >>  1;
		x = (x & 0x33333333) <<  2 | (x & 0xCCCCCCCC) >>  2;
		x = (x & 0x0F0F0F0F) <<  4 | (x & 0xF0F0F0F0) >>  4;
		x = (x & 0x00FF00FF) <<  8 | (x & 0xFF00FF00) >>  8;
		x = (x & 0x0000FFFF) << 16 | (x & 0xFFFF0000) >> 16;
		return x;
	}

	GLM_FUNC_QUALIFIER glm::uint64_t bitfieldReverseUint64(glm::uint64_t x)
	{
		x = (x & 0x5555555555555555) <<  1 | (x & 0xAAAAAAAAAAAAAAAA) >>  1;
		x = (x & 0x3333333333333333) <<  2 | (x & 0xCCCCCCCCCCCCCCCC) >>  2;
		x = (x & 0x0F0F0F0F0F0F0F0F) <<  4 | (x & 0xF0F0F0F0F0F0F0F0) >>  4;
		x = (x & 0x00FF00FF00FF00FF) <<  8 | (x & 0xFF00FF00FF00FF00) >>  8;
		x = (x & 0x0000FFFF0000FFFF) << 16 | (x & 0xFFFF0000FFFF0000) >> 16;
		x = (x & 0x00000000FFFFFFFF) << 32 | (x & 0xFFFFFFFF00000000) >> 32;
		return x;
	}

	template<bool EXEC = false>
	struct compute_bitfieldReverseStep
	{
		template<glm::length_t L, typename T, glm::precision P, template<glm::length_t, typename, glm::precision> class vecType>
		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & v, T, T)
		{
			return v;
		}
	};

	template<>
	struct compute_bitfieldReverseStep<true>
	{
		template<glm::length_t L, typename T, glm::precision P, template<glm::length_t, typename, glm::precision> class vecType>
		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & v, T Mask, T Shift)
		{
			return (v & Mask) << Shift | (v & (~Mask)) >> Shift;
		}
	};

	template<glm::length_t L, typename T, glm::precision P, template<glm::length_t, typename, glm::precision> class vecType>
	GLM_FUNC_QUALIFIER vecType<L, T, P> bitfieldReverseOps(vecType<L, T, P> const & v)
	{
		vecType<L, T, P> x(v);
		x = compute_bitfieldReverseStep<sizeof(T) * 8 >=  2>::call(x, T(0x5555555555555555ull), static_cast<T>( 1));
		x = compute_bitfieldReverseStep<sizeof(T) * 8 >=  4>::call(x, T(0x3333333333333333ull), static_cast<T>( 2));
		x = compute_bitfieldReverseStep<sizeof(T) * 8 >=  8>::call(x, T(0x0F0F0F0F0F0F0F0Full), static_cast<T>( 4));
		x = compute_bitfieldReverseStep<sizeof(T) * 8 >= 16>::call(x, T(0x00FF00FF00FF00FFull), static_cast<T>( 8));
		x = compute_bitfieldReverseStep<sizeof(T) * 8 >= 32>::call(x, T(0x0000FFFF0000FFFFull), static_cast<T>(16));
		x = compute_bitfieldReverseStep<sizeof(T) * 8 >= 64>::call(x, T(0x00000000FFFFFFFFull), static_cast<T>(32));
		return x;
	}

	template<typename genType>
	GLM_FUNC_QUALIFIER genType bitfieldReverseOps(genType x)
	{
		return bitfieldReverseOps(glm::vec<1, genType, glm::defaultp>(x)).x;
	}

	template<typename genType>
	struct type
	{
		genType		Value;
		genType		Return;
		result		Result;
	};

	typedef type<glm::uint> typeU32;

	typeU32 const Data32[] =
	{
		{0x00000001, 0x80000000, SUCCESS},
		{0x0000000f, 0xf0000000, SUCCESS},
		{0x000000ff, 0xff000000, SUCCESS},
		{0xf0000000, 0x0000000f, SUCCESS},
		{0xff000000, 0x000000ff, SUCCESS},
		{0xffffffff, 0xffffffff, SUCCESS},
		{0x00000000, 0x00000000, SUCCESS}
	};

	typedef type<glm::uint64> typeU64;

	typeU64 const Data64[] =
	{
		{0x00000000000000ff, 0xff00000000000000, SUCCESS},
		{0x000000000000000f, 0xf000000000000000, SUCCESS},
		{0xf000000000000000, 0x000000000000000f, SUCCESS},
		{0xffffffffffffffff, 0xffffffffffffffff, SUCCESS},
		{0x0000000000000000, 0x0000000000000000, SUCCESS}
	};

	static int test32_bitfieldReverse()
	{
		int Error = 0;
		std::size_t const Count = sizeof(Data32) / sizeof(typeU32);
		
		for(std::size_t i = 0; i < Count; ++i)
		{
			glm::uint Return = glm::bitfieldReverse(Data32[i].Value);
			
			bool Compare = Data32[i].Return == Return;
			
			if(Data32[i].Result == SUCCESS)
				Error += Compare ? 0 : 1;
			else
				Error += Compare ? 1 : 0;
		}
		
		return Error;
	}

	static int test32_bitfieldReverseLoop()
	{
		int Error = 0;
		std::size_t const Count = sizeof(Data32) / sizeof(typeU32);
		
		for(std::size_t i = 0; i < Count; ++i)
		{
			glm::uint Return = bitfieldReverseLoop(Data32[i].Value);
			
			bool Compare = Data32[i].Return == Return;
			
			if(Data32[i].Result == SUCCESS)
				Error += Compare ? 0 : 1;
			else
				Error += Compare ? 1 : 0;
		}
		
		return Error;
	}

	static int test32_bitfieldReverseUint32()
	{
		int Error = 0;
		std::size_t const Count = sizeof(Data32) / sizeof(typeU32);
		
		for(std::size_t i = 0; i < Count; ++i)
		{
			glm::uint Return = bitfieldReverseUint32(Data32[i].Value);
			
			bool Compare = Data32[i].Return == Return;
			
			if(Data32[i].Result == SUCCESS)
				Error += Compare ? 0 : 1;
			else
				Error += Compare ? 1 : 0;
		}
		
		return Error;
	}

	static int test32_bitfieldReverseOps()
	{
		int Error = 0;
		std::size_t const Count = sizeof(Data32) / sizeof(typeU32);
		
		for(std::size_t i = 0; i < Count; ++i)
		{
			glm::uint Return = bitfieldReverseOps(Data32[i].Value);
			
			bool Compare = Data32[i].Return == Return;
			
			if(Data32[i].Result == SUCCESS)
				Error += Compare ? 0 : 1;
			else
				Error += Compare ? 1 : 0;
		}
		
		return Error;
	}

	static int test64_bitfieldReverse()
	{
		int Error = 0;
		std::size_t const Count = sizeof(Data64) / sizeof(typeU64);
		
		for(std::size_t i = 0; i < Count; ++i)
		{
			glm::uint64 Return = glm::bitfieldReverse(Data64[i].Value);
			
			bool Compare = Data64[i].Return == Return;
			
			if(Data64[i].Result == SUCCESS)
				Error += Compare ? 0 : 1;
			else
				Error += Compare ? 1 : 0;
		}
		
		return Error;
	}

	static int test64_bitfieldReverseLoop()
	{
		int Error = 0;
		std::size_t const Count = sizeof(Data64) / sizeof(typeU64);
		
		for(std::size_t i = 0; i < Count; ++i)
		{
			glm::uint64 Return = bitfieldReverseLoop(Data64[i].Value);
			
			bool Compare = Data64[i].Return == Return;
			
			if(Data32[i].Result == SUCCESS)
				Error += Compare ? 0 : 1;
			else
				Error += Compare ? 1 : 0;
		}
		
		return Error;
	}

	static int test64_bitfieldReverseUint64()
	{
		int Error = 0;
		std::size_t const Count = sizeof(Data64) / sizeof(typeU64);
		
		for(std::size_t i = 0; i < Count; ++i)
		{
			glm::uint64 Return = bitfieldReverseUint64(Data64[i].Value);
			
			bool Compare = Data64[i].Return == Return;
			
			if(Data64[i].Result == SUCCESS)
				Error += Compare ? 0 : 1;
			else
				Error += Compare ? 1 : 0;
		}
		
		return Error;
	}

	static int test64_bitfieldReverseOps()
	{
		int Error = 0;
		std::size_t const Count = sizeof(Data64) / sizeof(typeU64);
		
		for(std::size_t i = 0; i < Count; ++i)
		{
			glm::uint64 Return = bitfieldReverseOps(Data64[i].Value);
			
			bool Compare = Data64[i].Return == Return;
			
			if(Data64[i].Result == SUCCESS)
				Error += Compare ? 0 : 1;
			else
				Error += Compare ? 1 : 0;
		}
		
		return Error;
	}

	static int test()
	{
		int Error = 0;

		Error += test32_bitfieldReverse();
		Error += test32_bitfieldReverseLoop();
		Error += test32_bitfieldReverseUint32();
		Error += test32_bitfieldReverseOps();

		Error += test64_bitfieldReverse();
		Error += test64_bitfieldReverseLoop();
		Error += test64_bitfieldReverseUint64();
		Error += test64_bitfieldReverseOps();

		return Error;
	}

	static int perf32(glm::uint32 Count)
	{
		int Error = 0;

		std::vector<glm::uint32> Data;
		Data.resize(static_cast<std::size_t>(Count));

		std::clock_t Timestamps0 = std::clock();

		for(glm::uint32 k = 0; k < Count; ++k)
			Data[k] = glm::bitfieldReverse(k);

		std::clock_t Timestamps1 = std::clock();

		for(glm::uint32 k = 0; k < Count; ++k)
			Data[k] = bitfieldReverseLoop(k);

		std::clock_t Timestamps2 = std::clock();

		for(glm::uint32 k = 0; k < Count; ++k)
			Data[k] = bitfieldReverseUint32(k);

		std::clock_t Timestamps3 = std::clock();

		for(glm::uint32 k = 0; k < Count; ++k)
			Data[k] = bitfieldReverseOps(k);

		std::clock_t Timestamps4 = std::clock();

		std::printf(""glm::bitfieldReverse: %d clocks\\n"", static_cast<unsigned int>(Timestamps1 - Timestamps0));
		std::printf(""bitfieldReverseLoop: %d clocks\\n"", static_cast<unsigned int>(Timestamps2 - Timestamps1));
		std::printf(""bitfieldReverseUint32: %d clocks\\n"", static_cast<unsigned int>(Timestamps3 - Timestamps2));
		std::printf(""bitfieldReverseOps: %d clocks\\n"", static_cast<unsigned int>(Timestamps4 - Timestamps3));

		return Error;
	}

	static int perf64(glm::uint64 Count)
	{
		int Error = 0;

		std::vector<glm::uint64> Data;
		Data.resize(static_cast<std::size_t>(Count));

		std::clock_t Timestamps0 = std::clock();

		for(glm::uint32 k = 0; k < Count; ++k)
			Data[k] = glm::bitfieldReverse(k);

		std::clock_t Timestamps1 = std::clock();

		for(glm::uint64 k = 0; k < Count; ++k)
			Data[k] = bitfieldReverseLoop(k);

		std::clock_t Timestamps2 = std::clock();

		for(glm::uint64 k = 0; k < Count; ++k)
			Data[k] = bitfieldReverseUint64(k);

		std::clock_t Timestamps3 = std::clock();

		for(glm::uint64 k = 0; k < Count; ++k)
			Data[k] = bitfieldReverseOps(k);

		std::clock_t Timestamps4 = std::clock();

		std::printf(""glm::bitfieldReverse - 64: %d clocks\\n"", static_cast<unsigned int>(Timestamps1 - Timestamps0));
		std::printf(""bitfieldReverseLoop - 64: %d clocks\\n"", static_cast<unsigned int>(Timestamps2 - Timestamps1));
		std::printf(""bitfieldReverseUint - 64: %d clocks\\n"", static_cast<unsigned int>(Timestamps3 - Timestamps2));
		std::printf(""bitfieldReverseOps - 64: %d clocks\\n"", static_cast<unsigned int>(Timestamps4 - Timestamps3));

		return Error;
	}

	static int perf(std::size_t Samples)
	{
		int Error = 0;

		Error += perf32(static_cast<glm::uint32>(Samples));
		Error += perf64(static_cast<glm::uint64>(Samples));

		return Error;
	}
}//bitfieldReverse

namespace findMSB
{
	template<typename genType, typename retType>
	struct type
	{
		genType		Value;
		retType		Return;
	};

#	if GLM_HAS_BITSCAN_WINDOWS
		template<typename genIUType>
		static int findMSB_intrinsic(genIUType Value)
		{
			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, ""'findMSB' only accept integer values"");

			if(Value == 0)
				return -1;

			unsigned long Result(0);
			_BitScanReverse(&Result, Value);
			return int(Result);
		}
#	endif//GLM_HAS_BITSCAN_WINDOWS

#	if GLM_ARCH & GLM_ARCH_AVX && GLM_COMPILER & GLM_COMPILER_VC
		template<typename genIUType>
		static int findMSB_avx(genIUType Value)
		{
			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, ""'findMSB' only accept integer values"");

			if(Value == 0)
				return -1;

			return int(_tzcnt_u32(Value));
		}
#	endif//GLM_ARCH & GLM_ARCH_AVX && GLM_PLATFORM & GLM_PLATFORM_WINDOWS

	template<typename genIUType>
	static int findMSB_095(genIUType Value)
	{
		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, ""'findMSB' only accept integer values"");
		
		if(Value == genIUType(0) || Value == genIUType(-1))
			return -1;
		else if(Value > 0)
		{
			genIUType Bit = genIUType(-1);
			for(genIUType tmp = Value; tmp > 0; tmp >>= 1, ++Bit){}
			return static_cast<int>(Bit);
		}
		else //if(Value < 0)
		{
			int const BitCount(sizeof(genIUType) * 8);
			int MostSignificantBit(-1);
			for(int BitIndex(0); BitIndex < BitCount; ++BitIndex)
				MostSignificantBit = (Value & (1 << BitIndex)) ? MostSignificantBit : BitIndex;
			assert(MostSignificantBit >= 0);
			return MostSignificantBit;
		}
	}

	template<typename genIUType>
	static int findMSB_nlz1(genIUType x)
	{
		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, ""'findMSB' only accept integer values"");

		if (x == 0)
			return -1;

		int n = 0;
		if (x <= 0x0000FFFF) {n = n +16; x = x <<16;}
		if (x <= 0x00FFFFFF) {n = n + 8; x = x << 8;}
		if (x <= 0x0FFFFFFF) {n = n + 4; x = x << 4;}
		if (x <= 0x3FFFFFFF) {n = n + 2; x = x << 2;}
		if (x <= 0x7FFFFFFF) {n = n + 1;}
		return 31 - n;
	}

	static int findMSB_nlz2(unsigned int x)
	{
		unsigned int y;
		int n = 32;

		y = x >>16;  if (y != 0) {n = n -16;  x = y;}
		y = x >> 8;  if (y != 0) {n = n - 8;  x = y;}
		y = x >> 4;  if (y != 0) {n = n - 4;  x = y;}
		y = x >> 2;  if (y != 0) {n = n - 2;  x = y;}
		y = x >> 1;  if (y != 0) return n - 2;
		return 32 - (n - static_cast<int>(x));
	}

	static int findMSB_pop(unsigned int x)
	{
		x = x | (x >> 1);
		x = x | (x >> 2);
		x = x | (x >> 4);
		x = x | (x >> 8);
		x = x | (x >>16);
		return 31 - glm::bitCount(~x);
	}

	static int perf_int(std::size_t Count)
	{
		type<int, int> const Data[] =
		{
			{0x00000000, -1},
			{0x00000001,  0},
			{0x00000002,  1},
			{0x00000003,  1},
			{0x00000004,  2},
			{0x00000005,  2},
			{0x00000007,  2},
			{0x00000008,  3},
			{0x00000010,  4},
			{0x00000020,  5},
			{0x00000040,  6},
			{0x00000080,  7},
			{0x00000100,  8},
			{0x00000200,  9},
			{0x00000400, 10},
			{0x00000800, 11},
			{0x00001000, 12},
			{0x00002000, 13},
			{0x00004000, 14},
			{0x00008000, 15},
			{0x00010000, 16},
			{0x00020000, 17},
			{0x00040000, 18},
			{0x00080000, 19},
			{0x00100000, 20},
			{0x00200000, 21},
			{0x00400000, 22},
			{0x00800000, 23},
			{0x01000000, 24},
			{0x02000000, 25},
			{0x04000000, 26},
			{0x08000000, 27},
			{0x10000000, 28},
			{0x20000000, 29},
			{0x40000000, 30}
		};

		int Error(0);

		std::clock_t Timestamps0 = std::clock();

		for(std::size_t k = 0; k < Count; ++k)
		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<int, int>); ++i)
		{
			int Result = glm::findMSB(Data[i].Value);
			Error += Data[i].Return == Result ? 0 : 1;
		}

		std::clock_t Timestamps1 = std::clock();

		for(std::size_t k = 0; k < Count; ++k)
		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<int, int>); ++i)
		{
			int Result = findMSB_nlz1(Data[i].Value);
			Error += Data[i].Return == Result ? 0 : 1;
		}

		std::clock_t Timestamps2 = std::clock();

		for(std::size_t k = 0; k < Count; ++k)
		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<int, int>); ++i)
		{
			int Result = findMSB_nlz2(static_cast<unsigned int>(Data[i].Value));
			Error += Data[i].Return == Result ? 0 : 1;
		}

		std::clock_t Timestamps3 = std::clock();

		for(std::size_t k = 0; k < Count; ++k)
		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<int, int>); ++i)
		{
			int Result = findMSB_095(static_cast<unsigned int>(Data[i].Value));
			Error += Data[i].Return == Result ? 0 : 1;
		}

		std::clock_t Timestamps4 = std::clock();

#		if GLM_HAS_BITSCAN_WINDOWS
			for(std::size_t k = 0; k < Count; ++k)
			for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<int, int>); ++i)
			{
				int Result = findMSB_intrinsic(Data[i].Value);
				Error += Data[i].Return == Result ? 0 : 1;
			}
#		endif//GLM_HAS_BITSCAN_WINDOWS

		std::clock_t Timestamps5 = std::clock();

		for(std::size_t k = 0; k < Count; ++k)
		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<int, int>); ++i)
		{
			int Result = findMSB_pop(static_cast<unsigned int>(Data[i].Value));
			Error += Data[i].Return == Result ? 0 : 1;
		}

		std::clock_t Timestamps6 = std::clock();

#		if GLM_ARCH & GLM_ARCH_AVX && GLM_COMPILER & GLM_COMPILER_VC
			for(std::size_t k = 0; k < Count; ++k)
			for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<int, int>); ++i)
			{
				int Result = findMSB_avx(Data[i].Value);
				Error += Data[i].Return == Result ? 0 : 1;
			}

			std::clock_t Timestamps7 = std::clock();
#		endif

		std::printf(""glm::findMSB: %d clocks\\n"", static_cast<unsigned int>(Timestamps1 - Timestamps0));
		std::printf(""findMSB - nlz1: %d clocks\\n"", static_cast<unsigned int>(Timestamps2 - Timestamps1));
		std::printf(""findMSB - nlz2: %d clocks\\n"", static_cast<unsigned int>(Timestamps3 - Timestamps2));
		std::printf(""findMSB - 0.9.5: %d clocks\\n"", static_cast<unsigned int>(Timestamps4 - Timestamps3));

#		if GLM_HAS_BITSCAN_WINDOWS
			std::printf(""findMSB - intrinsics: %d clocks\\n"", static_cast<unsigned int>(Timestamps5 - Timestamps4));
#		endif//GLM_HAS_BITSCAN_WINDOWS
		std::printf(""findMSB - pop: %d clocks\\n"", static_cast<unsigned int>(Timestamps6 - Timestamps5));

#		if GLM_ARCH & GLM_ARCH_AVX && GLM_COMPILER & GLM_COMPILER_VC
			std::printf(""findMSB - avx tzcnt: %d clocks\\n"", static_cast<unsigned int>(Timestamps7 - Timestamps6));
#		endif//GLM_ARCH & GLM_ARCH_AVX && GLM_PLATFORM & GLM_PLATFORM_WINDOWS

		return Error;
	}

	static int test_ivec4()
	{
		type<glm::ivec4, glm::ivec4> const Data[] =
		{
			{glm::ivec4(0x00000000), glm::ivec4(-1)},
			{glm::ivec4(0x00000001), glm::ivec4( 0)},
			{glm::ivec4(0x00000002), glm::ivec4( 1)},
			{glm::ivec4(0x00000003), glm::ivec4( 1)},
			{glm::ivec4(0x00000004), glm::ivec4( 2)},
			{glm::ivec4(0x00000005), glm::ivec4( 2)},
			{glm::ivec4(0x00000007), glm::ivec4( 2)},
			{glm::ivec4(0x00000008), glm::ivec4( 3)},
			{glm::ivec4(0x00000010), glm::ivec4( 4)},
			{glm::ivec4(0x00000020), glm::ivec4( 5)},
			{glm::ivec4(0x00000040), glm::ivec4( 6)},
			{glm::ivec4(0x00000080), glm::ivec4( 7)},
			{glm::ivec4(0x00000100), glm::ivec4( 8)},
			{glm::ivec4(0x00000200), glm::ivec4( 9)},
			{glm::ivec4(0x00000400), glm::ivec4(10)},
			{glm::ivec4(0x00000800), glm::ivec4(11)},
			{glm::ivec4(0x00001000), glm::ivec4(12)},
			{glm::ivec4(0x00002000), glm::ivec4(13)},
			{glm::ivec4(0x00004000), glm::ivec4(14)},
			{glm::ivec4(0x00008000), glm::ivec4(15)},
			{glm::ivec4(0x00010000), glm::ivec4(16)},
			{glm::ivec4(0x00020000), glm::ivec4(17)},
			{glm::ivec4(0x00040000), glm::ivec4(18)},
			{glm::ivec4(0x00080000), glm::ivec4(19)},
			{glm::ivec4(0x00100000), glm::ivec4(20)},
			{glm::ivec4(0x00200000), glm::ivec4(21)},
			{glm::ivec4(0x00400000), glm::ivec4(22)},
			{glm::ivec4(0x00800000), glm::ivec4(23)},
			{glm::ivec4(0x01000000), glm::ivec4(24)},
			{glm::ivec4(0x02000000), glm::ivec4(25)},
			{glm::ivec4(0x04000000), glm::ivec4(26)},
			{glm::ivec4(0x08000000), glm::ivec4(27)},
			{glm::ivec4(0x10000000), glm::ivec4(28)},
			{glm::ivec4(0x20000000), glm::ivec4(29)},
			{glm::ivec4(0x40000000), glm::ivec4(30)}
		};

		int Error(0);

		for(std::size_t i = 0; i < sizeof(Data) / sizeof(type<glm::ivec4, glm::ivec4>); ++i)
		{
			glm::ivec4 Result0 = glm::findMSB(Data[i].Value);
			Error += glm::all(glm::equal(Data[i].Return, Result0)) ? 0 : 1;
		}

		return Error;
	}

	static int test_int()
	{
		typedef type<glm::uint, int> entry;

		entry const Data[] =
		{
			{0x00000000, -1},
			{0x00000001,  0},
			{0x00000002,  1},
			{0x00000003,  1},
			{0x00000004,  2},
			{0x00000005,  2},
			{0x00000007,  2},
			{0x00000008,  3},
			{0x00000010,  4},
			{0x00000020,  5},
			{0x00000040,  6},
			{0x00000080,  7},
			{0x00000100,  8},
			{0x00000200,  9},
			{0x00000400, 10},
			{0x00000800, 11},
			{0x00001000, 12},
			{0x00002000, 13},
			{0x00004000, 14},
			{0x00008000, 15},
			{0x00010000, 16},
			{0x00020000, 17},
			{0x00040000, 18},
			{0x00080000, 19},
			{0x00100000, 20},
			{0x00200000, 21},
			{0x00400000, 22},
			{0x00800000, 23},
			{0x01000000, 24},
			{0x02000000, 25},
			{0x04000000, 26},
			{0x08000000, 27},
			{0x10000000, 28},
			{0x20000000, 29},
			{0x40000000, 30}
		};

		int Error(0);

		for(std::size_t i = 0; i < sizeof(Data) / sizeof(entry); ++i)
		{
			int Result0 = glm::findMSB(Data[i].Value);
			Error += Data[i].Return == Result0 ? 0 : 1;
		}

		for(std::size_t i = 0; i < sizeof(Data) / sizeof(entry); ++i)
		{
			int Result0 = findMSB_nlz1(Data[i].Value);
			Error += Data[i].Return == Result0 ? 0 : 1;
		}
/*
		for(std::size_t i = 0; i < sizeof(Data) / sizeof(entry); ++i)
		{
			int Result0 = findMSB_nlz2(Data[i].Value);
			Error += Data[i].Return == Result0 ? 0 : 1;
		}
*/
		for(std::size_t i = 0; i < sizeof(Data) / sizeof(entry); ++i)
		{
			int Result0 = findMSB_095(Data[i].Value);
			Error += Data[i].Return == Result0 ? 0 : 1;
		}

#		if GLM_HAS_BITSCAN_WINDOWS
			for(std::size_t i = 0; i < sizeof(Data) / sizeof(entry); ++i)
			{
				int Result0 = findMSB_intrinsic(Data[i].Value);
				Error += Data[i].Return == Result0 ? 0 : 1;
			}
#		endif//GLM_HAS_BITSCAN_WINDOWS

		for(std::size_t i = 0; i < sizeof(Data) / sizeof(entry); ++i)
		{
			int Result0 = findMSB_pop(Data[i].Value);
			Error += Data[i].Return == Result0 ? 0 : 1;
		}

		return Error;
	}

	static int test()
	{
		int Error(0);

		Error += test_ivec4();
		Error += test_int();

		return Error;
	}

	static int perf(std::size_t Samples)
	{
		int Error(0);

		Error += perf_int(Samples);

		return Error;
	}
}//findMSB

namespace findLSB
{
	template<typename genType, typename retType>
	struct type
	{
		genType		Value;
		retType		Return;
	};

	typedef type<int, int> entry;

	entry const DataI32[] =
	{
		{0x00000001,  0},
		{0x00000003,  0},
		{0x00000002,  1},
		// {0x80000000, 31}, // Clang generates an error with this
		{0x00010000, 16},
		{0x7FFF0000, 16},
		{0x7F000000, 24},
		{0x7F00FF00,  8},
		{0x00000000, -1}
	};

#	if GLM_HAS_BITSCAN_WINDOWS
		template<typename genIUType>
		static int findLSB_intrinsic(genIUType Value)
		{
			GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, ""'findLSB' only accept integer values"");

			if(Value == 0)
				return -1;

			unsigned long Result(0);
			_BitScanForward(&Result, Value);
			return int(Result);
		}
#	endif

	template<typename genIUType>
	static int findLSB_095(genIUType Value)
	{
		GLM_STATIC_ASSERT(std::numeric_limits<genIUType>::is_integer, ""'findLSB' only accept integer values"");
		if(Value == 0)
			return -1;

		genIUType Bit;
		for(Bit = genIUType(0); !(Value & (1 << Bit)); ++Bit){}
		return Bit;
	}

	template<typename genIUType>
	static int findLSB_ntz2(genIUType x)
	{
		if(x == 0)
			return -1;

		return glm::bitCount(~x & (x - static_cast<genIUType>(1)));
	}

	template<typename genIUType>
	static int findLSB_branchfree(genIUType x)
	{
		bool IsNull(x == 0);
		int const Keep(!IsNull);
		int const Discard(IsNull);

		return static_cast<int>(glm::bitCount(~x & (x - static_cast<genIUType>(1)))) * Keep + Discard * -1;
	}

	static int test_int()
	{
		int Error(0);

		for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i)
		{
			int Result = glm::findLSB(DataI32[i].Value);
			Error += DataI32[i].Return == Result ? 0 : 1;
		}

		for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i)
		{
			int Result = findLSB_095(DataI32[i].Value);
			Error += DataI32[i].Return == Result ? 0 : 1;
		}

#		if GLM_HAS_BITSCAN_WINDOWS
			for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i)
			{
				int Result = findLSB_intrinsic(DataI32[i].Value);
				Error += DataI32[i].Return == Result ? 0 : 1;
			}
#		endif

		for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i)
		{
			int Result = findLSB_ntz2(DataI32[i].Value);
			Error += DataI32[i].Return == Result ? 0 : 1;
		}

		for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i)
		{
			int Result = findLSB_branchfree(DataI32[i].Value);
			Error += DataI32[i].Return == Result ? 0 : 1;
		}

		return Error;
	}

	static int test()
	{
		int Error(0);

		Error += test_int();

		return Error;
	}

	static int perf_int(std::size_t Count)
	{
		int Error(0);

		std::clock_t Timestamps0 = std::clock();

		for(std::size_t k = 0; k < Count; ++k)
		for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i)
		{
			int Result = glm::findLSB(DataI32[i].Value);
			Error += DataI32[i].Return == Result ? 0 : 1;
		}

		std::clock_t Timestamps1 = std::clock();

		for(std::size_t k = 0; k < Count; ++k)
		for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i)
		{
			int Result = findLSB_095(DataI32[i].Value);
			Error += DataI32[i].Return == Result ? 0 : 1;
		}

		std::clock_t Timestamps2 = std::clock();

#		if GLM_HAS_BITSCAN_WINDOWS
			for(std::size_t k = 0; k < Count; ++k)
			for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i)
			{
				int Result = findLSB_intrinsic(DataI32[i].Value);
				Error += DataI32[i].Return == Result ? 0 : 1;
			}
#		endif

		std::clock_t Timestamps3 = std::clock();

		for(std::size_t k = 0; k < Count; ++k)
		for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i)
		{
			int Result = findLSB_ntz2(DataI32[i].Value);
			Error += DataI32[i].Return == Result ? 0 : 1;
		}

		std::clock_t Timestamps4 = std::clock();

		for(std::size_t k = 0; k < Count; ++k)
		for(std::size_t i = 0; i < sizeof(DataI32) / sizeof(entry); ++i)
		{
			int Result = findLSB_branchfree(DataI32[i].Value);
			Error += DataI32[i].Return == Result ? 0 : 1;
		}

		std::clock_t Timestamps5 = std::clock();

		std::printf(""glm::findLSB: %d clocks\\n"", static_cast<unsigned int>(Timestamps1 - Timestamps0));
		std::printf(""findLSB - 0.9.5: %d clocks\\n"", static_cast<unsigned int>(Timestamps2 - Timestamps1));

#		if GLM_HAS_BITSCAN_WINDOWS
			std::printf(""findLSB - intrinsics: %d clocks\\n"", static_cast<unsigned int>(Timestamps3 - Timestamps2));
#		endif

		std::printf(""findLSB - ntz2: %d clocks\\n"", static_cast<unsigned int>(Timestamps4 - Timestamps3));
		std::printf(""findLSB - branchfree: %d clocks\\n"", static_cast<unsigned int>(Timestamps5 - Timestamps4));

		return Error;
	}

	static int perf(std::size_t Samples)
	{
		int Error(0);

		Error += perf_int(Samples);

		return Error;
	}
}//findLSB

namespace uaddCarry
{
	static int test()
	{
		int Error(0);
		
		{
			glm::uint x = std::numeric_limits<glm::uint>::max();
			glm::uint y = 0;
			glm::uint Carry = 0;
			glm::uint Result = glm::uaddCarry(x, y, Carry);

			Error += Carry == 0 ? 0 : 1;
			Error += Result == std::numeric_limits<glm::uint>::max() ? 0 : 1;
		}

		{
			glm::uint x = std::numeric_limits<glm::uint>::max();
			glm::uint y = 1;
			glm::uint Carry = 0;
			glm::uint Result = glm::uaddCarry(x, y, Carry);

			Error += Carry == 1 ? 0 : 1;
			Error += Result == 0 ? 0 : 1;
		}

		{
			glm::uvec1 x(std::numeric_limits<glm::uint>::max());
			glm::uvec1 y(0);
			glm::uvec1 Carry(0);
			glm::uvec1 Result(glm::uaddCarry(x, y, Carry));

			Error += glm::all(glm::equal(Carry, glm::uvec1(0))) ? 0 : 1;
			Error += glm::all(glm::equal(Result, glm::uvec1(std::numeric_limits<glm::uint>::max()))) ? 0 : 1;
		}

		{
			glm::uvec1 x(std::numeric_limits<glm::uint>::max());
			glm::uvec1 y(1);
			glm::uvec1 Carry(0);
			glm::uvec1 Result(glm::uaddCarry(x, y, Carry));

			Error += glm::all(glm::equal(Carry, glm::uvec1(1))) ? 0 : 1;
			Error += glm::all(glm::equal(Result, glm::uvec1(0))) ? 0 : 1;
		}

		return Error;
	}
}//namespace uaddCarry

namespace usubBorrow
{
	static int test()
	{
		int Error(0);
		
		{
			glm::uint x = 16;
			glm::uint y = 17;
			glm::uint Borrow = 0;
			glm::uint Result = glm::usubBorrow(x, y, Borrow);

			Error += Borrow == 1 ? 0 : 1;
			Error += Result == 1 ? 0 : 1;
		}

		{
			glm::uvec1 x(16);
			glm::uvec1 y(17);
			glm::uvec1 Borrow(0);
			glm::uvec1 Result(glm::usubBorrow(x, y, Borrow));

			Error += glm::all(glm::equal(Borrow, glm::uvec1(1))) ? 0 : 1;
			Error += glm::all(glm::equal(Result, glm::uvec1(1))) ? 0 : 1;
		}

		{
			glm::uvec2 x(16);
			glm::uvec2 y(17);
			glm::uvec2 Borrow(0);
			glm::uvec2 Result(glm::usubBorrow(x, y, Borrow));

			Error += glm::all(glm::equal(Borrow, glm::uvec2(1))) ? 0 : 1;
			Error += glm::all(glm::equal(Result, glm::uvec2(1))) ? 0 : 1;
		}

		{
			glm::uvec3 x(16);
			glm::uvec3 y(17);
			glm::uvec3 Borrow(0);
			glm::uvec3 Result(glm::usubBorrow(x, y, Borrow));

			Error += glm::all(glm::equal(Borrow, glm::uvec3(1))) ? 0 : 1;
			Error += glm::all(glm::equal(Result, glm::uvec3(1))) ? 0 : 1;
		}

		{
			glm::uvec4 x(16);
			glm::uvec4 y(17);
			glm::uvec4 Borrow(0);
			glm::uvec4 Result(glm::usubBorrow(x, y, Borrow));

			Error += glm::all(glm::equal(Borrow, glm::uvec4(1))) ? 0 : 1;
			Error += glm::all(glm::equal(Result, glm::uvec4(1))) ? 0 : 1;
		}

		return Error;
	}
}//namespace usubBorrow

namespace umulExtended
{
	static int test()
	{
		int Error(0);
		
		{
			glm::uint x = 2;
			glm::uint y = 3;
			glm::uint msb = 0;
			glm::uint lsb = 0;
			glm::umulExtended(x, y, msb, lsb);

			Error += msb == 0 ? 0 : 1;
			Error += lsb == 6 ? 0 : 1;
		}

		{
			glm::uvec1 x(2);
			glm::uvec1 y(3);
			glm::uvec1 msb(0);
			glm::uvec1 lsb(0);
			glm::umulExtended(x, y, msb, lsb);

			Error += glm::all(glm::equal(msb, glm::uvec1(0))) ? 0 : 1;
			Error += glm::all(glm::equal(lsb, glm::uvec1(6))) ? 0 : 1;
		}

		{
			glm::uvec2 x(2);
			glm::uvec2 y(3);
			glm::uvec2 msb(0);
			glm::uvec2 lsb(0);
			glm::umulExtended(x, y, msb, lsb);

			Error += glm::all(glm::equal(msb, glm::uvec2(0))) ? 0 : 1;
			Error += glm::all(glm::equal(lsb, glm::uvec2(6))) ? 0 : 1;
		}

		{
			glm::uvec3 x(2);
			glm::uvec3 y(3);
			glm::uvec3 msb(0);
			glm::uvec3 lsb(0);
			glm::umulExtended(x, y, msb, lsb);

			Error += glm::all(glm::equal(msb, glm::uvec3(0))) ? 0 : 1;
			Error += glm::all(glm::equal(lsb, glm::uvec3(6))) ? 0 : 1;
		}

		{
			glm::uvec4 x(2);
			glm::uvec4 y(3);
			glm::uvec4 msb(0);
			glm::uvec4 lsb(0);
			glm::umulExtended(x, y, msb, lsb);

			Error += glm::all(glm::equal(msb, glm::uvec4(0))) ? 0 : 1;
			Error += glm::all(glm::equal(lsb, glm::uvec4(6))) ? 0 : 1;
		}

		return Error;
	}
}//namespace umulExtended

namespace imulExtended
{
	static int test()
	{
		int Error(0);
		
		{
			int x = 2;
			int y = 3;
			int msb = 0;
			int lsb = 0;
			glm::imulExtended(x, y, msb, lsb);

			Error += msb == 0 ? 0 : 1;
			Error += lsb == 6 ? 0 : 1;
		}

		{
			glm::ivec1 x(2);
			glm::ivec1 y(3);
			glm::ivec1 msb(0);
			glm::ivec1 lsb(0);
			glm::imulExtended(x, y, msb, lsb);

			Error += glm::all(glm::equal(msb, glm::ivec1(0))) ? 0 : 1;
			Error += glm::all(glm::equal(lsb, glm::ivec1(6))) ? 0 : 1;
		}

		{
			glm::ivec2 x(2);
			glm::ivec2 y(3);
			glm::ivec2 msb(0);
			glm::ivec2 lsb(0);
			glm::imulExtended(x, y, msb, lsb);

			Error += glm::all(glm::equal(msb, glm::ivec2(0))) ? 0 : 1;
			Error += glm::all(glm::equal(lsb, glm::ivec2(6))) ? 0 : 1;
		}

		{
			glm::ivec3 x(2);
			glm::ivec3 y(3);
			glm::ivec3 msb(0);
			glm::ivec3 lsb(0);
			glm::imulExtended(x, y, msb, lsb);

			Error += glm::all(glm::equal(msb, glm::ivec3(0))) ? 0 : 1;
			Error += glm::all(glm::equal(lsb, glm::ivec3(6))) ? 0 : 1;
		}

		{
			glm::ivec4 x(2);
			glm::ivec4 y(3);
			glm::ivec4 msb(0);
			glm::ivec4 lsb(0);
			glm::imulExtended(x, y, msb, lsb);

			Error += glm::all(glm::equal(msb, glm::ivec4(0))) ? 0 : 1;
			Error += glm::all(glm::equal(lsb, glm::ivec4(6))) ? 0 : 1;
		}

		return Error;
	}
}//namespace imulExtended

namespace bitCount
{
	template<typename genType>
	struct type
	{
		genType		Value;
		genType		Return;
	};

	type<int> const DataI32[] =
	{
		{0x00000001,  1},
		{0x00000003,  2},
		{0x00000002,  1},
		{0x7fffffff, 31},
		{0x00000000,  0}
	};

	template<typename T>
	inline int bitCount_if(T v)
	{
		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, ""'bitCount' only accept integer values"");

		int Count(0);
		for(T i = 0, n = static_cast<T>(sizeof(T) * 8); i < n; ++i)
		{
			if(v & static_cast<T>(1 << i))
				++Count;
		}
		return Count;
	}

	template<typename T>
	inline int bitCount_vec(T v)
	{
		GLM_STATIC_ASSERT(std::numeric_limits<T>::is_integer, ""'bitCount' only accept integer values"");

		int Count(0);
		for(T i = 0, n = static_cast<T>(sizeof(T) * 8); i < n; ++i)
		{
			Count += static_cast<int>((v >> i) & static_cast<T>(1));
		}
		return Count;
	}

	template<bool EXEC = false>
	struct compute_bitfieldBitCountStep
	{
		template<glm::length_t L, typename T, glm::precision P, template<glm::length_t, typename, glm::precision> class vecType>
		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & v, T, T)
		{
			return v;
		}
	};

	template<>
	struct compute_bitfieldBitCountStep<true>
	{
		template<glm::length_t L, typename T, glm::precision P, template<glm::length_t, typename, glm::precision> class vecType>
		GLM_FUNC_QUALIFIER static vecType<L, T, P> call(vecType<L, T, P> const & v, T Mask, T Shift)
		{
			return (v & Mask) + ((v >> Shift) & Mask);
		}
	};

	template<glm::length_t L, typename T, glm::precision P, template<glm::length_t, typename, glm::precision> class vecType>
	static vecType<L, int, P> bitCount_bitfield(vecType<L, T, P> const & v)
	{
		vecType<L, typename glm::detail::make_unsigned<T>::type, P> x(*reinterpret_cast<vecType<L, typename glm::detail::make_unsigned<T>::type, P> const *>(&v));
		x = compute_bitfieldBitCountStep<sizeof(T) * 8 >=  2>::call(x, typename glm::detail::make_unsigned<T>::type(0x5555555555555555ull), typename glm::detail::make_unsigned<T>::type( 1));
		x = compute_bitfieldBitCountStep<sizeof(T) * 8 >=  4>::call(x, typename glm::detail::make_unsigned<T>::type(0x3333333333333333ull), typename glm::detail::make_unsigned<T>::type( 2));
		x = compute_bitfieldBitCountStep<sizeof(T) * 8 >=  8>::call(x, typename glm::detail::make_unsigned<T>::type(0x0F0F0F0F0F0F0F0Full), typename glm::detail::make_unsigned<T>::type( 4));
		x = compute_bitfieldBitCountStep<sizeof(T) * 8 >= 16>::call(x, typename glm::detail::make_unsigned<T>::type(0x00FF00FF00FF00FFull), typename glm::detail::make_unsigned<T>::type( 8));
		x = compute_bitfieldBitCountStep<sizeof(T) * 8 >= 32>::call(x, typename glm::detail::make_unsigned<T>::type(0x0000FFFF0000FFFFull), typename glm::detail::make_unsigned<T>::type(16));
		x = compute_bitfieldBitCountStep<sizeof(T) * 8 >= 64>::call(x, typename glm::detail::make_unsigned<T>::type(0x00000000FFFFFFFFull), typename glm::detail::make_unsigned<T>::type(32));
		return vecType<L, int, P>(x);
	}

	template<typename genType>
	static int bitCount_bitfield(genType x)
	{
		return bitCount_bitfield(glm::vec<1, genType, glm::defaultp>(x)).x;
	}

	static int perf(std::size_t Size)
	{
		int Error(0);

		std::vector<int> v;
		v.resize(Size);

		std::vector<glm::ivec4> w;
		w.resize(Size);


		std::clock_t TimestampsA = std::clock();

		// bitCount - TimeIf
		{
			for(std::size_t i = 0, n = v.size(); i < n; ++i)
				v[i] = bitCount_if(static_cast<int>(i));
		}

		std::clock_t TimestampsB = std::clock();

		// bitCount - TimeVec
		{
			for(std::size_t i = 0, n = v.size(); i < n; ++i)
				v[i] = bitCount_vec(i);
		}

		std::clock_t TimestampsC = std::clock();

		// bitCount - TimeDefault
		{
			for(std::size_t i = 0, n = v.size(); i < n; ++i)
				v[i] = glm::bitCount(i);
		}

		std::clock_t TimestampsD = std::clock();

		// bitCount - TimeVec4
		{
			for(std::size_t i = 0, n = v.size(); i < n; ++i)
				w[i] = glm::bitCount(glm::ivec4(static_cast<int>(i)));
		}

		std::clock_t TimestampsE = std::clock();

		{
			for(std::size_t i = 0, n = v.size(); i < n; ++i)
				v[i] = bitCount_bitfield(static_cast<int>(i));
		}

		std::clock_t TimestampsF = std::clock();

		std::printf(""bitCount - TimeIf %d\\n"", static_cast<unsigned int>(TimestampsB - TimestampsA));
		std::printf(""bitCount - TimeVec %d\\n"", static_cast<unsigned int>(TimestampsC - TimestampsB));
		std::printf(""bitCount - TimeDefault %d\\n"", static_cast<unsigned int>(TimestampsD - TimestampsC));
		std::printf(""bitCount - TimeVec4 %d\\n"", static_cast<unsigned int>(TimestampsE - TimestampsD));
		std::printf(""bitCount - bitfield %d\\n"", static_cast<unsigned int>(TimestampsF - TimestampsE));

		return Error;
	}

	static int test()
	{
		int Error(0);

		for(std::size_t i = 0, n = sizeof(DataI32) / sizeof(type<int>); i < n; ++i)
		{
			int ResultA = glm::bitCount(DataI32[i].Value);
			int ResultB = bitCount_if(DataI32[i].Value);
			int ResultC = bitCount_vec(DataI32[i].Value);
			int ResultE = bitCount_bitfield(DataI32[i].Value);

			Error += DataI32[i].Return == ResultA ? 0 : 1;
			Error += DataI32[i].Return == ResultB ? 0 : 1;
			Error += DataI32[i].Return == ResultC ? 0 : 1;
			Error += DataI32[i].Return == ResultE ? 0 : 1;

			assert(!Error);
		}

		return Error;
	}
}//bitCount

int main()
{
	int Error = 0;

	Error += ::bitCount::test();
	Error += ::bitfieldReverse::test();
	Error += ::findMSB::test();
	Error += ::findLSB::test();
	Error += ::umulExtended::test();
	Error += ::imulExtended::test();
	Error += ::uaddCarry::test();
	Error += ::usubBorrow::test();
	Error += ::bitfieldInsert::test();
	Error += ::bitfieldExtract::test();

#	ifdef NDEBUG
		std::size_t const Samples = 1000;
#	else
		std::size_t const Samples = 1;
#	endif

	::bitCount::perf(Samples);
	::bitfieldReverse::perf(Samples);
	::findMSB::perf(Samples);
	::findLSB::perf(Samples);

	return Error;
}
",16210,True,3197.496684791507,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]]
`breakers`::
(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,2567.281727116853,median
"/*!
 *  Copyright (c) 2014-2019 by Contributors
 * \\file allreduce_robust.cc
 * \\brief Robust implementation of Allreduce
 *
 * \\author Tianqi Chen, Ignacio Cano, Tianyi Zhou
 */
#define NOMINMAX
#include <rabit/base.h>
#include <chrono>
#include <thread>
#include <limits>
#include <utility>
#include ""rabit/internal/io.h""
#include ""rabit/internal/timer.h""
#include ""rabit/internal/utils.h""
#include ""rabit/internal/engine.h""
#include ""rabit/internal/rabit-inl.h""
#include ""allreduce_robust.h""

#undef _assert

namespace rabit {
namespace engine {

AllreduceRobust::AllreduceRobust(void) {
  num_local_replica = 0;
  num_global_replica = 5;
  default_local_replica = 2;
  seq_counter = 0;
  cur_cache_seq = 0;
  local_chkpt_version = 0;
  result_buffer_round = 1;
  global_lazycheck = NULL;
  use_local_model = -1;
  recover_counter = 0;
  checkpoint_loaded = false;
  env_vars.push_back(""rabit_global_replica"");
  env_vars.push_back(""rabit_local_replica"");
}
bool AllreduceRobust::Init(int argc, char* argv[]) {
  if (AllreduceBase::Init(argc, argv)) {
    // chenqin: alert user opted in experimental feature.
    if (rabit_bootstrap_cache) utils::HandleLogInfo(
      ""[EXPERIMENTAL] bootstrap cache has been enabled\\n"");
    checkpoint_loaded = false;
    if (num_global_replica == 0) {
      result_buffer_round = -1;
    } else {
      result_buffer_round = std::max(world_size / num_global_replica, 1);
    }
    return true;
  } else {
    return false;
  }
}
/*! \\brief shutdown the engine */
bool AllreduceRobust::Shutdown(void) {
  try {
    // need to sync the exec before we shutdown, do a pesudo check point
    // execute checkpoint, note: when checkpoint existing, load will not happen
    _assert(RecoverExec(NULL, 0, ActionSummary::kCheckPoint, ActionSummary::kSpecialOp,
      cur_cache_seq), ""Shutdown: check point must return true"");
    // reset result buffer
    resbuf.Clear(); seq_counter = 0;
    cachebuf.Clear(); cur_cache_seq = 0;
    lookupbuf.Clear();
    // execute check ack step, load happens here
    _assert(RecoverExec(NULL, 0, ActionSummary::kCheckAck,
      ActionSummary::kSpecialOp, cur_cache_seq), ""Shutdown: check ack must return true"");
// travis ci only osx test hang
#if defined (__APPLE__)
    sleep(1);
#endif
    shutdown_timeout = true;
    if (rabit_timeout_task.valid()) {
      rabit_timeout_task.wait();
      _assert(rabit_timeout_task.get(), ""expect timeout task return\\n"");
    }
    return AllreduceBase::Shutdown();
  } catch (const std::exception& e) {
    fprintf(stderr, ""%s\\n"", e.what());
    return false;
  }
}

/*!
 * \\brief set parameters to the engine
 * \\param name parameter name
 * \\param val parameter value
 */
void AllreduceRobust::SetParam(const char *name, const char *val) {
  AllreduceBase::SetParam(name, val);
  if (!strcmp(name, ""rabit_global_replica"")) num_global_replica = atoi(val);
  if (!strcmp(name, ""rabit_local_replica"")) {
    num_local_replica = atoi(val);
  }
}

int AllreduceRobust::SetBootstrapCache(const std::string &key, const void *buf,
  const size_t type_nbytes, const size_t count) {
  int index = -1;
  for (int i = 0 ; i < cur_cache_seq; i++) {
    size_t nsize = 0;
    void* name = lookupbuf.Query(i, &nsize);
    if (nsize == key.length() + 1
      && strcmp(static_cast<const char*>(name), key.c_str()) == 0) {
      index = i;
      break;
    }
  }
  // we should consider way to support duplicated signatures
  // https://github.com/dmlc/xgboost/issues/5012
  // _assert(index == -1, ""immutable cache key already exists"");
  _assert(type_nbytes*count > 0, ""can't set empty cache"");
  void* temp = cachebuf.AllocTemp(type_nbytes, count);
  cachebuf.PushTemp(cur_cache_seq, type_nbytes, count);
  std::memcpy(temp, buf, type_nbytes*count);

  std::string k(key);
  void* name = lookupbuf.AllocTemp(strlen(k.c_str()) + 1, 1);
  lookupbuf.PushTemp(cur_cache_seq, strlen(k.c_str()) + 1, 1);
  std::memcpy(name, key.c_str(), strlen(k.c_str()) + 1);
  cur_cache_seq += 1;
  return 0;
}

int AllreduceRobust::GetBootstrapCache(const std::string &key, void* buf,
  const size_t type_nbytes, const size_t count) {
  // as requester sync with rest of nodes on latest cache content
  if (!RecoverExec(NULL, 0, ActionSummary::kLoadBootstrapCache,
    seq_counter, cur_cache_seq)) return -1;

  int index = -1;
  for (int i = 0 ; i < cur_cache_seq; i++) {
    size_t nsize = 0;
    void* name = lookupbuf.Query(i, &nsize);
    if (nsize == strlen(key.c_str()) + 1
      && strcmp(reinterpret_cast<char*>(name), key.c_str()) == 0) {
      index = i;
      break;
    }
  }
  // cache doesn't exists
  if (index == -1) return -1;

  size_t siz = 0;
  void* temp = cachebuf.Query(index, &siz);
  utils::Assert(cur_cache_seq > index, ""cur_cache_seq is smaller than lookup cache seq index"");
  utils::Assert(siz == type_nbytes*count, ""cache size stored expected to be same as requested"");
  utils::Assert(siz > 0, ""cache size should be greater than 0"");
  std::memcpy(buf, temp, type_nbytes*count);
  return 0;
}

/*!
 * \\brief Allgather function, each node have a segment of data in the ring of sendrecvbuf,
 *  the data provided by current node k is [slice_begin, slice_end),
 *  the next node's segment must start with slice_end
 *  after the call of Allgather, sendrecvbuf_ contains all the contents including all segments
 *  use a ring based algorithm
 *
 * \\param sendrecvbuf buffer for both sending and receiving data, it is a ring conceptually
 * \\param total_size total size of data to be gathered
 * \\param slice_begin beginning of the current slice
 * \\param slice_end end of the current slice
 * \\param size_prev_slice size of the previous slice i.e. slice of node (rank - 1) % world_size
 * \\param _file caller file name used to generate unique cache key
 * \\param _line caller line number used to generate unique cache key
 * \\param _caller caller function name used to generate unique cache key 
 */ 
void AllreduceRobust::Allgather(void *sendrecvbuf,
                                    size_t total_size,
                                    size_t slice_begin,
                                    size_t slice_end,
                                    size_t size_prev_slice,
                                    const char* _file,
                                    const int _line,
                                    const char* _caller) {
  if (world_size == 1 || world_size == -1) return;
  // genreate unique allgather signature
  std::string key = std::string(_file) + ""::"" + std::to_string(_line) + ""::""
    + std::string(_caller) + ""#"" +std::to_string(total_size);

  // try fetch bootstrap allgather results from cache
  if (!checkpoint_loaded && rabit_bootstrap_cache &&
    GetBootstrapCache(key, sendrecvbuf, total_size, 1) != -1) return;

  double start = utils::GetTime();
  bool recovered = RecoverExec(sendrecvbuf, total_size, 0, seq_counter, cur_cache_seq);

  if (resbuf.LastSeqNo() != -1 &&
    (result_buffer_round == -1 ||
      resbuf.LastSeqNo() % result_buffer_round != rank % result_buffer_round)) {
    resbuf.DropLast();
  }

  void *temp = resbuf.AllocTemp(total_size, 1);
  while (true) {
    if (recovered) {
      std::memcpy(temp, sendrecvbuf, total_size); break;
    } else {
      std::memcpy(temp, sendrecvbuf, total_size);
      if (CheckAndRecover(TryAllgatherRing(temp, total_size,
                                           slice_begin, slice_end, size_prev_slice))) {
        std::memcpy(sendrecvbuf, temp, total_size); break;
      } else {
        recovered = RecoverExec(sendrecvbuf, total_size, 0, seq_counter, cur_cache_seq);
      }
    }
  }
  double delta = utils::GetTime() - start;
  // log allgather latency
  if (rabit_debug) {
    utils::HandleLogInfo(""[%d] allgather (%s) finished version %d, seq %d, take %f seconds\\n"",
      rank, key.c_str(), version_number, seq_counter, delta);
  }

  // if bootstrap allgather, store and fetch through cache
  if (checkpoint_loaded || !rabit_bootstrap_cache) {
    resbuf.PushTemp(seq_counter, total_size, 1);
    seq_counter += 1;
  } else {
    SetBootstrapCache(key, sendrecvbuf, total_size, 1);
  }
}

/*!
 * \\brief perform in-place allreduce, on sendrecvbuf
 *        this function is NOT thread-safe
 * \\param sendrecvbuf_ buffer for both sending and recving data
 * \\param type_nbytes the unit number of bytes the type have
 * \\param count number of elements to be reduced
 * \\param reducer reduce function
 * \\param prepare_func Lazy preprocessing function, lazy prepare_fun(prepare_arg)
 *                     will be called by the function before performing Allreduce, to intialize the data in sendrecvbuf_.
 *                     If the result of Allreduce can be recovered directly, then prepare_func will NOT be called
 * \\param prepare_arg argument used to passed into the lazy preprocessing function
 * \\param _file caller file name used to generate unique cache key
 * \\param _line caller line number used to generate unique cache key
 * \\param _caller caller function name used to generate unique cache key
 */
void AllreduceRobust::Allreduce(void *sendrecvbuf_,
                                size_t type_nbytes,
                                size_t count,
                                ReduceFunction reducer,
                                PreprocFunction prepare_fun,
                                void *prepare_arg,
                                const char* _file,
                                const int _line,
                                const char* _caller) {
  // skip action in single node
  if (world_size == 1 || world_size == -1) {
    if (prepare_fun != NULL) prepare_fun(prepare_arg);
    return;
  }

  // genreate unique allreduce signature
  std::string key = std::string(_file) + ""::"" + std::to_string(_line) + ""::""
    + std::string(_caller) + ""#"" +std::to_string(type_nbytes) + ""x"" + std::to_string(count);

  // try fetch bootstrap allreduce results from cache
  if (!checkpoint_loaded && rabit_bootstrap_cache &&
    GetBootstrapCache(key, sendrecvbuf_, type_nbytes, count) != -1) return;

  double start = utils::GetTime();
  bool recovered = RecoverExec(sendrecvbuf_, type_nbytes * count, 0, seq_counter, cur_cache_seq);

  if (resbuf.LastSeqNo() != -1 &&
    (result_buffer_round == -1 ||
      resbuf.LastSeqNo() % result_buffer_round != rank % result_buffer_round)) {
    resbuf.DropLast();
  }

  if (!recovered && prepare_fun != NULL) prepare_fun(prepare_arg);
  void *temp = resbuf.AllocTemp(type_nbytes, count);
  while (true) {
    if (recovered) {
      std::memcpy(temp, sendrecvbuf_, type_nbytes * count); break;
    } else {
      std::memcpy(temp, sendrecvbuf_, type_nbytes * count);
      if (CheckAndRecover(TryAllreduce(temp, type_nbytes, count, reducer))) {
        std::memcpy(sendrecvbuf_, temp, type_nbytes * count); break;
      } else {
        recovered = RecoverExec(sendrecvbuf_, type_nbytes * count, 0, seq_counter, cur_cache_seq);
      }
    }
  }
  double delta = utils::GetTime() - start;
  // log allreduce latency
  if (rabit_debug) {
    utils::HandleLogInfo(""[%d] allreduce (%s) finished version %d, seq %d, take %f seconds\\n"",
      rank, key.c_str(), version_number, seq_counter, delta);
  }

  // if bootstrap allreduce, store and fetch through cache
  if (checkpoint_loaded || !rabit_bootstrap_cache) {
    resbuf.PushTemp(seq_counter, type_nbytes, count);
    seq_counter += 1;
  } else {
    SetBootstrapCache(key, sendrecvbuf_, type_nbytes, count);
  }
}
/*!
 * \\brief broadcast data from root to all nodes
 * \\param sendrecvbuf_ buffer for both sending and recving data
 * \\param size the size of the data to be broadcasted
 * \\param root the root worker id to broadcast the data
 * \\param _file caller file name used to generate unique cache key
 * \\param _line caller line number used to generate unique cache key
 * \\param _caller caller function name used to generate unique cache key
 */
void AllreduceRobust::Broadcast(void *sendrecvbuf_, size_t total_size, int root,
                                const char* _file,
                                const int _line,
                                const char* _caller) {
  // skip action in single node
  if (world_size == 1 || world_size == -1) return;
  // genreate unique cache signature
  std::string key = std::string(_file) + ""::"" + std::to_string(_line) + ""::""
    + std::string(_caller) + ""#"" +std::to_string(total_size) + ""@"" + std::to_string(root);
  // try fetch bootstrap allreduce results from cache
  if (!checkpoint_loaded && rabit_bootstrap_cache &&
  GetBootstrapCache(key, sendrecvbuf_, total_size, 1) != -1) return;
  double start = utils::GetTime();
  bool recovered = RecoverExec(sendrecvbuf_, total_size, 0, seq_counter, cur_cache_seq);
  // now we are free to remove the last result, if any
  if (resbuf.LastSeqNo() != -1 &&
      (result_buffer_round == -1 ||
       resbuf.LastSeqNo() % result_buffer_round != rank % result_buffer_round)) {
    resbuf.DropLast();
  }
  void *temp = resbuf.AllocTemp(1, total_size);
  while (true) {
    if (recovered) {
      std::memcpy(temp, sendrecvbuf_, total_size); break;
    } else {
      if (CheckAndRecover(TryBroadcast(sendrecvbuf_, total_size, root))) {
        std::memcpy(temp, sendrecvbuf_, total_size); break;
      } else {
        recovered = RecoverExec(sendrecvbuf_, total_size, 0, seq_counter, cur_cache_seq);
      }
    }
  }

  double delta = utils::GetTime() - start;
  // log broadcast latency
  if (rabit_debug) {
    utils::HandleLogInfo(
      ""[%d] broadcast (%s) root %d finished version %d,seq %d, take %f seconds\\n"",
      rank, key.c_str(), root, version_number, seq_counter, delta);
  }
  // if bootstrap broadcast, store and fetch through cache
  if (checkpoint_loaded || !rabit_bootstrap_cache) {
    resbuf.PushTemp(seq_counter, 1, total_size);
    seq_counter += 1;
  } else {
    SetBootstrapCache(key, sendrecvbuf_, total_size, 1);
  }
}
/*!
 * \\brief load latest check point
 * \\param global_model pointer to the globally shared model/state
 *   when calling this function, the caller need to gauranttees that global_model
 *   is the same in all nodes
 * \\param local_model pointer to local model, that is specific to current node/rank
 *   this can be NULL when no local model is needed
 *
 * \\return the version number of check point loaded
 *     if returned version == 0, this means no model has been CheckPointed
 *     the p_model is not touched, user should do necessary initialization by themselves
 *
 *   Common usage example:
 *      int iter = rabit::LoadCheckPoint(&model);
 *      if (iter == 0) model.InitParameters();
 *      for (i = iter; i < max_iter; ++i) {
 *        do many things, include allreduce
 *        rabit::CheckPoint(model);
 *      }
 *
 * \\sa CheckPoint, VersionNumber
 */
int AllreduceRobust::LoadCheckPoint(Serializable *global_model,
                                    Serializable *local_model) {
  checkpoint_loaded = true;
  // skip action in single node
  if (world_size == 1) return 0;
  this->LocalModelCheck(local_model != NULL);
  if (num_local_replica == 0) {
    utils::Check(local_model == NULL,
                 ""need to set rabit_local_replica larger than 1 to checkpoint local_model"");
  }
  double start = utils::GetTime();
  // check if we succeed
  if (RecoverExec(NULL, 0, ActionSummary::kLoadCheck, ActionSummary::kSpecialOp, cur_cache_seq)) {
    int nlocal = std::max(static_cast<int>(local_rptr[local_chkpt_version].size()) - 1, 0);
    if (local_model != NULL) {
      if (nlocal == num_local_replica + 1) {
        // load in local model
        utils::MemoryFixSizeBuffer fs(BeginPtr(local_chkpt[local_chkpt_version]),
                                      local_rptr[local_chkpt_version][1]);
        local_model->Load(&fs);
      } else {
        _assert(nlocal == 0, ""[%d] local model inconsistent, nlocal=%d"", rank, nlocal);
      }
    }
    // reset result buffer
    resbuf.Clear(); seq_counter = 0;
    // load from buffer
    utils::MemoryBufferStream fs(&global_checkpoint);
    if (global_checkpoint.length() == 0) {
      version_number = 0;
    } else {
      _assert(fs.Read(&version_number, sizeof(version_number)) != 0,
                    ""read in version number"");
      global_model->Load(&fs);
      _assert(local_model == NULL || nlocal == num_local_replica + 1,
                    ""local model inconsistent, nlocal=%d"", nlocal);
    }
    // run another phase of check ack, if recovered from data
    _assert(RecoverExec(NULL, 0, ActionSummary::kCheckAck,
      ActionSummary::kSpecialOp, cur_cache_seq), ""check ack must return true"");

    if (!RecoverExec(NULL, 0, ActionSummary::kLoadBootstrapCache, seq_counter, cur_cache_seq)) {
      utils::Printf(""no need to load cache\\n"");
    }
    double delta = utils::GetTime() - start;

    // log broadcast latency
    if (rabit_debug) {
      utils::HandleLogInfo(""[%d] loadcheckpoint size %ld finished version %d, ""
                         ""seq %d, take %f seconds\\n"",
                         rank, global_checkpoint.length(),
                         version_number, seq_counter, delta);
    }
    return version_number;
  } else {
    // log job fresh start
    if (rabit_debug) utils::HandleLogInfo(""[%d] loadcheckpoint reset\\n"", rank);

    // reset result buffer
    resbuf.Clear(); seq_counter = 0; version_number = 0;
    // nothing loaded, a fresh start, everyone init model
    return version_number;
  }
}
/*!
 * \\brief internal consistency check function,
 *  use check to ensure user always call CheckPoint/LoadCheckPoint
 *  with or without local but not both, this function will set the approperiate settings
 *  in the first call of LoadCheckPoint/CheckPoint
 *
 * \\param with_local whether the user calls CheckPoint with local model
 */
void AllreduceRobust::LocalModelCheck(bool with_local) {
  if (use_local_model == -1) {
    if (with_local) {
      use_local_model = 1;
      if (num_local_replica == 0) {
        num_local_replica = default_local_replica;
      }
    } else {
      use_local_model = 0;
      num_local_replica = 0;
    }
  } else {
    utils::Check(use_local_model == static_cast<int>(with_local),
                 ""Can only call Checkpoint/LoadCheckPoint always with""\\
                 ""or without local_model, but not mixed case"");
  }
}
/*!
 * \\brief internal implementation of checkpoint, support both lazy and normal way
 *
 * \\param global_model pointer to the globally shared model/state
 *   when calling this function, the caller need to gauranttees that global_model
 *   is the same in all nodes
 * \\param local_model pointer to local model, that is specific to current node/rank
 *   this can be NULL when no local state is needed
 * \\param lazy_checkpt whether the action is lazy checkpoint
 *
 * \\sa CheckPoint, LazyCheckPoint
 */
void AllreduceRobust::CheckPoint_(const Serializable *global_model,
                                  const Serializable *local_model,
                                  bool lazy_checkpt) {
  // never do check point in single machine mode
  if (world_size == 1) {
    version_number += 1; return;
  }
  double start = utils::GetTime();
  this->LocalModelCheck(local_model != NULL);
  if (num_local_replica == 0) {
    utils::Check(local_model == NULL,
                 ""need to set rabit_local_replica larger than 1 to checkpoint local_model"");
  }
  if (num_local_replica != 0) {
    while (true) {
      if (RecoverExec(NULL, 0, 0, ActionSummary::kLocalCheckPoint)) break;
      // save model to new version place
      int new_version = !local_chkpt_version;

      local_chkpt[new_version].clear();
      utils::MemoryBufferStream fs(&local_chkpt[new_version]);
      if (local_model != NULL) {
        local_model->Save(&fs);
      }
      local_rptr[new_version].clear();
      local_rptr[new_version].push_back(0);
      local_rptr[new_version].push_back(local_chkpt[new_version].length());
      if (CheckAndRecover(TryCheckinLocalState(&local_rptr[new_version],
                                               &local_chkpt[new_version]))) break;
    }
    // run the ack phase, can be true or false
    RecoverExec(NULL, 0, 0, ActionSummary::kLocalCheckAck);
    // switch pointer to new version
    local_chkpt_version = !local_chkpt_version;
  }
  // execute checkpoint, note: when checkpoint existing, load will not happen
  _assert(RecoverExec(NULL, 0, ActionSummary::kCheckPoint,
    ActionSummary::kSpecialOp, cur_cache_seq),
                ""check point must return true"");
  // this is the critical region where we will change all the stored models
  // increase version number
  version_number += 1;
  // save model
  if (lazy_checkpt) {
    global_lazycheck = global_model;
  } else {
    global_checkpoint.resize(0);
    utils::MemoryBufferStream fs(&global_checkpoint);
    fs.Write(&version_number, sizeof(version_number));
    global_model->Save(&fs);
    global_lazycheck = NULL;
  }
  double delta = utils::GetTime() - start;
  // log checkpoint latency
  if (rabit_debug) {
    utils::HandleLogInfo(
      ""[%d] checkpoint finished version %d,seq %d, take %f seconds\\n"",
      rank, version_number, seq_counter, delta);
  }
  start = utils::GetTime();
  // reset result buffer, mark boostrap phase complete
  resbuf.Clear(); seq_counter = 0;
  // execute check ack step, load happens here
  _assert(RecoverExec(NULL, 0, ActionSummary::kCheckAck,
    ActionSummary::kSpecialOp, cur_cache_seq), ""check ack must return true"");

  delta = utils::GetTime() - start;
  // log checkpoint ack latency
  if (rabit_debug) {
    utils::HandleLogInfo(""[%d] checkpoint ack finished version %d, take %f seconds\\n"",
    rank, version_number, delta);
  }
}
/*!
 * \\brief reset the all the existing links by sending Out-of-Band message marker
 *  after this function finishes, all the messages received and sent before in all live links are discarded,
 *  This allows us to get a fresh start after error has happened
 *
 * \\return this function can return kSuccess or kSockError
 *         when kSockError is returned, it simply means there are bad sockets in the links,
 *         and some link recovery proceduer is needed
 */
AllreduceRobust::ReturnType AllreduceRobust::TryResetLinks(void) {
  // number of links
  const int nlink = static_cast<int>(all_links.size());
  for (int i = 0; i < nlink; ++i) {
    all_links[i].InitBuffer(sizeof(int), 1 << 10, reduce_buffer_size);
    all_links[i].ResetSize();
  }
  // read and discard data from all channels until pass mark
  while (true) {
    for (int i = 0; i < nlink; ++i) {
      if (all_links[i].sock.BadSocket()) continue;
      if (all_links[i].size_write == 0) {
        char sig = kOOBReset;
        ssize_t len = all_links[i].sock.Send(&sig, sizeof(sig), MSG_OOB);
        // error will be filtered in next loop
        if (len == sizeof(sig)) all_links[i].size_write = 1;
      }
      if (all_links[i].size_write == 1) {
        char sig = kResetMark;
        ssize_t len = all_links[i].sock.Send(&sig, sizeof(sig));
        if (len == sizeof(sig)) all_links[i].size_write = 2;
      }
    }
    utils::PollHelper rsel;
    bool finished = true;
    for (int i = 0; i < nlink; ++i) {
      if (all_links[i].size_write != 2 && !all_links[i].sock.BadSocket()) {
        rsel.WatchWrite(all_links[i].sock); finished = false;
      }
    }
    if (finished) break;
    // wait to read from the channels to discard data
    rsel.Poll();
  }
  for (int i = 0; i < nlink; ++i) {
    if (!all_links[i].sock.BadSocket()) {
      utils::PollHelper::WaitExcept(all_links[i].sock);
    }
  }
  while (true) {
    utils::PollHelper rsel;
    bool finished = true;
    for (int i = 0; i < nlink; ++i) {
      if (all_links[i].size_read == 0 && !all_links[i].sock.BadSocket()) {
        rsel.WatchRead(all_links[i].sock); finished = false;
      }
    }
    if (finished) break;
    rsel.Poll();
    for (int i = 0; i < nlink; ++i) {
      if (all_links[i].sock.BadSocket()) continue;
      if (all_links[i].size_read == 0) {
        int atmark = all_links[i].sock.AtMark();
        if (atmark < 0) {
          _assert(all_links[i].sock.BadSocket(), ""must already gone bad"");
        } else if (atmark > 0) {
          all_links[i].size_read = 1;
        } else {
          // no at mark, read and discard data
          ssize_t len = all_links[i].sock.Recv(all_links[i].buffer_head, all_links[i].buffer_size);
          if (all_links[i].sock.AtMark()) all_links[i].size_read = 1;
          // zero length, remote closed the connection, close socket
          if (len == 0) all_links[i].sock.Close();
        }
      }
    }
  }
  // start synchronization, use blocking I/O to avoid select
  for (int i = 0; i < nlink; ++i) {
    if (!all_links[i].sock.BadSocket()) {
      char oob_mark;
      all_links[i].sock.SetNonBlock(false);
      ssize_t len = all_links[i].sock.Recv(&oob_mark, sizeof(oob_mark), MSG_WAITALL);
      if (len == 0) {
        all_links[i].sock.Close(); continue;
      } else if (len > 0) {
        _assert(oob_mark == kResetMark, ""wrong oob msg"");
        _assert(all_links[i].sock.AtMark() != 1, ""should already read past mark"");
      } else {
        _assert(errno != EAGAIN|| errno != EWOULDBLOCK, ""BUG"");
      }
      // send out ack
      char ack = kResetAck;
      while (true) {
        len = all_links[i].sock.Send(&ack, sizeof(ack));
        if (len == sizeof(ack)) break;
        if (len == -1) {
          if (errno != EAGAIN && errno != EWOULDBLOCK) break;
        }
      }
    }
  }
  // wait all ack
  for (int i = 0; i < nlink; ++i) {
    if (!all_links[i].sock.BadSocket()) {
      char ack;
      ssize_t len = all_links[i].sock.Recv(&ack, sizeof(ack), MSG_WAITALL);
      if (len == 0) {
        all_links[i].sock.Close(); continue;
      } else if (len > 0) {
        _assert(ack == kResetAck, ""wrong Ack MSG"");
      } else {
        _assert(errno != EAGAIN|| errno != EWOULDBLOCK, ""BUG"");
      }
      // set back to nonblock mode
      all_links[i].sock.SetNonBlock(true);
    }
  }
  for (int i = 0; i < nlink; ++i) {
    if (all_links[i].sock.BadSocket()) return kSockError;
  }
  return kSuccess;
}
/*!
 * \\brief if err_type indicates an error
 *         recover links according to the error type reported
 *        if there is no error, return true
 * \\param err_type the type of error happening in the system
 * \\return true if err_type is kSuccess, false otherwise
 */
bool AllreduceRobust::CheckAndRecover(ReturnType err_type) {
  shutdown_timeout = err_type == kSuccess;
  if (err_type == kSuccess) return true;

  _assert(err_link != NULL, ""must know the error link"");
  recover_counter += 1;
  // async launch timeout task if enable_rabit_timeout is set
  if (rabit_timeout && !rabit_timeout_task.valid()) {
    utils::Printf(""[EXPERIMENTAL] timeout thread expires in %d second(s)\\n"", timeout_sec);
    rabit_timeout_task = std::async(std::launch::async, [=]() {
      if (rabit_debug) {
        utils::Printf(""[%d] timeout thread %ld starts\\n"", rank,
                      std::this_thread::get_id());
      }
      int time = 0;
      // check if rabit recovered every 100ms
      while (time++ < 10 * timeout_sec) {
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
        if (shutdown_timeout.load()) {
          if (rabit_debug) {
            utils::Printf(""[%d] timeout task thread %ld exits\\n"",
              rank, std::this_thread::get_id());
          }
          return true;
        }
      }
      _error(""[%d] exit due to time out %d s\\n"", rank, timeout_sec);
      return false;
    });
  }
  // simple way, shutdown all links
  for (size_t i = 0; i < all_links.size(); ++i) {
    if (!all_links[i].sock.BadSocket()) all_links[i].sock.Close();
  }
  // smooth out traffic to tracker
  std::this_thread::sleep_for(std::chrono::milliseconds(10*rank));
  ReConnectLinks(""recover"");
  return false;
}
/*!
 * \\brief message passing function, used to decide the
 *        shortest distance to the possible source of data
 * \\param node_value a pair of have_data and size
 *           have_data whether current node have data
 *           size gives the size of data, if current node is kHaveData
 * \\param dist_in the shorest to any data source distance in each direction
 * \\param out_index the edge index of output link
 * \\return the shorest distance result of out edge specified by out_index
 */
inline std::pair<int, size_t>
ShortestDist(const std::pair<bool, size_t> &node_value,
             const std::vector< std::pair<int, size_t> > &dist_in,
             size_t out_index) {
  if (node_value.first) {
    return std::make_pair(1, node_value.second);
  }
  size_t size = 0;
  int res = std::numeric_limits<int>::max();
  for (size_t i = 0; i < dist_in.size(); ++i) {
    if (i == out_index) continue;
    if (dist_in[i].first == std::numeric_limits<int>::max()) continue;
    if (dist_in[i].first + 1 < res) {
      res = dist_in[i].first + 1;
      size = dist_in[i].second;
    }
  }
  // add one hop

  return std::make_pair(res, size);
}
/*!
 * \\brief message passing function, used to decide the
 *    data request from each edge, whether need to request data from certain edge
 * \\param node_value a pair of request_data and best_link
 *           request_data stores whether current node need to request data
 *           best_link gives the best edge index to fetch the data
 * \\param req_in the data request from incoming edges
 * \\param out_index the edge index of output link
 * \\return the request to the output edge
 */
inline char DataRequest(const std::pair<bool, int> &node_value,
                        const std::vector<char> &req_in,
                        size_t out_index) {
  // whether current node need to request data
  bool request_data = node_value.first;
  // which edge index is the best link to request data
  // can be -1, which means current node contains data
  const int best_link = node_value.second;
  if (static_cast<int>(out_index) == best_link) {
    if (request_data) return 1;
    for (size_t i = 0; i < req_in.size(); ++i) {
      if (i == out_index) continue;
      if (req_in[i] != 0) return 1;
    }
  }
  return 0;
}
/*!
 * \\brief try to decide the recovery message passing request
 * \\param role the current role of the node
 * \\param p_size used to store the size of the message, for node in state kHaveData,
 *               this size must be set correctly before calling the function
 *               for others, this surves as output parameter
 *
 * \\param p_recvlink used to store the link current node should recv data from, if necessary
 *          this can be -1, which means current node have the data
 * \\param p_req_in used to store the resulting vector, indicating which link we should send the data to
 *
 * \\return this function can return kSuccess/kSockError/kGetExcept, see ReturnType for details
 * \\sa ReturnType
 */
AllreduceRobust::ReturnType
AllreduceRobust::TryDecideRouting(AllreduceRobust::RecoverType role,
                                  size_t *p_size,
                                  int *p_recvlink,
                                  std::vector<bool> *p_req_in) {
  int best_link = -2;
  {
    // get the shortest distance to the request point
    std::vector<std::pair<int, size_t> > dist_in, dist_out;

    ReturnType succ = MsgPassing(std::make_pair(role == kHaveData, *p_size),
                                 &dist_in, &dist_out, ShortestDist);
    if (succ != kSuccess) return succ;
    if (role != kHaveData) {
      for (size_t i = 0; i < dist_in.size(); ++i) {
        if (dist_in[i].first != std::numeric_limits<int>::max()) {
          utils::Check(best_link == -2 || *p_size == dist_in[i].second,
                       ""[%d] Allreduce size inconsistent, distin=%lu, size=%lu, reporting=%lu\\n"",
                       rank, dist_in[i].first, *p_size, dist_in[i].second);
          if (best_link == -2 || dist_in[i].first < dist_in[best_link].first) {
            best_link = static_cast<int>(i);
            *p_size = dist_in[i].second;
          }
        }
      }
      utils::Check(best_link != -2, ""Too many nodes went down and we cannot recover.."");
    } else {
      best_link = -1;
    }
  }
  // get the node request
  std::vector<char> req_in, req_out;
  ReturnType succ = MsgPassing(std::make_pair(role == kRequestData, best_link),
                               &req_in, &req_out, DataRequest);
  if (succ != kSuccess) return succ;
  // set p_req_in
  p_req_in->resize(req_in.size());
  for (size_t i = 0; i < req_in.size(); ++i) {
    // set p_req_in
    (*p_req_in)[i] = (req_in[i] != 0);
    if (req_out[i] != 0) {
      _assert(req_in[i] == 0, ""cannot get and receive request"");
      _assert(static_cast<int>(i) == best_link, ""request result inconsistent"");
    }
  }
  *p_recvlink = best_link;
  return kSuccess;
}
/*!
 * \\brief try to finish the data recovery request,
 *        this function is used together with TryDecideRouting
 * \\param role the current role of the node
 * \\param sendrecvbuf_ the buffer to store the data to be sent/recived
 *          - if the role is kHaveData, this stores the data to be sent
 *          - if the role is kRequestData, this is the buffer to store the result
 *          - if the role is kPassData, this will not be used, and can be NULL
 * \\param size the size of the data, obtained from TryDecideRouting
 * \\param recv_link the link index to receive data, if necessary, obtained from TryDecideRouting
 * \\param req_in the request of each link to send data, obtained from TryDecideRouting
 *
 * \\return this function can return kSuccess/kSockError/kGetExcept, see ReturnType for details
 * \\sa ReturnType, TryDecideRouting
 */
AllreduceRobust::ReturnType
AllreduceRobust::TryRecoverData(RecoverType role,
                                void *sendrecvbuf_,
                                size_t size,
                                int recv_link,
                                const std::vector<bool> &req_in) {
  RefLinkVector &links = tree_links;
  // no need to run recovery for zero size messages
  if (links.size() == 0 || size == 0) return kSuccess;
  _assert(req_in.size() == links.size(), ""TryRecoverData"");
  const int nlink = static_cast<int>(links.size());
  {
    bool req_data = role == kRequestData;
    for (int i = 0; i < nlink; ++i) {
      if (req_in[i]) {
        _assert(i != recv_link, ""TryDecideRouting"");
        req_data = true;
      }
    }
    // do not need to provide data or receive data, directly exit
    if (!req_data) return kSuccess;
  }
  _assert(recv_link >= 0 || role == kHaveData, ""recv_link must be active"");
  if (role == kPassData) {
    links[recv_link].InitBuffer(1, size, reduce_buffer_size);
  }
  for (int i = 0; i < nlink; ++i) {
    links[i].ResetSize();
  }
  while (true) {
    bool finished = true;
    utils::PollHelper watcher;
    for (int i = 0; i < nlink; ++i) {
      if (i == recv_link && links[i].size_read != size) {
        watcher.WatchRead(links[i].sock);
        finished = false;
      }
      if (req_in[i] && links[i].size_write != size) {
        if (role == kHaveData ||
            (links[recv_link].size_read != links[i].size_write)) {
          watcher.WatchWrite(links[i].sock);
        }
        finished = false;
      }
      watcher.WatchException(links[i].sock);
    }
    if (finished) break;
    watcher.Poll();
    // exception handling
    for (int i = 0; i < nlink; ++i) {
      if (watcher.CheckExcept(links[i].sock)) {
        return ReportError(&links[i], kGetExcept);
      }
    }
    if (role == kRequestData) {
      const int pid = recv_link;
      if (watcher.CheckRead(links[pid].sock)) {
        ReturnType ret = links[pid].ReadToArray(sendrecvbuf_, size);
        if (ret != kSuccess) {
          return ReportError(&links[pid], ret);
        }
      }
      for (int i = 0; i < nlink; ++i) {
        if (req_in[i] && links[i].size_write != links[pid].size_read) {
          ReturnType ret = links[i].WriteFromArray(sendrecvbuf_, links[pid].size_read);
          if (ret != kSuccess) {
            return ReportError(&links[i], ret);
          }
        }
      }
    }
    if (role == kHaveData) {
      for (int i = 0; i < nlink; ++i) {
        if (req_in[i] && links[i].size_write != size) {
          ReturnType ret = links[i].WriteFromArray(sendrecvbuf_, size);
          if (ret != kSuccess) {
            return ReportError(&links[i], ret);
          }
        }
      }
    }
    if (role == kPassData) {
      const int pid = recv_link;
      const size_t buffer_size = links[pid].buffer_size;
      if (watcher.CheckRead(links[pid].sock)) {
        size_t min_write = size;
        for (int i = 0; i < nlink; ++i) {
          if (req_in[i]) min_write = std::min(links[i].size_write, min_write);
        }
        _assert(min_write <= links[pid].size_read, ""boundary check"");
        ReturnType ret = links[pid].ReadToRingBuffer(min_write, size);
        if (ret != kSuccess) {
          return ReportError(&links[pid], ret);
        }
      }
      for (int i = 0; i < nlink; ++i) {
        if (req_in[i] && links[pid].size_read != links[i].size_write) {
          size_t start = links[i].size_write % buffer_size;
          // send out data from ring buffer
          size_t nwrite = std::min(buffer_size - start, links[pid].size_read - links[i].size_write);
          ssize_t len = links[i].sock.Send(links[pid].buffer_head + start, nwrite);
          if (len != -1) {
            links[i].size_write += len;
          } else {
            ReturnType ret = Errno2Return();
            if (ret != kSuccess) return ReportError(&links[i], ret);
          }
        }
      }
    }
  }
  return kSuccess;
}
/*!
 * \\brief try to fetch allreduce/broadcast results from rest of nodes
 *  as collaberative function called by all nodes, only requester node
 *  will pass seqno to rest of nodes and reconstruct/backfill sendrecvbuf_
 *  of specific seqno from other nodes.
 */
AllreduceRobust::ReturnType AllreduceRobust::TryRestoreCache(bool requester,
  const int min_seq, const int max_seq) {
  // clear requester and rebuild from those with most cache entries
  if (requester) {
    _assert(cur_cache_seq <= max_seq, ""requester is expected to have fewer cache entries"");
    cachebuf.Clear();
    lookupbuf.Clear();
    cur_cache_seq = 0;
  }
  RecoverType role = requester ? kRequestData : kHaveData;
  size_t size = 1;
  int recv_link;
  std::vector<bool> req_in;
  ReturnType ret = TryDecideRouting(role, &size, &recv_link, &req_in);
  if (ret != kSuccess) return ret;
  // only recover missing cache entries in requester
  // as tryrecoverdata is collective call, need to go through entire cache
  // and only work on those missing
  for (int i = 0; i < max_seq; i++) {
    // restore lookup map
    size_t cache_size = 0;
    void* key = lookupbuf.Query(i, &cache_size);
    ret = TryRecoverData(role, &cache_size, sizeof(size_t), recv_link, req_in);
    if (ret != kSuccess) return ret;
    if (requester) {
      key = lookupbuf.AllocTemp(cache_size, 1);
      lookupbuf.PushTemp(i, cache_size, 1);
    }
    ret = TryRecoverData(role, key, cache_size, recv_link, req_in);
    if (ret != kSuccess) return ret;
    // restore cache content
    cache_size = 0;
    void* buf = cachebuf.Query(i, &cache_size);
    ret = TryRecoverData(role, &cache_size, sizeof(size_t), recv_link, req_in);
    if (requester) {
      buf = cachebuf.AllocTemp(cache_size, 1);
      cachebuf.PushTemp(i, cache_size, 1);
      cur_cache_seq +=1;
    }
    ret = TryRecoverData(role, buf, cache_size, recv_link, req_in);
    if (ret != kSuccess) return ret;
  }

  return kSuccess;
}

/*!
 * \\brief try to load check point
 *
 *        This is a collaborative function called by all nodes
 *        only the nodes with requester set to true really needs to load the check point
 *        other nodes acts as collaborative roles to complete this request
 *
 * \\param requester whether current node is the requester
 * \\return this function can return kSuccess/kSockError/kGetExcept, see ReturnType for details
 * \\sa ReturnType
 */
AllreduceRobust::ReturnType AllreduceRobust::TryLoadCheckPoint(bool requester) {
  // check in local data
  RecoverType role =  requester ? kRequestData : kHaveData;
  ReturnType succ;
  if (num_local_replica != 0) {
    if (requester) {
      // clear existing history, if any, before load
      local_rptr[local_chkpt_version].clear();
      local_chkpt[local_chkpt_version].clear();
    }
    // recover local checkpoint
    succ = TryRecoverLocalState(&local_rptr[local_chkpt_version],
                                &local_chkpt[local_chkpt_version]);
    if (succ != kSuccess) return succ;
    int nlocal = std::max(static_cast<int>(local_rptr[local_chkpt_version].size()) - 1, 0);
    // check if everyone is OK
    unsigned state = 0;
    if (nlocal == num_local_replica + 1) {
      // complete recovery
      state = 1;
    } else if (nlocal == 0) {
      // get nothing
      state = 2;
    } else {
      // partially complete state
      state = 4;
    }
    succ = TryAllreduce(&state, sizeof(state), 1, op::Reducer<op::BitOR, unsigned>);
    if (succ != kSuccess) return succ;
    utils::Check(state == 1 || state == 2,
                 ""LoadCheckPoint: too many nodes fails, cannot recover local state"");
  }
  // do call save model if the checkpoint was lazy
  if (role == kHaveData && global_lazycheck != NULL) {
    global_checkpoint.resize(0);
    utils::MemoryBufferStream fs(&global_checkpoint);
    fs.Write(&version_number, sizeof(version_number));
    global_lazycheck->Save(&fs);
    global_lazycheck = NULL;
  }
  // recover global checkpoint
  size_t size = this->global_checkpoint.length();
  int recv_link;
  std::vector<bool> req_in;
  succ = TryDecideRouting(role, &size, &recv_link, &req_in);
  if (succ != kSuccess) return succ;
  if (role == kRequestData) {
    global_checkpoint.resize(size);
  }
  if (size == 0) return kSuccess;
  return TryRecoverData(role, BeginPtr(global_checkpoint), size, recv_link, req_in);
}
/*!
 * \\brief try to get the result of operation specified by seqno
 *
 *        This is a collaborative function called by all nodes
 *        only the nodes with requester set to true really needs to get the result
 *        other nodes acts as collaborative roles to complete this request
 *
 * \\param buf the buffer to store the result, this parameter is only used when current node is requester
 * \\param size the total size of the buffer, this parameter is only used when current node is requester
 * \\param seqno sequence number of the operation, this is unique index of a operation in current iteration
 * \\param requester whether current node is the requester
 * \\return this function can return kSuccess/kSockError/kGetExcept, see ReturnType for details
 * \\sa ReturnType
 */
AllreduceRobust::ReturnType
AllreduceRobust::TryGetResult(void *sendrecvbuf, size_t size, int seqno, bool requester) {
  // if minimum sequence requested is local check point ack,
  // this means all nodes have finished local check point, directly return
  if (seqno == ActionSummary::kLocalCheckAck) return kSuccess;
  if (seqno == ActionSummary::kLocalCheckPoint) {
    // new version of local model
    int new_version = !local_chkpt_version;
    int nlocal = std::max(static_cast<int>(local_rptr[new_version].size()) - 1, 0);
    // if we goes to this place, use must have already setup the state once
    _assert(nlocal == 1 || nlocal == num_local_replica + 1,
                  ""TryGetResult::Checkpoint"");
    return TryRecoverLocalState(&local_rptr[new_version], &local_chkpt[new_version]);
  }

  // handles normal data recovery
  RecoverType role;
  if (!requester) {
    sendrecvbuf = resbuf.Query(seqno, &size);
    role = sendrecvbuf != NULL ? kHaveData : kPassData;
  } else {
    role = kRequestData;
  }
  int recv_link;
  std::vector<bool> req_in;
  // size of data
  size_t data_size = size;
  ReturnType succ = TryDecideRouting(role, &data_size, &recv_link, &req_in);
  if (succ != kSuccess) return succ;
  utils::Check(data_size != 0, ""zero size check point is not allowed"");
  if (role == kRequestData || role == kHaveData) {
    utils::Check(data_size == size,
                 ""Allreduce Recovered data size do not match the specification of function call.\\n""\\
                 ""Please check if calling sequence of recovered program is the "" \\
                 ""same the original one in current VersionNumber"");
  }
  return TryRecoverData(role, sendrecvbuf, data_size, recv_link, req_in);
}
/*!
 * \\brief try to run recover execution for a request action described by flag and seqno,
 *        the function will keep blocking to run possible recovery operations before the specified action,
 *        until the requested result is received by a recovering procedure,
 *        or the function discovers that the requested action is not yet executed, and return false
 *
 * \\param buf the buffer to store the result
 * \\param size the total size of the buffer
 * \\param flag flag information about the action \\sa ActionSummary
 * \\param seqno sequence number of the action, if it is special action with flag set,
 *              seqno needs to be set to ActionSummary::kSpecialOp
 *
 * \\return if this function can return true or false
 *    - true means buf already set to the
 *           result by recovering procedure, the action is complete, no further action is needed
 *    - false means this is the lastest action that has not yet been executed, need to execute the action
 */
bool AllreduceRobust::RecoverExec(void *buf, size_t size, int flag, int seqno,
                                  int cache_seqno, const char* caller) {
  // kLoadBootstrapCache should be treated similar as allreduce
  // when loadcheck/check/checkack runs in other nodes
  if (flag != 0 && flag != ActionSummary::kLoadBootstrapCache) {
    _assert(seqno == ActionSummary::kSpecialOp, ""must only set seqno for normal operations"");
  }

  std::string msg = std::string(caller) + "" pass negative seqno ""
    + std::to_string(seqno) + "" flag "" + std::to_string(flag)
    + "" version "" + std::to_string(version_number);
  _assert(seqno >=0, msg.c_str());

  ActionSummary req(flag, flag, seqno, cache_seqno);

  while (true) {
    this->ReportStatus();
    // copy to action and send to allreduce with other nodes
    ActionSummary act = req;
    // get the reduced action
    if (!CheckAndRecover(TryAllreduce(&act, sizeof(act), 1, ActionSummary::Reducer))) continue;

    if (act.check_ack()) {
      if (act.check_point()) {
        // if we also have check_point, do check point first
        _assert(!act.diff_seq(),
                      ""check ack & check pt  cannot occur together with normal ops"");
        // if we requested checkpoint, we are free to go
        if (req.check_point()) return true;
      } else if (act.load_check()) {
        // if there is only check_ack and load_check, do load_check
        if (!CheckAndRecover(TryLoadCheckPoint(req.load_check()))) continue;
        // if requested load check, then misson complete
        if (req.load_check()) return true;
      } else {
        // there is no check point and no load check, execute check ack
        if (req.check_ack()) return true;
      }
      // if execute to this point
      // this means the action requested has not been completed
      // try next round
    } else {
      if (act.check_point()) {
        if (act.diff_seq()) {
          _assert(act.seqno() != ActionSummary::kSpecialOp, ""min seq bug"");
          // print checkpoint consensus flag if user turn on debug
          if (rabit_debug) {
            req.print_flags(rank, ""checkpoint req"");
            act.print_flags(rank, ""checkpoint act"");
          }
          /*
           * Chen Qin
           * at least one hit checkpoint_ code & at least one not hitting
           * compare with version_number of req.check_point() set true with rest
           * expect to be equal, means rest fall behind in sequence
           * use resbuf resbuf to recover
           * worker-0           worker-1
           * checkpoint(n-1)    checkpoint(n-1)
           * allreduce          allreduce (requester) |
           * broadcast                                V
           * checkpoint(n req)
           * after catch up to checkpoint n, diff_seq will be false
           * */
          // assume requester is falling behind
          bool requester = req.seqno() == act.seqno();
          // if not load cache
          if (!act.load_cache()) {
            if (act.seqno() > 0) {
              if (!requester) {
                _assert(req.check_point(), ""checkpoint node should be KHaveData role"");
                buf = resbuf.Query(act.seqno(), &size);
                _assert(buf != NULL, ""buf should have data from resbuf"");
                _assert(size > 0, ""buf size should be greater than 0"");
              }
              if (!CheckAndRecover(TryGetResult(buf, size, act.seqno(), requester))) continue;
            }
          } else {
            // cache seq no should be smaller than kSpecialOp
            _assert(act.seqno(SeqType::kCache) != ActionSummary::kSpecialOp,
              ""checkpoint with kSpecialOp"");
            int max_cache_seq = cur_cache_seq;
            if (TryAllreduce(&max_cache_seq, sizeof(max_cache_seq), 1,
              op::Reducer<op::Max, unsigned>) != kSuccess) continue;

            if (TryRestoreCache(req.load_cache(), act.seqno(), max_cache_seq)
              != kSuccess) continue;
          }
          if (requester) return true;
        } else  {
          // no difference in seq no, means we are free to check point
          if (req.check_point()) return true;
        }
      } else {
        // no check point
        if (act.load_check()) {
          // all the nodes called load_check, this is an incomplete action
          if (!act.diff_seq()) return false;
          // load check have higher priority, do load_check
          if (!CheckAndRecover(TryLoadCheckPoint(req.load_check()))) continue;
          // if requested load check, then misson complete
          if (req.load_check()) return true;
        } else {
          // run all nodes in a isolated cache restore logic
          if (act.load_cache()) {
            // print checkpoint consensus flag if user turn on debug
            if (rabit_debug) {
              req.print_flags(rank, ""loadcache req"");
              act.print_flags(rank, ""loadcache act"");
            }
            // load cache should not running in parralel with other states
            _assert(!act.load_check(),
              ""load cache state expect no nodes doing load checkpoint"");
            _assert(!act.check_point() ,
              ""load cache state expect no nodes doing checkpoint"");
            _assert(!act.check_ack(),
              ""load cache state expect no nodes doing checkpoint ack"");

            // if all nodes are requester in load cache, skip
            if (act.load_cache(SeqType::kCache)) return false;

            // bootstrap cache always restore before loadcheckpoint
            // requester always have seq diff with non requester
            if (act.diff_seq()) {
              // restore cache failed, retry from what's left
              if (TryRestoreCache(req.load_cache(), act.seqno(), act.seqno(SeqType::kCache))
                != kSuccess) continue;
            }
            // if requested load cache, then mission complete
            if (req.load_cache()) return true;
            continue;
          }

          // assert no req with load cache set goes into seq catch up
          _assert(!req.load_cache(), ""load cache not interacte with rest states"");

          // no special flags, no checkpoint, check ack, load_check
          _assert(act.seqno() != ActionSummary::kSpecialOp, ""min seq bug"");
          if (act.diff_seq()) {
            bool requester = req.seqno() == act.seqno();
            if (!CheckAndRecover(TryGetResult(buf, size, act.seqno(), requester))) continue;
            if (requester) return true;
          } else {
            // all the request is same,
            // this is most recent command that is yet to be executed
            return false;
          }
        }
      }
      // something is still incomplete try next round
    }
  }
  _assert(false, ""RecoverExec: should not reach here"");
  return true;
}
/*!
 * \\brief try to recover the local state, making each local state to be the result of itself
 *        plus replication of states in previous num_local_replica hops in the ring
 *
 * The input parameters must contain the valid local states available in current nodes,
 * This function try ist best to ""complete"" the missing parts of local_rptr and local_chkpt
 * If there is sufficient information in the ring, when the function returns, local_chkpt will
 * contain num_local_replica + 1 checkpoints (including the chkpt of this node)
 * If there is no sufficient information in the ring, this function the number of checkpoints
 * will be less than the specified value
 *
 * \\param p_local_rptr the pointer to the segment pointers in the states array
 * \\param p_local_chkpt the pointer to the storage of local check points
 * \\return this function can return kSuccess/kSockError/kGetExcept, see ReturnType for details
 * \\sa ReturnType
 */
AllreduceRobust::ReturnType
AllreduceRobust::TryRecoverLocalState(std::vector<size_t> *p_local_rptr,
                                      std::string *p_local_chkpt) {
  // if there is no local replica, we can do nothing
  if (num_local_replica == 0) return kSuccess;
  std::vector<size_t> &rptr = *p_local_rptr;
  std::string &chkpt = *p_local_chkpt;
  if (rptr.size() == 0) {
    rptr.push_back(0);
    _assert(chkpt.length() == 0, ""local chkpt space inconsistent"");
  }
  const int n = num_local_replica;
  {
    // backward passing, passing state in backward direction of the ring
    const int nlocal = static_cast<int>(rptr.size() - 1);
    _assert(nlocal <= n + 1, ""invalid local replica"");
    std::vector<int> msg_back(n + 1);
    msg_back[0] = nlocal;
    // backward passing one hop the request
    ReturnType succ;
    succ = RingPassing(BeginPtr(msg_back),
                       1 * sizeof(int), (n+1) * sizeof(int),
                       0 * sizeof(int), n * sizeof(int),
                       ring_next, ring_prev);
    if (succ != kSuccess) return succ;
    int msg_forward[2];
    msg_forward[0] = nlocal;
    succ = RingPassing(msg_forward,
                       1 * sizeof(int), 2 * sizeof(int),
                       0 * sizeof(int), 1 * sizeof(int),
                       ring_prev, ring_next);
    if (succ != kSuccess) return succ;
    // calculate the number of things we can read from next link
    int nread_end = nlocal;
    for (int i = 1; i <= n; ++i) {
      nread_end = std::max(nread_end, msg_back[i] - i);
    }
    // gives the size of forward
    int nwrite_start = std::min(msg_forward[1] + 1, nread_end);
    // get the size of each segments
    std::vector<size_t> sizes(nread_end);
    for (int i = 0; i < nlocal; ++i) {
      sizes[i] = rptr[i + 1] - rptr[i];
    }
    // pass size through the link
    succ = RingPassing(BeginPtr(sizes),
                       nlocal * sizeof(size_t),
                       nread_end * sizeof(size_t),
                       nwrite_start * sizeof(size_t),
                       nread_end * sizeof(size_t),
                       ring_next, ring_prev);
    if (succ != kSuccess) return succ;
    // update rptr
    rptr.resize(nread_end + 1);
    for (int i = nlocal; i < nread_end; ++i) {
      rptr[i + 1] = rptr[i] + sizes[i];
    }
    chkpt.resize(rptr.back());
    // pass data through the link
    succ = RingPassing(BeginPtr(chkpt), rptr[nlocal], rptr[nread_end],
                       rptr[nwrite_start], rptr[nread_end],
                       ring_next, ring_prev);
    if (succ != kSuccess) {
      rptr.resize(nlocal + 1); chkpt.resize(rptr.back()); return succ;
    }
  }
  {
    // forward passing, passing state in forward direction of the ring
    const int nlocal = static_cast<int>(rptr.size() - 1);
    _assert(nlocal <= n + 1, ""invalid local replica"");
    std::vector<int> msg_forward(n + 1);
    msg_forward[0] = nlocal;
    // backward passing one hop the request
    ReturnType succ;
    succ = RingPassing(BeginPtr(msg_forward),
                       1 * sizeof(int), (n+1) * sizeof(int),
                       0 * sizeof(int), n * sizeof(int),
                       ring_prev, ring_next);
    if (succ != kSuccess) return succ;
    int msg_back[2];
    msg_back[0] = nlocal;
    succ = RingPassing(msg_back,
                       1 * sizeof(int), 2 * sizeof(int),
                       0 * sizeof(int), 1 * sizeof(int),
                       ring_next, ring_prev);
    if (succ != kSuccess) return succ;
    // calculate the number of things we can read from next link
    int nread_end = nlocal, nwrite_end = 1;
    // have to have itself in order to get other data from prev link
    if (nlocal != 0) {
      for (int i = 1; i <= n; ++i) {
        if (msg_forward[i] == 0) break;
        nread_end = std::max(nread_end, i + 1);
        nwrite_end = i + 1;
      }
      if (nwrite_end > n) nwrite_end = n;
    } else  {
      nread_end = 0; nwrite_end = 0;
    }
    // gives the size of forward
    int nwrite_start = std::min(msg_back[1] - 1, nwrite_end);
    // next node miss the state of itself, cannot recover
    if (nwrite_start < 0) nwrite_start = nwrite_end = 0;
    // get the size of each segments
    std::vector<size_t> sizes(nread_end);
    for (int i = 0; i < nlocal; ++i) {
      sizes[i] = rptr[i + 1] - rptr[i];
    }
    // pass size through the link, check consistency
    succ = RingPassing(BeginPtr(sizes),
                       nlocal * sizeof(size_t),
                       nread_end * sizeof(size_t),
                       nwrite_start * sizeof(size_t),
                       nwrite_end * sizeof(size_t),
                       ring_prev, ring_next);
    if (succ != kSuccess) return succ;
    // update rptr
    rptr.resize(nread_end + 1);
    for (int i = nlocal; i < nread_end; ++i) {
      rptr[i + 1] = rptr[i] + sizes[i];
    }
    chkpt.resize(rptr.back());
    // pass data through the link
    succ = RingPassing(BeginPtr(chkpt), rptr[nlocal], rptr[nread_end],
                       rptr[nwrite_start], rptr[nwrite_end],
                       ring_prev, ring_next);
    if (succ != kSuccess) {
      rptr.resize(nlocal + 1); chkpt.resize(rptr.back()); return succ;
    }
  }
  return kSuccess;
}
/*!
 * \\brief try to checkpoint local state, this function is called in normal executation phase
 *    of checkpoint that contains local state
 *  the input state must exactly one saved state(local state of current node),
 *  after complete, this function will get local state from previous num_local_replica nodes and put them
 *  into local_chkpt and local_rptr
 *
 *  It is also OK to call TryRecoverLocalState instead,
 *  TryRecoverLocalState makes less assumption about the input, and requires more communications
 *
 * \\param p_local_rptr the pointer to the segment pointers in the states array
 * \\param p_local_chkpt the pointer to the storage of local check points
 * \\return this function can return kSuccess/kSockError/kGetExcept, see ReturnType for details
 * \\sa ReturnType, TryRecoverLocalState
 */
AllreduceRobust::ReturnType
AllreduceRobust::TryCheckinLocalState(std::vector<size_t> *p_local_rptr,
                                      std::string *p_local_chkpt) {
  // if there is no local replica, we can do nothing
  if (num_local_replica == 0) return kSuccess;
  std::vector<size_t> &rptr = *p_local_rptr;
  std::string &chkpt = *p_local_chkpt;
  _assert(rptr.size() == 2,
                ""TryCheckinLocalState must have exactly 1 state"");
  const int n = num_local_replica;
  std::vector<size_t> sizes(n + 1);
  sizes[0] = rptr[1] - rptr[0];
  ReturnType succ;
  // pass size through the link
  succ = RingPassing(BeginPtr(sizes),
                     1 * sizeof(size_t),
                     (n + 1) * sizeof(size_t),
                     0 * sizeof(size_t),
                     n * sizeof(size_t),
                     ring_prev, ring_next);
  if (succ != kSuccess) return succ;
  // update rptr
  rptr.resize(n + 2);
  for (int i = 1; i <= n; ++i) {
    rptr[i + 1] = rptr[i] + sizes[i];
  }
  chkpt.resize(rptr.back());
  // pass data through the link
  succ = RingPassing(BeginPtr(chkpt),
                     rptr[1], rptr[n + 1],
                     rptr[0], rptr[n],
                     ring_prev, ring_next);
  if (succ != kSuccess) {
    rptr.resize(2); chkpt.resize(rptr.back()); return succ;
  }
  return kSuccess;
}
/*!
 * \\brief perform a ring passing to receive data from prev link, and sent data to next link
 *  this allows data to stream over a ring structure
 *  sendrecvbuf[0:read_ptr] are already provided by current node
 *  current node will recv sendrecvbuf[read_ptr:read_end] from prev link
 *  current node will send sendrecvbuf[write_ptr:write_end] to next link
 *  write_ptr will wait till the data is readed before sending the data
 *  this function requires read_end >= write_end
 *
 * \\param sendrecvbuf_ the place to hold the incoming and outgoing data
 * \\param read_ptr the initial read pointer
 * \\param read_end the ending position to read
 * \\param write_ptr the initial write pointer
 * \\param write_end the ending position to write
 * \\param read_link pointer to link to previous position in ring
 * \\param write_link pointer to link of next position in ring
 */
AllreduceRobust::ReturnType
AllreduceRobust::RingPassing(void *sendrecvbuf_,
                             size_t read_ptr,
                             size_t read_end,
                             size_t write_ptr,
                             size_t write_end,
                             LinkRecord *read_link,
                             LinkRecord *write_link) {
  if (read_link == NULL || write_link == NULL || read_end == 0) return kSuccess;
  _assert(write_end <= read_end,
                ""RingPassing: boundary check1"");
  _assert(read_ptr <= read_end, ""RingPassing: boundary check2"");
  _assert(write_ptr <= write_end, ""RingPassing: boundary check3"");
  // take reference
  LinkRecord &prev = *read_link, &next = *write_link;
  // send recv buffer
  char *buf = reinterpret_cast<char*>(sendrecvbuf_);
  while (true) {
    bool finished = true;
    utils::PollHelper watcher;
    if (read_ptr != read_end) {
      watcher.WatchRead(prev.sock);
      finished = false;
    }
    if (write_ptr < read_ptr && write_ptr != write_end) {
      watcher.WatchWrite(next.sock);
      finished = false;
    }
    watcher.WatchException(prev.sock);
    watcher.WatchException(next.sock);
    if (finished) break;
    watcher.Poll();
    if (watcher.CheckExcept(prev.sock)) return ReportError(&prev, kGetExcept);
    if (watcher.CheckExcept(next.sock)) return ReportError(&next, kGetExcept);
    if (read_ptr != read_end && watcher.CheckRead(prev.sock)) {
      ssize_t len = prev.sock.Recv(buf + read_ptr, read_end - read_ptr);
      if (len == 0) {
        prev.sock.Close(); return ReportError(&prev, kRecvZeroLen);
      }
      if (len != -1) {
        read_ptr += static_cast<size_t>(len);
      } else {
        ReturnType ret = Errno2Return();
        if (ret != kSuccess) return ReportError(&prev, ret);
      }
    }
    if (write_ptr != write_end && write_ptr < read_ptr) {
      size_t nsend = std::min(write_end - write_ptr, read_ptr - write_ptr);
      ssize_t len = next.sock.Send(buf + write_ptr, nsend);
      if (len != -1) {
        write_ptr += static_cast<size_t>(len);
      } else {
        ReturnType ret = Errno2Return();
        if (ret != kSuccess) return ReportError(&prev, ret);
      }
    }
  }
  return kSuccess;
}
}  // namespace engine
}  // namespace rabit
",16280,True,2910.901266092626,median
"/////////////////////////////////////////////////////////////////
/*
MIT License

Copyright (c) 2019 lewis he

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.

axp20x.cpp - Arduino library for X-Power AXP202 chip.
Created by Lewis he on April 1, 2019.
github:https://github.com/lewisxhe/AXP202X_Libraries
*/
/////////////////////////////////////////////////////////////////

#include ""axp20x.h""
#include <math.h>

const uint8_t AXP20X_Class::startupParams[] = {
    0b00000000,
    0b01000000,
    0b10000000,
    0b11000000
};

const uint8_t AXP20X_Class::longPressParams[] = {
    0b00000000,
    0b00010000,
    0b00100000,
    0b00110000
};

const uint8_t AXP20X_Class::shutdownParams[] = {
    0b00000000,
    0b00000001,
    0b00000010,
    0b00000011
};

const uint8_t AXP20X_Class::targetVolParams[] = {
    0b00000000,
    0b00100000,
    0b01000000,
    0b01100000
};



// Power Output Control register
uint8_t AXP20X_Class::_outputReg;

int AXP20X_Class::_axp_probe()
{
    uint8_t data;
    if (_isAxp173) {
        //!Axp173 does not have a chip ID, read the status register to see if it reads normally
        _readByte(0x01, 1, &data);
        if (data == 0 || data == 0xFF) {
            return AXP_FAIL;
        }
        _chip_id = AXP173_CHIP_ID;
        _readByte(AXP202_LDO234_DC23_CTL, 1, &_outputReg);
        AXP_DEBUG(""OUTPUT Register 0x%x\\n"", _outputReg);
        _init = true;
        return AXP_PASS;
    }
    _readByte(AXP202_IC_TYPE, 1, &_chip_id);
    AXP_DEBUG(""chip id detect 0x%x\\n"", _chip_id);
    if (_chip_id == AXP202_CHIP_ID || _chip_id == AXP192_CHIP_ID) {
        AXP_DEBUG(""Detect CHIP :%s\\n"", _chip_id == AXP202_CHIP_ID ? ""AXP202"" : ""AXP192"");
        _readByte(AXP202_LDO234_DC23_CTL, 1, &_outputReg);
        AXP_DEBUG(""OUTPUT Register 0x%x\\n"", _outputReg);
        _init = true;
        return AXP_PASS;
    }
    return AXP_FAIL;
}

int AXP20X_Class::begin(TwoWire &port, uint8_t addr, bool isAxp173)
{
    _i2cPort = &port; //Grab which port the user wants us to use
    _address = addr;
    _isAxp173 = isAxp173;

    return _axp_probe();
}

int AXP20X_Class::begin(axp_com_fptr_t read_cb, axp_com_fptr_t write_cb, uint8_t addr, bool isAxp173)
{
    if (read_cb == nullptr || write_cb == nullptr)return AXP_FAIL;
    _read_cb = read_cb;
    _write_cb = write_cb;
    _address = addr;
    _isAxp173 = isAxp173;
    return _axp_probe();
}

//Only axp192 chip
bool AXP20X_Class::isDCDC1Enable()
{
    if (_chip_id == AXP192_CHIP_ID)
        return IS_OPEN(_outputReg, AXP192_DCDC1);
    else if (_chip_id == AXP173_CHIP_ID)
        return IS_OPEN(_outputReg, AXP173_DCDC1);
    return false;
}

bool AXP20X_Class::isExtenEnable()
{
    if (_chip_id == AXP192_CHIP_ID)
        return IS_OPEN(_outputReg, AXP192_EXTEN);
    else if (_chip_id == AXP202_CHIP_ID)
        return IS_OPEN(_outputReg, AXP202_EXTEN);
    else if (_chip_id == AXP173_CHIP_ID) {
        uint8_t data;
        _readByte(AXP173_EXTEN_DC2_CTL, 1, &data);
        return IS_OPEN(data, AXP173_CTL_EXTEN_BIT);
    }
    return false;
}

bool AXP20X_Class::isLDO2Enable()
{
    if (_chip_id == AXP173_CHIP_ID) {
        return IS_OPEN(_outputReg, AXP173_LDO2);
    }
    //axp192 same axp202 ldo2 bit
    return IS_OPEN(_outputReg, AXP202_LDO2);
}

bool AXP20X_Class::isLDO3Enable()
{
    if (_chip_id == AXP192_CHIP_ID)
        return IS_OPEN(_outputReg, AXP192_LDO3);
    else if (_chip_id == AXP202_CHIP_ID)
        return IS_OPEN(_outputReg, AXP202_LDO3);
    else if (_chip_id == AXP173_CHIP_ID)
        return IS_OPEN(_outputReg, AXP173_LDO3);
    return false;
}

bool AXP20X_Class::isLDO4Enable()
{
    if (_chip_id == AXP202_CHIP_ID)
        return IS_OPEN(_outputReg, AXP202_LDO4);
    if (_chip_id == AXP173_CHIP_ID)
        return IS_OPEN(_outputReg, AXP173_LDO4);
    return false;
}

bool AXP20X_Class::isDCDC2Enable()
{
    if (_chip_id == AXP173_CHIP_ID) {
        uint8_t data;
        _readByte(AXP173_EXTEN_DC2_CTL, 1, &data);
        return IS_OPEN(data, AXP173_CTL_DC2_BIT);
    }
    //axp192 same axp202 dc2 bit
    return IS_OPEN(_outputReg, AXP202_DCDC2);
}

bool AXP20X_Class::isDCDC3Enable()
{
    if (_chip_id == AXP173_CHIP_ID)
        return false;
    //axp192 same axp202 dc3 bit
    return IS_OPEN(_outputReg, AXP202_DCDC3);
}

int AXP20X_Class::setPowerOutPut(uint8_t ch, bool en)
{
    uint8_t data;
    uint8_t val = 0;
    if (!_init)
        return AXP_NOT_INIT;

    //! Axp173 cannot use the REG12H register to control
    //! DC2 and EXTEN. It is necessary to control REG10H separately.
    if (_chip_id == AXP173_CHIP_ID) {
        _readByte(AXP173_EXTEN_DC2_CTL, 1, &data);
        if (ch & AXP173_DCDC2) {
            data = en ? data | BIT_MASK(AXP173_CTL_DC2_BIT) : data & (~BIT_MASK(AXP173_CTL_DC2_BIT));
            ch &= (~BIT_MASK(AXP173_DCDC2));
            _writeByte(AXP173_EXTEN_DC2_CTL, 1, &data);
        } else if (ch & AXP173_EXTEN) {
            data = en ? data | BIT_MASK(AXP173_CTL_EXTEN_BIT) : data & (~BIT_MASK(AXP173_CTL_EXTEN_BIT));
            ch &= (~BIT_MASK(AXP173_EXTEN));
            _writeByte(AXP173_EXTEN_DC2_CTL, 1, &data);
        }
    }

    _readByte(AXP202_LDO234_DC23_CTL, 1, &data);
    if (en) {
        data |= (1 << ch);
    } else {
        data &= (~(1 << ch));
    }

    if (_chip_id == AXP202_CHIP_ID) {
        FORCED_OPEN_DCDC3(data); //! Must be forced open in T-Watch
    }

    _writeByte(AXP202_LDO234_DC23_CTL, 1, &data);
    delay(1);
    _readByte(AXP202_LDO234_DC23_CTL, 1, &val);
    if (data == val) {
        _outputReg = val;
        return AXP_PASS;
    }
    return AXP_FAIL;
}

bool AXP20X_Class::isChargeing()
{
    uint8_t reg;
    if (!_init)
        return AXP_NOT_INIT;
    _readByte(AXP202_MODE_CHGSTATUS, 1, &reg);
    return IS_OPEN(reg, 6);
}

bool AXP20X_Class::isBatteryConnect()
{
    uint8_t reg;
    if (!_init)
        return AXP_NOT_INIT;
    _readByte(AXP202_MODE_CHGSTATUS, 1, &reg);
    return IS_OPEN(reg, 5);
}

float AXP20X_Class::getAcinVoltage()
{
    if (!_init)
        return AXP_NOT_INIT;
    return _getRegistResult(AXP202_ACIN_VOL_H8, AXP202_ACIN_VOL_L4) * AXP202_ACIN_VOLTAGE_STEP;
}

float AXP20X_Class::getAcinCurrent()
{
    if (!_init)
        return AXP_NOT_INIT;
    return _getRegistResult(AXP202_ACIN_CUR_H8, AXP202_ACIN_CUR_L4) * AXP202_ACIN_CUR_STEP;
}

float AXP20X_Class::getVbusVoltage()
{
    if (!_init)
        return AXP_NOT_INIT;
    return _getRegistResult(AXP202_VBUS_VOL_H8, AXP202_VBUS_VOL_L4) * AXP202_VBUS_VOLTAGE_STEP;
}

float AXP20X_Class::getVbusCurrent()
{
    if (!_init)
        return AXP_NOT_INIT;
    return _getRegistResult(AXP202_VBUS_CUR_H8, AXP202_VBUS_CUR_L4) * AXP202_VBUS_CUR_STEP;
}

float AXP20X_Class::getTemp()
{
    if (!_init)
        return AXP_NOT_INIT;
    return _getRegistResult(AXP202_INTERNAL_TEMP_H8, AXP202_INTERNAL_TEMP_L4) * AXP202_INTERNAL_TEMP_STEP + AXP202_INTERNAL_TEMP_MIN;
}

float AXP20X_Class::getTSTemp()
{
    if (!_init)
        return AXP_NOT_INIT;
    return _getRegistResult(AXP202_TS_IN_H8, AXP202_TS_IN_L4) * AXP202_TS_PIN_OUT_STEP;
}

float AXP20X_Class::getGPIO0Voltage()
{
    if (!_init)
        return AXP_NOT_INIT;
    return _getRegistResult(AXP202_GPIO0_VOL_ADC_H8, AXP202_GPIO0_VOL_ADC_L4) * AXP202_GPIO0_STEP;
}

float AXP20X_Class::getGPIO1Voltage()
{
    if (!_init)
        return AXP_NOT_INIT;
    return _getRegistResult(AXP202_GPIO1_VOL_ADC_H8, AXP202_GPIO1_VOL_ADC_L4) * AXP202_GPIO1_STEP;
}

/*
Note: the battery power formula:
Pbat =2* register value * Voltage LSB * Current LSB / 1000.
(Voltage LSB is 1.1mV; Current LSB is 0.5mA, and unit of calculation result is mW.)
*/
float AXP20X_Class::getBattInpower()
{
    float rslt;
    uint8_t hv, mv, lv;
    if (!_init)
        return AXP_NOT_INIT;
    _readByte(AXP202_BAT_POWERH8, 1, &hv);
    _readByte(AXP202_BAT_POWERM8, 1, &mv);
    _readByte(AXP202_BAT_POWERL8, 1, &lv);
    rslt = (hv << 16) | (mv << 8) | lv;
    rslt = 2 * rslt * 1.1 * 0.5 / 1000;
    return rslt;
}

float AXP20X_Class::getBattVoltage()
{
    if (!_init)
        return AXP_NOT_INIT;
    return _getRegistResult(AXP202_BAT_AVERVOL_H8, AXP202_BAT_AVERVOL_L4) * AXP202_BATT_VOLTAGE_STEP;
}

float AXP20X_Class::getBattChargeCurrent()
{
    if (!_init)
        return AXP_NOT_INIT;
    switch (_chip_id) {
    case AXP202_CHIP_ID:
        return _getRegistResult(AXP202_BAT_AVERCHGCUR_H8, AXP202_BAT_AVERCHGCUR_L4) * AXP202_BATT_CHARGE_CUR_STEP;
    case AXP192_CHIP_ID:
        return _getRegistH8L5(AXP202_BAT_AVERCHGCUR_H8, AXP202_BAT_AVERCHGCUR_L5) * AXP202_BATT_CHARGE_CUR_STEP;
    default:
        return AXP_FAIL;
    }
}

float AXP20X_Class::getBattDischargeCurrent()
{
    if (!_init)
        return AXP_NOT_INIT;
    return _getRegistH8L5(AXP202_BAT_AVERDISCHGCUR_H8, AXP202_BAT_AVERDISCHGCUR_L5) * AXP202_BATT_DISCHARGE_CUR_STEP;
}

float AXP20X_Class::getSysIPSOUTVoltage()
{
    if (!_init)
        return AXP_NOT_INIT;
    return _getRegistResult(AXP202_APS_AVERVOL_H8, AXP202_APS_AVERVOL_L4);
}

/*
Coulomb calculation formula:
C= 65536 * current LSB *（charge coulomb counter value - discharge coulomb counter value） /
3600 / ADC sample rate. Refer to REG84H setting for ADC sample rate；the current LSB is
0.5mA；unit of the calculation result is mAh. ）
*/
uint32_t AXP20X_Class::getBattChargeCoulomb()
{
    uint8_t buffer[4];
    if (!_init)
        return AXP_NOT_INIT;
    _readByte(0xB0, 4, buffer);
    return (buffer[0] << 24) + (buffer[1] << 16) + (buffer[2] << 8) + buffer[3];
}

uint32_t AXP20X_Class::getBattDischargeCoulomb()
{
    uint8_t buffer[4];
    if (!_init)
        return AXP_NOT_INIT;
    _readByte(0xB4, 4, buffer);
    return (buffer[0] << 24) + (buffer[1] << 16) + (buffer[2] << 8) + buffer[3];
}

float AXP20X_Class::getCoulombData()
{
    if (!_init)
        return AXP_NOT_INIT;
    uint32_t charge = getBattChargeCoulomb(), discharge = getBattDischargeCoulomb();
    uint8_t rate = getAdcSamplingRate();
    float result = 65536.0 * 0.5 * (charge - discharge) / 3600.0 / rate;
    return result;
}


//-------------------------------------------------------
// New Coulomb functions  by MrFlexi
//-------------------------------------------------------

uint8_t AXP20X_Class::getCoulombRegister()
{
    uint8_t buffer;
    if (!_init)
        return AXP_NOT_INIT;
    _readByte(AXP202_COULOMB_CTL, 1, &buffer);
    return buffer;
}


int AXP20X_Class::setCoulombRegister(uint8_t val)
{
    if (!_init)
        return AXP_NOT_INIT;    
    _writeByte(AXP202_COULOMB_CTL, 1, &val);
    return AXP_PASS;
}


int AXP20X_Class::EnableCoulombcounter(void)
{
   
     if (!_init)
        return AXP_NOT_INIT;    
     uint8_t val = 0x80;    
    _writeByte(AXP202_COULOMB_CTL, 1, &val);
    return AXP_PASS;    
}

int AXP20X_Class::DisableCoulombcounter(void)
{
   
     if (!_init)
        return AXP_NOT_INIT;    
     uint8_t val = 0x00;    
    _writeByte(AXP202_COULOMB_CTL, 1, &val);
    return AXP_PASS;    
}

int AXP20X_Class::StopCoulombcounter(void)
{
   
     if (!_init)
        return AXP_NOT_INIT;    
     uint8_t val = 0xB8;    
    _writeByte(AXP202_COULOMB_CTL, 1, &val);
    return AXP_PASS;    
}


int AXP20X_Class::ClearCoulombcounter(void)
{
   
     if (!_init)
        return AXP_NOT_INIT;    
     uint8_t val = 0xA0;    
    _writeByte(AXP202_COULOMB_CTL, 1, &val);
    return AXP_PASS;    
}

//-------------------------------------------------------
// END 
//-------------------------------------------------------



uint8_t AXP20X_Class::getAdcSamplingRate()
{
    //axp192 same axp202 aregister address 0x84
    if (!_init)
        return AXP_NOT_INIT;
    uint8_t val;
    _readByte(AXP202_ADC_SPEED, 1, &val);
    return 25 * (int)pow(2, (val & 0xC0) >> 6);
}

int AXP20X_Class::setAdcSamplingRate(axp_adc_sampling_rate_t rate)
{
    //axp192 same axp202 aregister address 0x84
    if (!_init)
        return AXP_NOT_INIT;
    if (rate > AXP_ADC_SAMPLING_RATE_200HZ)
        return AXP_FAIL;
    uint8_t val;
    _readByte(AXP202_ADC_SPEED, 1, &val);
    uint8_t rw = rate;
    val &= 0x3F;
    val |= (rw << 6);
    _writeByte(AXP202_ADC_SPEED, 1, &val);
    return AXP_PASS;
}

int AXP20X_Class::setTSfunction(axp_ts_pin_function_t func)
{
    //axp192 same axp202 aregister address 0x84
    if (!_init)
        return AXP_NOT_INIT;
    if (func > AXP_TS_PIN_FUNCTION_ADC)
        return AXP_FAIL;
    uint8_t val;
    _readByte(AXP202_ADC_SPEED, 1, &val);
    uint8_t rw = func;
    val &= 0xFA;
    val |= (rw << 2);
    _writeByte(AXP202_ADC_SPEED, 1, &val);
    return AXP_PASS;
}

int AXP20X_Class::setTScurrent(axp_ts_pin_current_t current)
{
    //axp192 same axp202 aregister address 0x84
    if (!_init)
        return AXP_NOT_INIT;
    if (current > AXP_TS_PIN_CURRENT_80UA)
        return AXP_FAIL;
    uint8_t val;
    _readByte(AXP202_ADC_SPEED, 1, &val);
    uint8_t rw = current;
    val &= 0xCF;
    val |= (rw << 4);
    _writeByte(AXP202_ADC_SPEED, 1, &val);
    return AXP_PASS;
}

int AXP20X_Class::setTSmode(axp_ts_pin_mode_t mode)
{
    //axp192 same axp202 aregister address 0x84
    if (!_init)
        return AXP_NOT_INIT;
    if (mode > AXP_TS_PIN_MODE_ENABLE)
        return AXP_FAIL;
    uint8_t val;
    _readByte(AXP202_ADC_SPEED, 1, &val);
    uint8_t rw = mode;
    val &= 0xFC;
    val |= rw;
    _writeByte(AXP202_ADC_SPEED, 1, &val);

    // TS pin ADC function enable/disable
    if (mode == AXP_TS_PIN_MODE_DISABLE)
        adc1Enable(AXP202_TS_PIN_ADC1, false);
    else
        adc1Enable(AXP202_TS_PIN_ADC1, true);
    return AXP_PASS;
}

int AXP20X_Class::adc1Enable(uint16_t params, bool en)
{
    if (!_init)
        return AXP_NOT_INIT;
    uint8_t val;
    _readByte(AXP202_ADC_EN1, 1, &val);
    if (en)
        val |= params;
    else
        val &= ~(params);
    _writeByte(AXP202_ADC_EN1, 1, &val);
    return AXP_PASS;
}

int AXP20X_Class::adc2Enable(uint16_t params, bool en)
{
    if (!_init)
        return AXP_NOT_INIT;
    uint8_t val;
    _readByte(AXP202_ADC_EN2, 1, &val);
    if (en)
        val |= params;
    else
        val &= ~(params);
    _writeByte(AXP202_ADC_EN2, 1, &val);
    return AXP_PASS;
}

int AXP20X_Class::enableIRQ(uint64_t params, bool en)
{
    if (!_init)
        return AXP_NOT_INIT;
    uint8_t val, val1;
    if (params & 0xFF) {
        val1 = params & 0xFF;
        _readByte(AXP202_INTEN1, 1, &val);
        if (en)
            val |= val1;
        else
            val &= ~(val1);
        AXP_DEBUG(""%s [0x%x]val:0x%x\\n"", en ? ""enable"" : ""disable"", AXP202_INTEN1, val);
        _writeByte(AXP202_INTEN1, 1, &val);
    }
    if (params & 0xFF00) {
        val1 = params >> 8;
        _readByte(AXP202_INTEN2, 1, &val);
        if (en)
            val |= val1;
        else
            val &= ~(val1);
        AXP_DEBUG(""%s [0x%x]val:0x%x\\n"", en ? ""enable"" : ""disable"", AXP202_INTEN2, val);
        _writeByte(AXP202_INTEN2, 1, &val);
    }

    if (params & 0xFF0000) {
        val1 = params >> 16;
        _readByte(AXP202_INTEN3, 1, &val);
        if (en)
            val |= val1;
        else
            val &= ~(val1);
        AXP_DEBUG(""%s [0x%x]val:0x%x\\n"", en ? ""enable"" : ""disable"", AXP202_INTEN3, val);
        _writeByte(AXP202_INTEN3, 1, &val);
    }

    if (params & 0xFF000000) {
        val1 = params >> 24;
        _readByte(AXP202_INTEN4, 1, &val);
        if (en)
            val |= val1;
        else
            val &= ~(val1);
        AXP_DEBUG(""%s [0x%x]val:0x%x\\n"", en ? ""enable"" : ""disable"", AXP202_INTEN4, val);
        _writeByte(AXP202_INTEN4, 1, &val);
    }

    if (params & 0xFF00000000) {
        val1 = params >> 32;
        _readByte(AXP202_INTEN5, 1, &val);
        if (en)
            val |= val1;
        else
            val &= ~(val1);
        AXP_DEBUG(""%s [0x%x]val:0x%x\\n"", en ? ""enable"" : ""disable"", AXP202_INTEN5, val);
        _writeByte(AXP202_INTEN5, 1, &val);
    }
    return AXP_PASS;
}

int AXP20X_Class::readIRQ()
{
    if (!_init)
        return AXP_NOT_INIT;
    switch (_chip_id) {
    case AXP192_CHIP_ID:
        for (int i = 0; i < 4; ++i) {
            _readByte(AXP192_INTSTS1 + i, 1, &_irq[i]);
        }
        _readByte(AXP192_INTSTS5, 1, &_irq[4]);
        return AXP_PASS;

    case AXP202_CHIP_ID:
        for (int i = 0; i < 5; ++i) {
            _readByte(AXP202_INTSTS1 + i, 1, &_irq[i]);
        }
        return AXP_PASS;
    default:
        return AXP_FAIL;
    }
}

void AXP20X_Class::clearIRQ()
{
    uint8_t val = 0xFF;
    switch (_chip_id) {
    case AXP192_CHIP_ID:
        for (int i = 0; i < 3; i++) {
            _writeByte(AXP192_INTSTS1 + i, 1, &val);
        }
        _writeByte(AXP192_INTSTS5, 1, &val);
        break;
    case AXP202_CHIP_ID:
        for (int i = 0; i < 5; i++) {
            _writeByte(AXP202_INTSTS1 + i, 1, &val);
        }
        break;
    default:
        break;
    }
    memset(_irq, 0, sizeof(_irq));
}

bool AXP20X_Class::isAcinOverVoltageIRQ()
{
    return (bool)(_irq[0] & BIT_MASK(7));
}

bool AXP20X_Class::isAcinPlugInIRQ()
{
    return (bool)(_irq[0] & BIT_MASK(6));
}

bool AXP20X_Class::isAcinRemoveIRQ()
{
    return (bool)(_irq[0] & BIT_MASK(5));
}

bool AXP20X_Class::isVbusOverVoltageIRQ()
{
    return (bool)(_irq[0] & BIT_MASK(4));
}

bool AXP20X_Class::isVbusPlugInIRQ()
{
    return (bool)(_irq[0] & BIT_MASK(3));
}

bool AXP20X_Class::isVbusRemoveIRQ()
{
    return (bool)(_irq[0] & BIT_MASK(2));
}

bool AXP20X_Class::isVbusLowVHOLDIRQ()
{
    return (bool)(_irq[0] & BIT_MASK(1));
}

bool AXP20X_Class::isBattPlugInIRQ()
{
    return (bool)(_irq[1] & BIT_MASK(7));
}
bool AXP20X_Class::isBattRemoveIRQ()
{
    return (bool)(_irq[1] & BIT_MASK(6));
}
bool AXP20X_Class::isBattEnterActivateIRQ()
{
    return (bool)(_irq[1] & BIT_MASK(5));
}
bool AXP20X_Class::isBattExitActivateIRQ()
{
    return (bool)(_irq[1] & BIT_MASK(4));
}
bool AXP20X_Class::isChargingIRQ()
{
    return (bool)(_irq[1] & BIT_MASK(3));
}
bool AXP20X_Class::isChargingDoneIRQ()
{
    return (bool)(_irq[1] & BIT_MASK(2));
}
bool AXP20X_Class::isBattTempLowIRQ()
{
    return (bool)(_irq[1] & BIT_MASK(1));
}
bool AXP20X_Class::isBattTempHighIRQ()
{
    return (bool)(_irq[1] & BIT_MASK(0));
}

bool AXP20X_Class::isPEKShortPressIRQ()
{
    return (bool)(_irq[2] & BIT_MASK(1));
}

bool AXP20X_Class::isPEKLongtPressIRQ()
{
    return (bool)(_irq[2] & BIT_MASK(0));
}

bool AXP20X_Class::isTimerTimeoutIRQ()
{
    return (bool)(_irq[4] & BIT_MASK(7));
}

bool AXP20X_Class::isVBUSPlug()
{
    if (!_init)
        return AXP_NOT_INIT;
    uint8_t reg;
    _readByte(AXP202_STATUS, 1, &reg);
    return IS_OPEN(reg, 5);
}

int AXP20X_Class::setDCDC2Voltage(uint16_t mv)
{
    if (!_init)
        return AXP_NOT_INIT;
    if (mv < 700) {
        AXP_DEBUG(""DCDC2:Below settable voltage:700mV~2275mV"");
        mv = 700;
    }
    if (mv > 2275) {
        AXP_DEBUG(""DCDC2:Above settable voltage:700mV~2275mV"");
        mv = 2275;
    }
    uint8_t val = (mv - 700) / 25;
    //! axp173/192/202 same register
    _writeByte(AXP202_DC2OUT_VOL, 1, &val);
    return AXP_PASS;
}

uint16_t AXP20X_Class::getDCDC2Voltage()
{
    uint8_t val = 0;
    //! axp173/192/202 same register
    _readByte(AXP202_DC2OUT_VOL, 1, &val);
    return val * 25 + 700;
}

uint16_t AXP20X_Class::getDCDC3Voltage()
{
    if (!_init)
        return 0;
    if (_chip_id == AXP173_CHIP_ID)return AXP_NOT_SUPPORT;
    uint8_t val = 0;
    _readByte(AXP202_DC3OUT_VOL, 1, &val);
    return val * 25 + 700;
}

int AXP20X_Class::setDCDC3Voltage(uint16_t mv)
{
    if (!_init)
        return AXP_NOT_INIT;
    if (_chip_id == AXP173_CHIP_ID)return AXP_NOT_SUPPORT;
    if (mv < 700) {
        AXP_DEBUG(""DCDC3:Below settable voltage:700mV~3500mV"");
        mv = 700;
    }
    if (mv > 3500) {
        AXP_DEBUG(""DCDC3:Above settable voltage:700mV~3500mV"");
        mv = 3500;
    }
    uint8_t val = (mv - 700) / 25;
    _writeByte(AXP202_DC3OUT_VOL, 1, &val);
    return AXP_PASS;
}

int AXP20X_Class::setLDO2Voltage(uint16_t mv)
{
    uint8_t rVal, wVal;
    if (!_init)
        return AXP_NOT_INIT;
    if (mv < 1800) {
        AXP_DEBUG(""LDO2:Below settable voltage:1800mV~3300mV"");
        mv = 1800;
    }
    if (mv > 3300) {
        AXP_DEBUG(""LDO2:Above settable voltage:1800mV~3300mV"");
        mv = 3300;
    }
    wVal = (mv - 1800) / 100;
    if (_chip_id == AXP202_CHIP_ID) {
        _readByte(AXP202_LDO24OUT_VOL, 1, &rVal);
        rVal &= 0x0F;
        rVal |= (wVal << 4);
        _writeByte(AXP202_LDO24OUT_VOL, 1, &rVal);
        return AXP_PASS;
    } else if (_chip_id == AXP192_CHIP_ID || _chip_id == AXP173_CHIP_ID) {
        _readByte(AXP192_LDO23OUT_VOL, 1, &rVal);
        rVal &= 0x0F;
        rVal |= (wVal << 4);
        _writeByte(AXP192_LDO23OUT_VOL, 1, &rVal);
        return AXP_PASS;
    }
    return AXP_FAIL;
}

uint16_t AXP20X_Class::getLDO2Voltage()
{
    uint8_t rVal;
    if (_chip_id == AXP202_CHIP_ID) {
        _readByte(AXP202_LDO24OUT_VOL, 1, &rVal);
        rVal &= 0xF0;
        rVal >>= 4;
        return rVal * 100 + 1800;
    } else if (_chip_id == AXP192_CHIP_ID || _chip_id == AXP173_CHIP_ID ) {
        _readByte(AXP192_LDO23OUT_VOL, 1, &rVal);
        AXP_DEBUG(""get result:%x\\n"", rVal);
        rVal &= 0xF0;
        rVal >>= 4;
        return rVal * 100 + 1800;
    }
    return 0;
}

int AXP20X_Class::setLDO3Voltage(uint16_t mv)
{
    uint8_t rVal;
    if (!_init)
        return AXP_NOT_INIT;
    if (_chip_id == AXP202_CHIP_ID && mv < 700) {
        AXP_DEBUG(""LDO3:Below settable voltage:700mV~3500mV"");
        mv = 700;
    } else if (_chip_id == AXP192_CHIP_ID && mv < 1800) {
        AXP_DEBUG(""LDO3:Below settable voltage:1800mV~3300mV"");
        mv = 1800;
    }

    if (_chip_id == AXP202_CHIP_ID && mv > 3500) {
        AXP_DEBUG(""LDO3:Above settable voltage:700mV~3500mV"");
        mv = 3500;
    } else if (_chip_id == AXP192_CHIP_ID && mv > 3300) {
        AXP_DEBUG(""LDO3:Above settable voltage:1800mV~3300mV"");
        mv = 3300;
    }

    if (_chip_id == AXP202_CHIP_ID) {
        _readByte(AXP202_LDO3OUT_VOL, 1, &rVal);
        rVal &= 0x80;
        rVal |= ((mv - 700) / 25);
        _writeByte(AXP202_LDO3OUT_VOL, 1, &rVal);
        return AXP_PASS;
    } else if (_chip_id == AXP192_CHIP_ID || _chip_id == AXP173_CHIP_ID) {
        _readByte(AXP192_LDO23OUT_VOL, 1, &rVal);
        rVal &= 0xF0;
        rVal |= ((mv - 1800) / 100);
        _writeByte(AXP192_LDO23OUT_VOL, 1, &rVal);
        return AXP_PASS;
    }
    return AXP_FAIL;
}

uint16_t AXP20X_Class::getLDO3Voltage()
{
    uint8_t rVal;
    if (!_init)
        return AXP_NOT_INIT;

    if (_chip_id == AXP202_CHIP_ID) {
        _readByte(AXP202_LDO3OUT_VOL, 1, &rVal);
        if (rVal & 0x80) {
            //! According to the hardware N_VBUSEN Pin selection
            return getVbusVoltage() * 1000;
        } else {
            return (rVal & 0x7F) * 25 + 700;
        }
    } else if (_chip_id == AXP192_CHIP_ID || _chip_id == AXP173_CHIP_ID) {
        _readByte(AXP192_LDO23OUT_VOL, 1, &rVal);
        rVal &= 0x0F;
        return rVal * 100 + 1800;
    }
    return 0;
}

//! Only axp173 support
int AXP20X_Class::setLDO4Voltage(uint16_t mv)
{
    if (!_init)
        return AXP_NOT_INIT;
    if (_chip_id != AXP173_CHIP_ID)
        return AXP_FAIL;

    if (mv < 700) {
        AXP_DEBUG(""LDO4:Below settable voltage:700mV~3500mV"");
        mv = 700;
    }
    if (mv > 3500) {
        AXP_DEBUG(""LDO4:Above settable voltage:700mV~3500mV"");
        mv = 3500;
    }
    uint8_t val = (mv - 700) / 25;
    _writeByte(AXP173_LDO4_VLOTAGE, 1, &val);
    return AXP_PASS;
}

uint16_t AXP20X_Class::getLDO4Voltage()
{
    const uint16_t ldo4_table[] = {1250, 1300, 1400, 1500, 1600, 1700, 1800, 1900, 2000, 2500, 2700, 2800, 3000, 3100, 3200, 3300};
    if (!_init)
        return 0;
    uint8_t val = 0;
    switch (_chip_id) {
    case AXP173_CHIP_ID:
        _readByte(AXP173_LDO4_VLOTAGE, 1, &val);
        return val * 25 + 700;
    case AXP202_CHIP_ID:
        _readByte(AXP202_LDO24OUT_VOL, 1, &val);
        val &= 0xF;
        return ldo4_table[val];
        break;
    case AXP192_CHIP_ID:
    default:
        break;
    }
    return 0;
}


//! Only axp202 support
int AXP20X_Class::setLDO4Voltage(axp_ldo4_table_t param)
{
    if (!_init)
        return AXP_NOT_INIT;
    if (_chip_id == AXP202_CHIP_ID) {
        if (param >= AXP202_LDO4_MAX)
            return AXP_INVALID;
        uint8_t val;
        _readByte(AXP202_LDO24OUT_VOL, 1, &val);
        val &= 0xF0;
        val |= param;
        _writeByte(AXP202_LDO24OUT_VOL, 1, &val);
        return AXP_PASS;
    }
    return AXP_FAIL;
}

//! Only AXP202 support
// 0 : LDO  1 : DCIN
int AXP20X_Class::setLDO3Mode(uint8_t mode)
{
    uint8_t val;
    if (_chip_id != AXP202_CHIP_ID)
        return AXP_FAIL;
    _readByte(AXP202_LDO3OUT_VOL, 1, &val);
    if (mode) {
        val |= BIT_MASK(7);
    } else {
        val &= (~BIT_MASK(7));
    }
    _writeByte(AXP202_LDO3OUT_VOL, 1, &val);
    return AXP_PASS;
}

int AXP20X_Class::setStartupTime(uint8_t param)
{
    uint8_t val;
    if (!_init)
        return AXP_NOT_INIT;
    if (param > sizeof(startupParams) / sizeof(startupParams[0]))
        return AXP_INVALID;
    _readByte(AXP202_POK_SET, 1, &val);
    val &= (~0b11000000);
    val |= startupParams[param];
    _writeByte(AXP202_POK_SET, 1, &val);
    return AXP_PASS;
}

int AXP20X_Class::setlongPressTime(uint8_t param)
{
    uint8_t val;
    if (!_init)
        return AXP_NOT_INIT;
    if (param > sizeof(longPressParams) / sizeof(longPressParams[0]))
        return AXP_INVALID;
    _readByte(AXP202_POK_SET, 1, &val);
    val &= (~0b00110000);
    val |= longPressParams[param];
    _writeByte(AXP202_POK_SET, 1, &val);
    return AXP_PASS;
}

int AXP20X_Class::setShutdownTime(uint8_t param)
{
    uint8_t val;
    if (!_init)
        return AXP_NOT_INIT;
    if (param > sizeof(shutdownParams) / sizeof(shutdownParams[0]))
        return AXP_INVALID;
    _readByte(AXP202_POK_SET, 1, &val);
    val &= (~0b00000011);
    val |= shutdownParams[param];
    _writeByte(AXP202_POK_SET, 1, &val);
    return AXP_PASS;
}

int AXP20X_Class::setTimeOutShutdown(bool en)
{
    uint8_t val;
    if (!_init)
        return AXP_NOT_INIT;
    _readByte(AXP202_POK_SET, 1, &val);
    if (en)
        val |= (1 << 3);
    else
        val &= (~(1 << 3));
    _writeByte(AXP202_POK_SET, 1, &val);
    return AXP_PASS;
}

int AXP20X_Class::shutdown()
{
    uint8_t val;
    if (!_init)
        return AXP_NOT_INIT;
    _readByte(AXP202_OFF_CTL, 1, &val);
    val |= (1 << 7);
    _writeByte(AXP202_OFF_CTL, 1, &val);
    return AXP_PASS;
}

float AXP20X_Class::getSettingChargeCurrent()
{
    uint8_t val;
    if (!_init)
        return AXP_NOT_INIT;
    _readByte(AXP202_CHARGE1, 1, &val);
    val &= 0b00000111;
    float cur = 300.0 + val * 100.0;
    AXP_DEBUG(""Setting Charge current : %.2f mA\\n"", cur);
    return cur;
}

bool AXP20X_Class::isChargeingEnable()
{
    uint8_t val;
    if (!_init)
        return false;
    _readByte(AXP202_CHARGE1, 1, &val);
    if (val & (1 << 7)) {
        AXP_DEBUG(""Charging enable is enable\\n"");
        val = true;
    } else {
        AXP_DEBUG(""Charging enable is disable\\n"");
        val = false;
    }
    return val;
}

int AXP20X_Class::enableChargeing(bool en)
{
    uint8_t val;
    if (!_init)
        return AXP_NOT_INIT;
    _readByte(AXP202_CHARGE1, 1, &val);
    val |= (1 << 7);
    _writeByte(AXP202_CHARGE1, 1, &val);
    return AXP_PASS;
}

int AXP20X_Class::setChargingTargetVoltage(axp_chargeing_vol_t param)
{
    uint8_t val;
    if (!_init)
        return AXP_NOT_INIT;
    if (param > sizeof(targetVolParams) / sizeof(targetVolParams[0]))
        return AXP_INVALID;
    _readByte(AXP202_CHARGE1, 1, &val);
    val &= ~(0b01100000);
    val |= targetVolParams[param];
    _writeByte(AXP202_CHARGE1, 1, &val);
    return AXP_PASS;
}

int AXP20X_Class::getBattPercentage()
{
    if (!_init)
        return AXP_NOT_INIT;
    if (_chip_id != AXP202_CHIP_ID)
        return AXP_NOT_SUPPORT;
    uint8_t val;
    if (!isBatteryConnect())
        return 0;
    _readByte(AXP202_BATT_PERCENTAGE, 1, &val);
    if (!(val & BIT_MASK(7))) {
        return val & (~BIT_MASK(7));
    }
    return 0;
}

int AXP20X_Class::setChgLEDMode(axp_chgled_mode_t mode)
{
    uint8_t val;
    _readByte(AXP202_OFF_CTL, 1, &val);
    val &= 0b11001111;
    val |= BIT_MASK(3);
    switch (mode) {
    case AXP20X_LED_OFF:
        _writeByte(AXP202_OFF_CTL, 1, &val);
        break;
    case AXP20X_LED_BLINK_1HZ:
        val |= 0b00010000;
        _writeByte(AXP202_OFF_CTL, 1, &val);
        break;
    case AXP20X_LED_BLINK_4HZ:
        val |= 0b00100000;
        _writeByte(AXP202_OFF_CTL, 1, &val);
        break;
    case AXP20X_LED_LOW_LEVEL:
        val |= 0b00110000;
        _writeByte(AXP202_OFF_CTL, 1, &val);
        break;
    default:
        return AXP_FAIL;
    }
    return AXP_PASS;
}

int AXP20X_Class::debugCharging()
{
    uint8_t val;
    _readByte(AXP202_CHARGE1, 1, &val);
    AXP_DEBUG(""SRC REG:0x%x\\n"", val);
    if (val & (1 << 7)) {
        AXP_DEBUG(""Charging enable is enable\\n"");
    } else {
        AXP_DEBUG(""Charging enable is disable\\n"");
    }
    AXP_DEBUG(""Charging target-voltage : 0x%x\\n"", ((val & 0b01100000) >> 5) & 0b11);
    if (val & (1 << 4)) {
        AXP_DEBUG(""end when the charge current is lower than 15%% of the set value\\n"");
    } else {
        AXP_DEBUG("" end when the charge current is lower than 10%% of the set value\\n"");
    }
    val &= 0b00000111;
    AXP_DEBUG(""Charge current : %.2f mA\\n"", 300.0 + val * 100.0);
    return AXP_PASS;
}

int AXP20X_Class::debugStatus()
{
    if (!_init)
        return AXP_NOT_INIT;
    uint8_t val, val1, val2;
    _readByte(AXP202_STATUS, 1, &val);
    _readByte(AXP202_MODE_CHGSTATUS, 1, &val1);
    _readByte(AXP202_IPS_SET, 1, &val2);
    AXP_DEBUG(""AXP202_STATUS:   AXP202_MODE_CHGSTATUS   AXP202_IPS_SET\\n"");
    AXP_DEBUG(""0x%x\\t\\t\\t 0x%x\\t\\t\\t 0x%x\\n"", val, val1, val2);
    return AXP_PASS;
}

int AXP20X_Class::limitingOff()
{
    if (!_init)
        return AXP_NOT_INIT;
    uint8_t val;
    _readByte(AXP202_IPS_SET, 1, &val);
    if (_chip_id == AXP202_CHIP_ID) {
        val |= 0x03;
    } else {
        val &= ~(1 << 1);
    }
    _writeByte(AXP202_IPS_SET, 1, &val);
    return AXP_PASS;
}

// Only AXP129 chip and AXP173
int AXP20X_Class::setDCDC1Voltage(uint16_t mv)
{
    if (!_init)
        return AXP_NOT_INIT;
    if (_chip_id != AXP192_CHIP_ID && _chip_id != AXP173_CHIP_ID)
        return AXP_FAIL;
    if (mv < 700) {
        AXP_DEBUG(""DCDC1:Below settable voltage:700mV~3500mV"");
        mv = 700;
    }
    if (mv > 3500) {
        AXP_DEBUG(""DCDC1:Above settable voltage:700mV~3500mV"");
        mv = 3500;
    }
    uint8_t val = (mv - 700) / 25;
    //! axp192 and axp173 dc1 control register same
    _writeByte(AXP192_DC1_VLOTAGE, 1, &val);
    return AXP_PASS;
}

// Only AXP129 chip and AXP173
uint16_t AXP20X_Class::getDCDC1Voltage()
{
    if (_chip_id != AXP192_CHIP_ID && _chip_id != AXP173_CHIP_ID)
        return AXP_FAIL;
    uint8_t val = 0;
    //! axp192 and axp173 dc1 control register same
    _readByte(AXP192_DC1_VLOTAGE, 1, &val);
    return val * 25 + 700;
}


/***********************************************
 *              !!! TIMER FUNCTION !!!
 * *********************************************/

int AXP20X_Class::setTimer(uint8_t minutes)
{
    if (!_init)
        return AXP_NOT_INIT;
    if (_chip_id == AXP202_CHIP_ID) {
        if (minutes > 63) {
            return AXP_ARG_INVALID;
        }
        _writeByte(AXP202_TIMER_CTL, 1, &minutes);
        return AXP_PASS;
    }
    return AXP_NOT_SUPPORT;
}

int AXP20X_Class::offTimer()
{
    if (!_init)
        return AXP_NOT_INIT;
    if (_chip_id == AXP202_CHIP_ID) {
        uint8_t minutes = 0x80;
        _writeByte(AXP202_TIMER_CTL, 1, &minutes);
        return AXP_PASS;
    }
    return AXP_NOT_SUPPORT;
}

int AXP20X_Class::clearTimerStatus()
{
    if (!_init)
        return AXP_NOT_INIT;
    if (_chip_id == AXP202_CHIP_ID) {
        uint8_t val;
        _readByte(AXP202_TIMER_CTL, 1, &val);
        val |= 0x80;
        _writeByte(AXP202_TIMER_CTL, 1, &val);
        return AXP_PASS;
    }
    return AXP_NOT_SUPPORT;
}

/***********************************************
 *              !!! GPIO FUNCTION !!!
 * *********************************************/

int AXP20X_Class::_axp192_gpio_0_select( axp_gpio_mode_t mode)
{
    switch (mode) {
    case AXP_IO_OUTPUT_LOW_MODE:
        return 0b101;
    case AXP_IO_INPUT_MODE:
        return 0b001;
    case AXP_IO_LDO_MODE:
        return 0b010;
    case AXP_IO_ADC_MODE:
        return 0b100;
    case AXP_IO_FLOATING_MODE:
        return 0b111;
    case AXP_IO_OPEN_DRAIN_OUTPUT_MODE:
        return 0;
    case AXP_IO_OUTPUT_HIGH_MODE:
    case AXP_IO_PWM_OUTPUT_MODE:
    default:
        break;
    }
    return AXP_NOT_SUPPORT;
}

int AXP20X_Class::_axp192_gpio_1_select( axp_gpio_mode_t mode)
{
    switch (mode) {
    case AXP_IO_OUTPUT_LOW_MODE:
        return 0b101;
    case AXP_IO_INPUT_MODE:
        return 0b001;
    case AXP_IO_ADC_MODE:
        return 0b100;
    case AXP_IO_FLOATING_MODE:
        return 0b111;
    case AXP_IO_OPEN_DRAIN_OUTPUT_MODE:
        return 0;
    case AXP_IO_PWM_OUTPUT_MODE:
        return 0b010;
    case AXP_IO_OUTPUT_HIGH_MODE:
    case AXP_IO_LDO_MODE:
    default:
        break;
    }
    return AXP_NOT_SUPPORT;
}


int AXP20X_Class::_axp192_gpio_3_select( axp_gpio_mode_t mode)
{
    switch (mode) {
    case AXP_IO_EXTERN_CHARGING_CTRL_MODE:
        return 0;
    case AXP_IO_OPEN_DRAIN_OUTPUT_MODE:
        return 1;
    case AXP_IO_INPUT_MODE:
        return 2;
    default:
        break;
    }
    return AXP_NOT_SUPPORT;
}

int AXP20X_Class::_axp192_gpio_4_select( axp_gpio_mode_t mode)
{
    switch (mode) {
    case AXP_IO_EXTERN_CHARGING_CTRL_MODE:
        return 0;
    case AXP_IO_OPEN_DRAIN_OUTPUT_MODE:
        return 1;
    case AXP_IO_INPUT_MODE:
        return 2;
    case AXP_IO_ADC_MODE:
        return 3;
    default:
        break;
    }
    return AXP_NOT_SUPPORT;
}


int AXP20X_Class::_axp192_gpio_set(axp_gpio_t gpio, axp_gpio_mode_t mode)
{
    int rslt;
    uint8_t val;
    switch (gpio) {
    case AXP_GPIO_0: {
        rslt = _axp192_gpio_0_select(mode);
        if (rslt < 0)return rslt;
        _readByte(AXP192_GPIO0_CTL, 1, &val);
        val &= 0xF8;
        val |= (uint8_t)rslt;
        _writeByte(AXP192_GPIO0_CTL, 1, &val);
        return AXP_PASS;
    }
    case AXP_GPIO_1: {
        rslt = _axp192_gpio_1_select(mode);
        if (rslt < 0)return rslt;
        _readByte(AXP192_GPIO1_CTL, 1, &val);
        val &= 0xF8;
        val |= (uint8_t)rslt;
        _writeByte(AXP192_GPIO1_CTL, 1, &val);
        return AXP_PASS;
    }
    case AXP_GPIO_2: {
        rslt = _axp192_gpio_1_select(mode);
        if (rslt < 0)return rslt;
        _readByte(AXP192_GPIO2_CTL, 1, &val);
        val &= 0xF8;
        val |= (uint8_t)rslt;
        _writeByte(AXP192_GPIO2_CTL, 1, &val);
        return AXP_PASS;
    }
    case AXP_GPIO_3: {
        rslt = _axp192_gpio_3_select(mode);
        if (rslt < 0)return rslt;
        _readByte(AXP192_GPIO34_CTL, 1, &val);
        val &= 0xFC;
        val |= (uint8_t)rslt;
        _writeByte(AXP192_GPIO34_CTL, 1, &val);
        return AXP_PASS;
    }
    case AXP_GPIO_4: {
        rslt = _axp192_gpio_4_select(mode);
        if (rslt < 0)return rslt;
        _readByte(AXP192_GPIO34_CTL, 1, &val);
        val &= 0xF3;
        val |= (uint8_t)rslt;
        _writeByte(AXP192_GPIO34_CTL, 1, &val);
        return AXP_PASS;
    }
    default:
        break;
    }
    return AXP_NOT_SUPPORT;
}

int AXP20X_Class::_axp202_gpio_0_select( axp_gpio_mode_t mode)
{
    switch (mode) {
    case AXP_IO_OUTPUT_LOW_MODE:
        return 0;
    case AXP_IO_OUTPUT_HIGH_MODE:
        return 1;
    case AXP_IO_INPUT_MODE:
        return 2;
    case AXP_IO_LDO_MODE:
        return 3;
    case AXP_IO_ADC_MODE:
        return 4;
    default:
        break;
    }
    return AXP_NOT_SUPPORT;
}

int AXP20X_Class::_axp202_gpio_1_select( axp_gpio_mode_t mode)
{
    switch (mode) {
    case AXP_IO_OUTPUT_LOW_MODE:
        return 0;
    case AXP_IO_OUTPUT_HIGH_MODE:
        return 1;
    case AXP_IO_INPUT_MODE:
        return 2;
    case AXP_IO_ADC_MODE:
        return 4;
    default:
        break;
    }
    return AXP_NOT_SUPPORT;
}

int AXP20X_Class::_axp202_gpio_2_select( axp_gpio_mode_t mode)
{
    switch (mode) {
    case AXP_IO_OUTPUT_LOW_MODE:
        return 0;
    case AXP_IO_INPUT_MODE:
        return 2;
    case AXP_IO_FLOATING_MODE:
        return 1;
    default:
        break;
    }
    return AXP_NOT_SUPPORT;
}


int AXP20X_Class::_axp202_gpio_3_select(axp_gpio_mode_t mode)
{
    switch (mode) {
    case AXP_IO_INPUT_MODE:
        return 1;
    case AXP_IO_OPEN_DRAIN_OUTPUT_MODE:
        return 0;
    default:
        break;
    }
    return AXP_NOT_SUPPORT;
}

int AXP20X_Class::_axp202_gpio_set(axp_gpio_t gpio, axp_gpio_mode_t mode)
{
    uint8_t val;
    int rslt;
    switch (gpio) {
    case AXP_GPIO_0: {
        rslt = _axp202_gpio_0_select(mode);
        if (rslt < 0)return rslt;
        _readByte(AXP202_GPIO0_CTL, 1, &val);
        val &= 0b11111000;
        val |= (uint8_t)rslt;
        _writeByte(AXP202_GPIO0_CTL, 1, &val);
        return AXP_PASS;
    }
    case AXP_GPIO_1: {
        rslt = _axp202_gpio_1_select(mode);
        if (rslt < 0)return rslt;
        _readByte(AXP202_GPIO1_CTL, 1, &val);
        val &= 0b11111000;
        val |= (uint8_t)rslt;
        _writeByte(AXP202_GPIO1_CTL, 1, &val);
        return AXP_PASS;
    }
    case AXP_GPIO_2: {
        rslt = _axp202_gpio_2_select(mode);
        if (rslt < 0)return rslt;
        _readByte(AXP202_GPIO2_CTL, 1, &val);
        val &= 0b11111000;
        val |= (uint8_t)rslt;
        _writeByte(AXP202_GPIO2_CTL, 1, &val);
        return AXP_PASS;
    }
    case AXP_GPIO_3: {
        rslt = _axp202_gpio_3_select(mode);
        if (rslt < 0)return rslt;
        _readByte(AXP202_GPIO3_CTL, 1, &val);
        val = rslt ? (val | BIT_MASK(2)) : (val & (~BIT_MASK(2)));
        _writeByte(AXP202_GPIO3_CTL, 1, &val);
        return AXP_PASS;
    }
    default:
        break;
    }
    return AXP_NOT_SUPPORT;
}


int AXP20X_Class::setGPIOMode(axp_gpio_t gpio, axp_gpio_mode_t mode)
{
    if (!_init)
        return AXP_NOT_INIT;
    switch (_chip_id) {
    case AXP202_CHIP_ID:
        return _axp202_gpio_set(gpio, mode);
        break;
    case AXP192_CHIP_ID:
        return _axp192_gpio_set(gpio, mode);
        break;
    default:
        break;
    }
    return AXP_NOT_SUPPORT;
}


int AXP20X_Class::_axp_irq_mask(axp_gpio_irq_t irq)
{
    switch (irq) {
    case AXP_IRQ_NONE:
        return 0;
    case AXP_IRQ_RISING:
        return BIT_MASK(7);
    case AXP_IRQ_FALLING:
        return BIT_MASK(6);
    case AXP_IRQ_DOUBLE_EDGE:
        return 0b1100000;
    default:
        break;
    }
    return AXP_NOT_SUPPORT;
}

int AXP20X_Class::_axp202_gpio_irq_set(axp_gpio_t gpio, axp_gpio_irq_t irq)
{
    uint8_t reg;
    uint8_t val;
    int mask;
    mask = _axp_irq_mask(irq);

    if (mask < 0)return mask;
    switch (gpio) {
    case AXP_GPIO_0:
        reg = AXP202_GPIO0_CTL;
        break;
    case AXP_GPIO_1:
        reg = AXP202_GPIO1_CTL;
        break;
    case AXP_GPIO_2:
        reg = AXP202_GPIO2_CTL;
        break;
    case AXP_GPIO_3:
        reg = AXP202_GPIO3_CTL;
        break;
    default:
        return AXP_NOT_SUPPORT;
    }
    _readByte(reg, 1, &val);
    val = mask == 0 ? (val & 0b00111111) : (val | mask);
    _writeByte(reg, 1, &val);
    return AXP_PASS;
}


int AXP20X_Class::setGPIOIrq(axp_gpio_t gpio, axp_gpio_irq_t irq)
{
    if (!_init)
        return AXP_NOT_INIT;
    switch (_chip_id) {
    case AXP202_CHIP_ID:
        return _axp202_gpio_irq_set(gpio, irq);
    case AXP192_CHIP_ID:
    case AXP173_CHIP_ID:
        return AXP_NOT_SUPPORT;
    default:
        break;
    }
    return AXP_NOT_SUPPORT;
}

int AXP20X_Class::setLDO5Voltage(axp_ldo5_table_t vol)
{
    const uint8_t params[] = {
        0b11111000, //1.8V
        0b11111001, //2.5V
        0b11111010, //2.8V
        0b11111011, //3.0V
        0b11111100, //3.1V
        0b11111101, //3.3V
        0b11111110, //3.4V
        0b11111111, //3.5V
    };
    if (!_init)
        return AXP_NOT_INIT;
    if (_chip_id != AXP202_CHIP_ID)
        return AXP_NOT_SUPPORT;
    if (vol > sizeof(params) / sizeof(params[0]))
        return AXP_ARG_INVALID;
    uint8_t val = 0;
    _readByte(AXP202_GPIO0_VOL, 1, &val);
    val &= 0b11111000;
    val |= params[vol];
    _writeByte(AXP202_GPIO0_VOL, 1, &val);
    return AXP_PASS;
}


int AXP20X_Class::_axp202_gpio_write(axp_gpio_t gpio, uint8_t val)
{
    uint8_t reg;
    uint8_t wVal = 0;
    switch (gpio) {
    case AXP_GPIO_0:
        reg = AXP202_GPIO0_CTL;
        break;
    case AXP_GPIO_1:
        reg = AXP202_GPIO1_CTL;
        break;
    case AXP_GPIO_2:
        reg = AXP202_GPIO2_CTL;
        if (val) {
            return AXP_NOT_SUPPORT;
        }
        break;
    case AXP_GPIO_3:
        if (val) {
            return AXP_NOT_SUPPORT;
        }
        _readByte(AXP202_GPIO3_CTL, 1, &wVal);
        wVal &= 0b11111101;
        _writeByte(AXP202_GPIO3_CTL, 1, &wVal);
        return AXP_PASS;
    default:
        return AXP_NOT_SUPPORT;
    }
    _readByte(reg, 1, &wVal);
    wVal = val ? (wVal | 1) : (wVal & 0b11111000);
    _writeByte(reg, 1, &wVal);
    return AXP_PASS;
}

int AXP20X_Class::_axp202_gpio_read(axp_gpio_t gpio)
{
    uint8_t val;
    uint8_t reg = AXP202_GPIO012_SIGNAL;
    uint8_t offset;
    switch (gpio) {
    case AXP_GPIO_0:
        offset = 4;
        break;
    case AXP_GPIO_1:
        offset = 5;
        break;
    case AXP_GPIO_2:
        offset = 6;
        break;
    case AXP_GPIO_3:
        reg = AXP202_GPIO3_CTL;
        offset = 0;
        break;
    default:
        return AXP_NOT_SUPPORT;
    }
    _readByte(reg, 1, &val);
    return val & BIT_MASK(offset) ? 1 : 0;
}

int AXP20X_Class::gpioWrite(axp_gpio_t gpio, uint8_t val)
{
    if (!_init)
        return AXP_NOT_INIT;
    switch (_chip_id) {
    case AXP202_CHIP_ID:
        return _axp202_gpio_write(gpio, val);
    case AXP192_CHIP_ID:
    case AXP173_CHIP_ID:
        return AXP_NOT_SUPPORT;
    default:
        break;
    }
    return AXP_NOT_SUPPORT;
}

int AXP20X_Class::gpioRead(axp_gpio_t gpio)
{
    if (!_init)
        return AXP_NOT_INIT;
    switch (_chip_id) {
    case AXP202_CHIP_ID:
        return _axp202_gpio_read(gpio);
    case AXP192_CHIP_ID:
    case AXP173_CHIP_ID:
        return AXP_NOT_SUPPORT;
    default:
        break;
    }
    return AXP_NOT_SUPPORT;
}



int AXP20X_Class::getChargeControlCur()
{
    int cur;
    uint8_t val;
    if (!_init)
        return AXP_NOT_INIT;
    switch (_chip_id) {
    case AXP202_CHIP_ID:
        _readByte(AXP202_CHARGE1, 1, &val);
        val &= 0x0F;
        cur =  val * 100 + 300;
        if (cur > 1800 || cur < 300)return 0;
        return cur;
    case AXP192_CHIP_ID:
    case AXP173_CHIP_ID:
        _readByte(AXP202_CHARGE1, 1, &val);
        return val & 0x0F;
    default:
        break;
    }
    return AXP_NOT_SUPPORT;
}

int AXP20X_Class::setChargeControlCur(uint16_t mA)
{
    uint8_t val;
    if (!_init)
        return AXP_NOT_INIT;
    switch (_chip_id) {
    case AXP202_CHIP_ID:
        _readByte(AXP202_CHARGE1, 1, &val);
        val &= 0b11110000;
        mA -= 300;
        val |= (mA / 100);
        _writeByte(AXP202_CHARGE1, 1, &val);
        return AXP_PASS;
    case AXP192_CHIP_ID:
    case AXP173_CHIP_ID:
        _readByte(AXP202_CHARGE1, 1, &val);
        val &= 0b11110000;
        if(mA > AXP1XX_CHARGE_CUR_1320MA)
            mA = AXP1XX_CHARGE_CUR_1320MA;
        val |= mA;
        _writeByte(AXP202_CHARGE1, 1, &val);
        return AXP_PASS;
    default:
        break;
    }
    return AXP_NOT_SUPPORT;
}

",16343,True,3403.844722256831,median
"[#_camel_apache_org_v1]
== camel.apache.org/v1

Package v1 contains API Schema definitions for the camel v1 API group

==  Resource Types

[#_camel_apache_org_v1_Build]
=== Build

Build is the Schema for the builds API

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`apiVersion` +
string
|`camel.apache.org/v1`

|`kind` +
string
|`Build`
|`metadata` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#objectmeta-v1-meta[Kubernetes meta/v1.ObjectMeta]*
|




Refer to the Kubernetes API documentation for the fields of the `metadata` field.
|`spec` +
*xref:#_camel_apache_org_v1_BuildSpec[BuildSpec]*
|




|`status` +
*xref:#_camel_apache_org_v1_BuildStatus[BuildStatus]*
|





|===

[#_camel_apache_org_v1_CamelCatalog]
=== CamelCatalog

CamelCatalog is the Schema for the camelcatalogs API

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`apiVersion` +
string
|`camel.apache.org/v1`

|`kind` +
string
|`CamelCatalog`
|`metadata` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#objectmeta-v1-meta[Kubernetes meta/v1.ObjectMeta]*
|




Refer to the Kubernetes API documentation for the fields of the `metadata` field.
|`status` +
*xref:#_camel_apache_org_v1_CamelCatalogStatus[CamelCatalogStatus]*
|




|`spec` +
*xref:#_camel_apache_org_v1_CamelCatalogSpec[CamelCatalogSpec]*
|





|===

[#_camel_apache_org_v1_Integration]
=== Integration

Integration is the Schema for the integrations API

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`apiVersion` +
string
|`camel.apache.org/v1`

|`kind` +
string
|`Integration`
|`metadata` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#objectmeta-v1-meta[Kubernetes meta/v1.ObjectMeta]*
|




Refer to the Kubernetes API documentation for the fields of the `metadata` field.
|`spec` +
*xref:#_camel_apache_org_v1_IntegrationSpec[IntegrationSpec]*
|




|`status` +
*xref:#_camel_apache_org_v1_IntegrationStatus[IntegrationStatus]*
|





|===

[#_camel_apache_org_v1_IntegrationKit]
=== IntegrationKit

IntegrationKit is the Schema for the integrationkits API

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`apiVersion` +
string
|`camel.apache.org/v1`

|`kind` +
string
|`IntegrationKit`
|`metadata` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#objectmeta-v1-meta[Kubernetes meta/v1.ObjectMeta]*
|




Refer to the Kubernetes API documentation for the fields of the `metadata` field.
|`spec` +
*xref:#_camel_apache_org_v1_IntegrationKitSpec[IntegrationKitSpec]*
|




|`status` +
*xref:#_camel_apache_org_v1_IntegrationKitStatus[IntegrationKitStatus]*
|





|===

[#_camel_apache_org_v1_IntegrationPlatform]
=== IntegrationPlatform

IntegrationPlatform is the Schema for the integrationplatforms API

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`apiVersion` +
string
|`camel.apache.org/v1`

|`kind` +
string
|`IntegrationPlatform`
|`metadata` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#objectmeta-v1-meta[Kubernetes meta/v1.ObjectMeta]*
|




Refer to the Kubernetes API documentation for the fields of the `metadata` field.
|`spec` +
*xref:#_camel_apache_org_v1_IntegrationPlatformSpec[IntegrationPlatformSpec]*
|




|`status` +
*xref:#_camel_apache_org_v1_IntegrationPlatformStatus[IntegrationPlatformStatus]*
|





|===

== Internal Types

[#_camel_apache_org_v1_Artifact]
=== Artifact

*Appears on:*

* <<#_camel_apache_org_v1_BuildStatus, BuildStatus>>
* <<#_camel_apache_org_v1_IntegrationKitStatus, IntegrationKitStatus>>

Artifact --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`id` +
string
|




|`location` +
string
|




|`target` +
string
|




|`checksum` +
string
|





|===

[#_camel_apache_org_v1_BaseTask]
=== BaseTask

*Appears on:*

* <<#_camel_apache_org_v1_BuildahTask, BuildahTask>>
* <<#_camel_apache_org_v1_BuilderTask, BuilderTask>>
* <<#_camel_apache_org_v1_KanikoTask, KanikoTask>>
* <<#_camel_apache_org_v1_S2iTask, S2iTask>>
* <<#_camel_apache_org_v1_SpectrumTask, SpectrumTask>>

BaseTask --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`name` +
string
|





|===

[#_camel_apache_org_v1_BuildCondition]
=== BuildCondition

*Appears on:*

* <<#_camel_apache_org_v1_BuildStatus, BuildStatus>>

BuildCondition describes the state of a resource at a certain point.

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`type` +
*xref:#_camel_apache_org_v1_BuildConditionType[BuildConditionType]*
|


Type of integration condition.

|`status` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#conditionstatus-v1-core[Kubernetes core/v1.ConditionStatus]*
|


Status of the condition, one of True, False, Unknown.

|`lastUpdateTime` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#time-v1-meta[Kubernetes meta/v1.Time]*
|


The last time this condition was updated.

|`lastTransitionTime` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#time-v1-meta[Kubernetes meta/v1.Time]*
|


Last time the condition transitioned from one status to another.

|`reason` +
string
|


The reason for the condition's last transition.

|`message` +
string
|


A human-readable message indicating details about the transition.


|===

[#_camel_apache_org_v1_BuildConditionType]
=== BuildConditionType(`string` alias)

*Appears on:*

* <<#_camel_apache_org_v1_BuildCondition, BuildCondition>>

BuildConditionType --


[#_camel_apache_org_v1_BuildPhase]
=== BuildPhase(`string` alias)

*Appears on:*

* <<#_camel_apache_org_v1_BuildStatus, BuildStatus>>

BuildPhase --


[#_camel_apache_org_v1_BuildSpec]
=== BuildSpec

*Appears on:*

* <<#_camel_apache_org_v1_Build, Build>>

BuildSpec defines the Build to be executed

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`tasks` +
*xref:#_camel_apache_org_v1_Task[[\\]Task]*
|


The sequence of Build tasks to be performed as part of the Build execution.

|`strategy` +
*xref:#_camel_apache_org_v1_BuildStrategy[BuildStrategy]*
|


The strategy that should be used to perform the Build.

|`timeout` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#duration-v1-meta[Kubernetes meta/v1.Duration]*
|


Timeout defines the Build maximum execution duration.
The Build deadline is set to the Build start time plus the Timeout duration.
If the Build deadline is exceeded, the Build context is canceled,
and its phase set to BuildPhaseFailed.


|===

[#_camel_apache_org_v1_BuildStatus]
=== BuildStatus

*Appears on:*

* <<#_camel_apache_org_v1_Build, Build>>

BuildStatus defines the observed state of Build

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`phase` +
*xref:#_camel_apache_org_v1_BuildPhase[BuildPhase]*
|




|`image` +
string
|




|`digest` +
string
|




|`baseImage` +
string
|




|`artifacts` +
*xref:#_camel_apache_org_v1_Artifact[[\\]Artifact]*
|




|`error` +
string
|




|`failure` +
*xref:#_camel_apache_org_v1_Failure[Failure]*
|




|`startedAt` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#time-v1-meta[Kubernetes meta/v1.Time]*
|




|`conditions` +
*xref:#_camel_apache_org_v1_BuildCondition[[\\]BuildCondition]*
|




|`duration` +
string
|


Change to Duration / ISO 8601 when CRD uses OpenAPI spec v3
https://github.com/OAI/OpenAPI-Specification/issues/845


|===

[#_camel_apache_org_v1_BuildStrategy]
=== BuildStrategy(`string` alias)

*Appears on:*

* <<#_camel_apache_org_v1_BuildSpec, BuildSpec>>
* <<#_camel_apache_org_v1_IntegrationPlatformBuildSpec, IntegrationPlatformBuildSpec>>

BuildStrategy specifies how the Build should be executed


[#_camel_apache_org_v1_BuildahTask]
=== BuildahTask

*Appears on:*

* <<#_camel_apache_org_v1_Task, Task>>

BuildahTask --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`BaseTask` +
*xref:#_camel_apache_org_v1_BaseTask[BaseTask]*
|(Members of `BaseTask` are embedded into this type.)




|`PublishTask` +
*xref:#_camel_apache_org_v1_PublishTask[PublishTask]*
|(Members of `PublishTask` are embedded into this type.)




|`verbose` +
bool
|





|===

[#_camel_apache_org_v1_BuilderTask]
=== BuilderTask

*Appears on:*

* <<#_camel_apache_org_v1_Task, Task>>

BuilderTask --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`BaseTask` +
*xref:#_camel_apache_org_v1_BaseTask[BaseTask]*
|(Members of `BaseTask` are embedded into this type.)




|`baseImage` +
string
|




|`runtime` +
*xref:#_camel_apache_org_v1_RuntimeSpec[RuntimeSpec]*
|




|`sources` +
*xref:#_camel_apache_org_v1_SourceSpec[[\\]SourceSpec]*
|




|`resources` +
*xref:#_camel_apache_org_v1_ResourceSpec[[\\]ResourceSpec]*
|




|`dependencies` +
[]string
|




|`steps` +
[]string
|




|`maven` +
*xref:#_camel_apache_org_v1_MavenBuildSpec[MavenBuildSpec]*
|




|`buildDir` +
string
|





|===

[#_camel_apache_org_v1_CamelArtifact]
=== CamelArtifact

*Appears on:*

* <<#_camel_apache_org_v1_CamelCatalogSpec, CamelCatalogSpec>>

CamelArtifact --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`CamelArtifactDependency` +
*xref:#_camel_apache_org_v1_CamelArtifactDependency[CamelArtifactDependency]*
|(Members of `CamelArtifactDependency` are embedded into this type.)




|`schemes` +
*xref:#_camel_apache_org_v1_CamelScheme[[\\]CamelScheme]*
|




|`languages` +
[]string
|




|`dataformats` +
[]string
|




|`dependencies` +
*xref:#_camel_apache_org_v1_CamelArtifactDependency[[\\]CamelArtifactDependency]*
|




|`javaTypes` +
[]string
|





|===

[#_camel_apache_org_v1_CamelArtifactDependency]
=== CamelArtifactDependency

*Appears on:*

* <<#_camel_apache_org_v1_CamelArtifact, CamelArtifact>>
* <<#_camel_apache_org_v1_CamelSchemeScope, CamelSchemeScope>>

CamelArtifactDependency represent a maven's dependency

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`MavenArtifact` +
*xref:#_camel_apache_org_v1_MavenArtifact[MavenArtifact]*
|(Members of `MavenArtifact` are embedded into this type.)




|`exclusions` +
*xref:#_camel_apache_org_v1_CamelArtifactExclusion[[\\]CamelArtifactExclusion]*
|





|===

[#_camel_apache_org_v1_CamelArtifactExclusion]
=== CamelArtifactExclusion

*Appears on:*

* <<#_camel_apache_org_v1_CamelArtifactDependency, CamelArtifactDependency>>

CamelArtifactExclusion --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`groupId` +
string
|




|`artifactId` +
string
|





|===

[#_camel_apache_org_v1_CamelCatalogSpec]
=== CamelCatalogSpec

*Appears on:*

* <<#_camel_apache_org_v1_CamelCatalog, CamelCatalog>>

CamelCatalogSpec defines the desired state of CamelCatalog

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`runtime` +
*xref:#_camel_apache_org_v1_RuntimeSpec[RuntimeSpec]*
|




|`artifacts` +
*xref:#_camel_apache_org_v1_CamelArtifact[map[string\\]github.com/apache/camel-k/pkg/apis/camel/v1.CamelArtifact]*
|




|`loaders` +
*xref:#_camel_apache_org_v1_CamelLoader[map[string\\]github.com/apache/camel-k/pkg/apis/camel/v1.CamelLoader]*
|





|===

[#_camel_apache_org_v1_CamelCatalogStatus]
=== CamelCatalogStatus

*Appears on:*

* <<#_camel_apache_org_v1_CamelCatalog, CamelCatalog>>

CamelCatalogStatus defines the observed state of CamelCatalog


[#_camel_apache_org_v1_CamelLoader]
=== CamelLoader

*Appears on:*

* <<#_camel_apache_org_v1_CamelCatalogSpec, CamelCatalogSpec>>

CamelLoader --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`MavenArtifact` +
*xref:#_camel_apache_org_v1_MavenArtifact[MavenArtifact]*
|(Members of `MavenArtifact` are embedded into this type.)




|`languages` +
[]string
|




|`dependencies` +
*xref:#_camel_apache_org_v1_MavenArtifact[[\\]MavenArtifact]*
|




|`metadata` +
map[string]string
|





|===

[#_camel_apache_org_v1_CamelScheme]
=== CamelScheme

*Appears on:*

* <<#_camel_apache_org_v1_CamelArtifact, CamelArtifact>>

CamelScheme --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`id` +
string
|




|`passive` +
bool
|




|`http` +
bool
|




|`consumer` +
*xref:#_camel_apache_org_v1_CamelSchemeScope[CamelSchemeScope]*
|




|`producer` +
*xref:#_camel_apache_org_v1_CamelSchemeScope[CamelSchemeScope]*
|





|===

[#_camel_apache_org_v1_CamelSchemeScope]
=== CamelSchemeScope

*Appears on:*

* <<#_camel_apache_org_v1_CamelScheme, CamelScheme>>

CamelSchemeScope contains scoped information about a scheme

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`dependencies` +
*xref:#_camel_apache_org_v1_CamelArtifactDependency[[\\]CamelArtifactDependency]*
|





|===

[#_camel_apache_org_v1_Capability]
=== Capability

*Appears on:*

* <<#_camel_apache_org_v1_RuntimeSpec, RuntimeSpec>>

Capability --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`dependencies` +
*xref:#_camel_apache_org_v1_MavenArtifact[[\\]MavenArtifact]*
|




|`metadata` +
map[string]string
|





|===

[#_camel_apache_org_v1_Configurable]
=== Configurable

Configurable --


[#_camel_apache_org_v1_ConfigurationSpec]
=== ConfigurationSpec

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationKitSpec, IntegrationKitSpec>>
* <<#_camel_apache_org_v1_IntegrationPlatformSpec, IntegrationPlatformSpec>>
* <<#_camel_apache_org_v1_IntegrationSpec, IntegrationSpec>>
* <<#_camel_apache_org_v1_IntegrationStatus, IntegrationStatus>>

ConfigurationSpec --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`type` +
string
|




|`value` +
string
|




|`resourceType` +
string
|




|`resourceMountPoint` +
string
|




|`resourceKey` +
string
|





|===

[#_camel_apache_org_v1_DataSpec]
=== DataSpec

*Appears on:*

* <<#_camel_apache_org_v1_ResourceSpec, ResourceSpec>>
* <<#_camel_apache_org_v1_SourceSpec, SourceSpec>>

DataSpec --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`name` +
string
|




|`path` +
string
|




|`content` +
string
|




|`rawContent` +
[]byte
|




|`contentRef` +
string
|




|`contentKey` +
string
|




|`contentType` +
string
|




|`compression` +
bool
|





|===

[#_camel_apache_org_v1_Failure]
=== Failure

*Appears on:*

* <<#_camel_apache_org_v1_BuildStatus, BuildStatus>>
* <<#_camel_apache_org_v1_IntegrationKitStatus, IntegrationKitStatus>>

Failure --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`reason` +
string
|




|`time` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#time-v1-meta[Kubernetes meta/v1.Time]*
|




|`recovery` +
*xref:#_camel_apache_org_v1_FailureRecovery[FailureRecovery]*
|





|===

[#_camel_apache_org_v1_FailureRecovery]
=== FailureRecovery

*Appears on:*

* <<#_camel_apache_org_v1_Failure, Failure>>

FailureRecovery --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`attempt` +
int
|




|`attemptMax` +
int
|




|`attemptTime` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#time-v1-meta[Kubernetes meta/v1.Time]*
|
*(Optional)*




|===

[#_camel_apache_org_v1_Flow]
=== Flow

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationSpec, IntegrationSpec>>

Flow is an unstructured object representing a Camel Flow in YAML/JSON DSL

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`RawMessage` +
*xref:#_camel_apache_org_v1_RawMessage[RawMessage]*
|(Members of `RawMessage` are embedded into this type.)





|===

[#_camel_apache_org_v1_IntegrationCondition]
=== IntegrationCondition

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationStatus, IntegrationStatus>>

IntegrationCondition describes the state of a resource at a certain point.

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`type` +
*xref:#_camel_apache_org_v1_IntegrationConditionType[IntegrationConditionType]*
|


Type of integration condition.

|`status` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#conditionstatus-v1-core[Kubernetes core/v1.ConditionStatus]*
|


Status of the condition, one of True, False, Unknown.

|`lastUpdateTime` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#time-v1-meta[Kubernetes meta/v1.Time]*
|


The last time this condition was updated.

|`lastTransitionTime` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#time-v1-meta[Kubernetes meta/v1.Time]*
|


Last time the condition transitioned from one status to another.

|`firstTruthyTime` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#time-v1-meta[Kubernetes meta/v1.Time]*
|


First time the condition status transitioned to True.

|`reason` +
string
|


The reason for the condition's last transition.

|`message` +
string
|


A human-readable message indicating details about the transition.


|===

[#_camel_apache_org_v1_IntegrationConditionType]
=== IntegrationConditionType(`string` alias)

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationCondition, IntegrationCondition>>

IntegrationConditionType --


[#_camel_apache_org_v1_IntegrationKitCondition]
=== IntegrationKitCondition

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationKitStatus, IntegrationKitStatus>>

IntegrationKitCondition describes the state of a resource at a certain point.

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`type` +
*xref:#_camel_apache_org_v1_IntegrationKitConditionType[IntegrationKitConditionType]*
|


Type of integration condition.

|`status` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#conditionstatus-v1-core[Kubernetes core/v1.ConditionStatus]*
|


Status of the condition, one of True, False, Unknown.

|`lastUpdateTime` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#time-v1-meta[Kubernetes meta/v1.Time]*
|


The last time this condition was updated.

|`lastTransitionTime` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#time-v1-meta[Kubernetes meta/v1.Time]*
|


Last time the condition transitioned from one status to another.

|`reason` +
string
|


The reason for the condition's last transition.

|`message` +
string
|


A human-readable message indicating details about the transition.


|===

[#_camel_apache_org_v1_IntegrationKitConditionType]
=== IntegrationKitConditionType(`string` alias)

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationKitCondition, IntegrationKitCondition>>

IntegrationKitConditionType --


[#_camel_apache_org_v1_IntegrationKitPhase]
=== IntegrationKitPhase(`string` alias)

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationKitStatus, IntegrationKitStatus>>

IntegrationKitPhase --


[#_camel_apache_org_v1_IntegrationKitSpec]
=== IntegrationKitSpec

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationKit, IntegrationKit>>

IntegrationKitSpec defines the desired state of IntegrationKit

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`image` +
string
|




|`dependencies` +
[]string
|




|`profile` +
*xref:#_camel_apache_org_v1_TraitProfile[TraitProfile]*
|




|`traits` +
*xref:#_camel_apache_org_v1_TraitSpec[map[string\\]github.com/apache/camel-k/pkg/apis/camel/v1.TraitSpec]*
|




|`configuration` +
*xref:#_camel_apache_org_v1_ConfigurationSpec[[\\]ConfigurationSpec]*
|




|`repositories` +
[]string
|





|===

[#_camel_apache_org_v1_IntegrationKitStatus]
=== IntegrationKitStatus

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationKit, IntegrationKit>>

IntegrationKitStatus defines the observed state of IntegrationKit

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`phase` +
*xref:#_camel_apache_org_v1_IntegrationKitPhase[IntegrationKitPhase]*
|




|`baseImage` +
string
|




|`image` +
string
|




|`digest` +
string
|




|`artifacts` +
*xref:#_camel_apache_org_v1_Artifact[[\\]Artifact]*
|




|`failure` +
*xref:#_camel_apache_org_v1_Failure[Failure]*
|




|`runtimeVersion` +
string
|




|`runtimeProvider` +
*xref:#_camel_apache_org_v1_RuntimeProvider[RuntimeProvider]*
|




|`platform` +
string
|




|`conditions` +
*xref:#_camel_apache_org_v1_IntegrationKitCondition[[\\]IntegrationKitCondition]*
|




|`version` +
string
|





|===

[#_camel_apache_org_v1_IntegrationPhase]
=== IntegrationPhase(`string` alias)

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationStatus, IntegrationStatus>>

IntegrationPhase --


[#_camel_apache_org_v1_IntegrationPlatformBuildPublishStrategy]
=== IntegrationPlatformBuildPublishStrategy(`string` alias)

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationPlatformBuildSpec, IntegrationPlatformBuildSpec>>

IntegrationPlatformBuildPublishStrategy enumerates all implemented publish strategies


[#_camel_apache_org_v1_IntegrationPlatformBuildSpec]
=== IntegrationPlatformBuildSpec

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationPlatformSpec, IntegrationPlatformSpec>>

IntegrationPlatformBuildSpec contains platform related build information

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`buildStrategy` +
*xref:#_camel_apache_org_v1_BuildStrategy[BuildStrategy]*
|




|`publishStrategy` +
*xref:#_camel_apache_org_v1_IntegrationPlatformBuildPublishStrategy[IntegrationPlatformBuildPublishStrategy]*
|




|`runtimeVersion` +
string
|




|`runtimeProvider` +
*xref:#_camel_apache_org_v1_RuntimeProvider[RuntimeProvider]*
|




|`baseImage` +
string
|




|`registry` +
*xref:#_camel_apache_org_v1_RegistrySpec[RegistrySpec]*
|




|`timeout` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#duration-v1-meta[Kubernetes meta/v1.Duration]*
|




|`persistentVolumeClaim` +
string
|




|`maven` +
*xref:#_camel_apache_org_v1_MavenSpec[MavenSpec]*
|




|`kanikoBuildCache` +
bool
|





|===

[#_camel_apache_org_v1_IntegrationPlatformCluster]
=== IntegrationPlatformCluster(`string` alias)

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationPlatformSpec, IntegrationPlatformSpec>>

IntegrationPlatformCluster is the kind of orchestration cluster the platform is installed into


[#_camel_apache_org_v1_IntegrationPlatformCondition]
=== IntegrationPlatformCondition

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationPlatformStatus, IntegrationPlatformStatus>>

IntegrationPlatformCondition describes the state of a resource at a certain point.

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`type` +
*xref:#_camel_apache_org_v1_IntegrationPlatformConditionType[IntegrationPlatformConditionType]*
|


Type of integration condition.

|`status` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#conditionstatus-v1-core[Kubernetes core/v1.ConditionStatus]*
|


Status of the condition, one of True, False, Unknown.

|`lastUpdateTime` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#time-v1-meta[Kubernetes meta/v1.Time]*
|


The last time this condition was updated.

|`lastTransitionTime` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#time-v1-meta[Kubernetes meta/v1.Time]*
|


Last time the condition transitioned from one status to another.

|`reason` +
string
|


The reason for the condition's last transition.

|`message` +
string
|


A human-readable message indicating details about the transition.


|===

[#_camel_apache_org_v1_IntegrationPlatformConditionType]
=== IntegrationPlatformConditionType(`string` alias)

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationPlatformCondition, IntegrationPlatformCondition>>

IntegrationPlatformConditionType --


[#_camel_apache_org_v1_IntegrationPlatformKameletRepositorySpec]
=== IntegrationPlatformKameletRepositorySpec

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationPlatformKameletSpec, IntegrationPlatformKameletSpec>>

IntegrationPlatformKameletRepositorySpec --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`uri` +
string
|





|===

[#_camel_apache_org_v1_IntegrationPlatformKameletSpec]
=== IntegrationPlatformKameletSpec

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationPlatformSpec, IntegrationPlatformSpec>>

IntegrationPlatformKameletSpec --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`repositories` +
*xref:#_camel_apache_org_v1_IntegrationPlatformKameletRepositorySpec[[\\]IntegrationPlatformKameletRepositorySpec]*
|





|===

[#_camel_apache_org_v1_IntegrationPlatformPhase]
=== IntegrationPlatformPhase(`string` alias)

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationPlatformStatus, IntegrationPlatformStatus>>

IntegrationPlatformPhase --


[#_camel_apache_org_v1_IntegrationPlatformResourcesSpec]
=== IntegrationPlatformResourcesSpec

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationPlatformSpec, IntegrationPlatformSpec>>

IntegrationPlatformResourcesSpec contains platform related resources


[#_camel_apache_org_v1_IntegrationPlatformSpec]
=== IntegrationPlatformSpec

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationPlatform, IntegrationPlatform>>
* <<#_camel_apache_org_v1_IntegrationPlatformStatus, IntegrationPlatformStatus>>

IntegrationPlatformSpec defines the desired state of IntegrationPlatform

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`cluster` +
*xref:#_camel_apache_org_v1_IntegrationPlatformCluster[IntegrationPlatformCluster]*
|




|`profile` +
*xref:#_camel_apache_org_v1_TraitProfile[TraitProfile]*
|




|`build` +
*xref:#_camel_apache_org_v1_IntegrationPlatformBuildSpec[IntegrationPlatformBuildSpec]*
|




|`resources` +
*xref:#_camel_apache_org_v1_IntegrationPlatformResourcesSpec[IntegrationPlatformResourcesSpec]*
|




|`traits` +
*xref:#_camel_apache_org_v1_TraitSpec[map[string\\]github.com/apache/camel-k/pkg/apis/camel/v1.TraitSpec]*
|




|`configuration` +
*xref:#_camel_apache_org_v1_ConfigurationSpec[[\\]ConfigurationSpec]*
|




|`kamelet` +
*xref:#_camel_apache_org_v1_IntegrationPlatformKameletSpec[IntegrationPlatformKameletSpec]*
|





|===

[#_camel_apache_org_v1_IntegrationPlatformStatus]
=== IntegrationPlatformStatus

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationPlatform, IntegrationPlatform>>

IntegrationPlatformStatus defines the observed state of IntegrationPlatform

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`IntegrationPlatformSpec` +
*xref:#_camel_apache_org_v1_IntegrationPlatformSpec[IntegrationPlatformSpec]*
|(Members of `IntegrationPlatformSpec` are embedded into this type.)




|`phase` +
*xref:#_camel_apache_org_v1_IntegrationPlatformPhase[IntegrationPlatformPhase]*
|




|`conditions` +
*xref:#_camel_apache_org_v1_IntegrationPlatformCondition[[\\]IntegrationPlatformCondition]*
|




|`version` +
string
|




|`info` +
map[string]string
|





|===

[#_camel_apache_org_v1_IntegrationSpec]
=== IntegrationSpec

*Appears on:*

* <<#_camel_apache_org_v1_Integration, Integration>>

IntegrationSpec defines the desired state of Integration

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`replicas` +
int32
|




|`sources` +
*xref:#_camel_apache_org_v1_SourceSpec[[\\]SourceSpec]*
|




|`flows` +
*xref:#_camel_apache_org_v1_Flow[[\\]Flow]*
|




|`resources` +
*xref:#_camel_apache_org_v1_ResourceSpec[[\\]ResourceSpec]*
|


Deprecated:
Use container trait (container.resources) to manage resources
Use openapi trait (openapi.configmaps) to manage OpenAPIs specifications

|`kit` +
string
|


Deprecated: use the IntegrationKit field

|`integrationKit` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#objectreference-v1-core[Kubernetes core/v1.ObjectReference]*
|




|`dependencies` +
[]string
|




|`profile` +
*xref:#_camel_apache_org_v1_TraitProfile[TraitProfile]*
|




|`traits` +
*xref:#_camel_apache_org_v1_TraitSpec[map[string\\]github.com/apache/camel-k/pkg/apis/camel/v1.TraitSpec]*
|




|`template` +
*xref:#_camel_apache_org_v1_PodSpecTemplate[PodSpecTemplate]*
|




|`configuration` +
*xref:#_camel_apache_org_v1_ConfigurationSpec[[\\]ConfigurationSpec]*
|


Deprecated:
Use camel trait (camel.properties) to manage properties
Use container trait (container.configs) to manage configs
Use container trait (container.resources) to manage resources
Use container trait (container.volumes) to manage volumes

|`repositories` +
[]string
|




|`serviceAccountName` +
string
|





|===

[#_camel_apache_org_v1_IntegrationStatus]
=== IntegrationStatus

*Appears on:*

* <<#_camel_apache_org_v1_Integration, Integration>>

IntegrationStatus defines the observed state of Integration

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`phase` +
*xref:#_camel_apache_org_v1_IntegrationPhase[IntegrationPhase]*
|




|`digest` +
string
|




|`image` +
string
|




|`dependencies` +
[]string
|




|`profile` +
*xref:#_camel_apache_org_v1_TraitProfile[TraitProfile]*
|




|`kit` +
string
|


Deprecated: use the IntegrationKit field

|`integrationKit` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#objectreference-v1-core[Kubernetes core/v1.ObjectReference]*
|




|`platform` +
string
|




|`generatedSources` +
*xref:#_camel_apache_org_v1_SourceSpec[[\\]SourceSpec]*
|




|`generatedResources` +
*xref:#_camel_apache_org_v1_ResourceSpec[[\\]ResourceSpec]*
|




|`runtimeVersion` +
string
|




|`runtimeProvider` +
*xref:#_camel_apache_org_v1_RuntimeProvider[RuntimeProvider]*
|




|`configuration` +
*xref:#_camel_apache_org_v1_ConfigurationSpec[[\\]ConfigurationSpec]*
|




|`conditions` +
*xref:#_camel_apache_org_v1_IntegrationCondition[[\\]IntegrationCondition]*
|




|`version` +
string
|




|`replicas` +
int32
|




|`selector` +
string
|




|`capabilities` +
[]string
|




|`lastInitTimestamp` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#time-v1-meta[Kubernetes meta/v1.Time]*
|


The timestamp representing the last time when this integration was initialized.


|===

[#_camel_apache_org_v1_KanikoTask]
=== KanikoTask

*Appears on:*

* <<#_camel_apache_org_v1_Task, Task>>

KanikoTask --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`BaseTask` +
*xref:#_camel_apache_org_v1_BaseTask[BaseTask]*
|(Members of `BaseTask` are embedded into this type.)




|`PublishTask` +
*xref:#_camel_apache_org_v1_PublishTask[PublishTask]*
|(Members of `PublishTask` are embedded into this type.)




|`verbose` +
bool
|




|`cache` +
*xref:#_camel_apache_org_v1_KanikoTaskCache[KanikoTaskCache]*
|





|===

[#_camel_apache_org_v1_KanikoTaskCache]
=== KanikoTaskCache

*Appears on:*

* <<#_camel_apache_org_v1_KanikoTask, KanikoTask>>

KanikoTaskCache --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`enabled` +
bool
|




|`persistentVolumeClaim` +
string
|





|===

[#_camel_apache_org_v1_Language]
=== Language(`string` alias)

*Appears on:*

* <<#_camel_apache_org_v1_SourceSpec, SourceSpec>>

Language --


[#_camel_apache_org_v1_MavenArtifact]
=== MavenArtifact

*Appears on:*

* <<#_camel_apache_org_v1_CamelArtifactDependency, CamelArtifactDependency>>
* <<#_camel_apache_org_v1_CamelLoader, CamelLoader>>
* <<#_camel_apache_org_v1_Capability, Capability>>
* <<#_camel_apache_org_v1_MavenSpec, MavenSpec>>
* <<#_camel_apache_org_v1_RuntimeSpec, RuntimeSpec>>

MavenArtifact defines a Maven artifact

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`groupId` +
string
|




|`artifactId` +
string
|




|`version` +
string
|





|===

[#_camel_apache_org_v1_MavenBuildSpec]
=== MavenBuildSpec

*Appears on:*

* <<#_camel_apache_org_v1_BuilderTask, BuilderTask>>

MavenBuildSpec --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`MavenSpec` +
*xref:#_camel_apache_org_v1_MavenSpec[MavenSpec]*
|(Members of `MavenSpec` are embedded into this type.)




|`repositories` +
*xref:#_camel_apache_org_v1_Repository[[\\]Repository]*
|


The Maven repositories.


|===

[#_camel_apache_org_v1_MavenSpec]
=== MavenSpec

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationPlatformBuildSpec, IntegrationPlatformBuildSpec>>
* <<#_camel_apache_org_v1_MavenBuildSpec, MavenBuildSpec>>

MavenSpec --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`localRepository` +
string
|


The path of the local Maven repository.

|`properties` +
map[string]string
|


The Maven properties.

|`settings` +
*xref:#_camel_apache_org_v1_ValueSource[ValueSource]*
|


A reference to the ConfigMap or Secret key that contains
the Maven settings.

|`caSecret` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#secretkeyselector-v1-core[Kubernetes core/v1.SecretKeySelector]*
|


The Secret name and key, containing the CA certificate(s) used to connect
to remote Maven repositories.
It can contain X.509 certificates, and PKCS#7 formatted certificate chains.
A JKS formatted keystore is automatically created to store the CA certificate(s),
and configured to be used as a trusted certificate(s) by the Maven commands.
Note that the root CA certificates are also imported into the created keystore.

|`timeout` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#duration-v1-meta[Kubernetes meta/v1.Duration]*
|


Deprecated: use IntegrationPlatform.Spec.Build.Timeout instead

|`extension` +
*xref:#_camel_apache_org_v1_MavenArtifact[[\\]MavenArtifact]*
|


The Maven build extensions.
See https://maven.apache.org/guides/mini/guide-using-extensions.html.

|`cliOptions` +
[]string
|


The CLI options that are appended to the list of arguments for Maven commands,
e.g., `-V,--no-transfer-progress,-Dstyle.color=never`.
See https://maven.apache.org/ref/3.8.4/maven-embedder/cli.html.


|===

[#_camel_apache_org_v1_PodSpec]
=== PodSpec

*Appears on:*

* <<#_camel_apache_org_v1_PodSpecTemplate, PodSpecTemplate>>



[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`volumes` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#volume-v1-core[[\\]Kubernetes core/v1.Volume]*
|




|`initContainers` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#container-v1-core[[\\]Kubernetes core/v1.Container]*
|




|`containers` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#container-v1-core[[\\]Kubernetes core/v1.Container]*
|




|`ephemeralContainers` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#ephemeralcontainer-v1-core[[\\]Kubernetes core/v1.EphemeralContainer]*
|




|`restartPolicy` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#restartpolicy-v1-core[Kubernetes core/v1.RestartPolicy]*
|




|`terminationGracePeriodSeconds` +
int64
|




|`activeDeadlineSeconds` +
int64
|




|`dnsPolicy` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#dnspolicy-v1-core[Kubernetes core/v1.DNSPolicy]*
|




|`nodeSelector` +
map[string]string
|




|`topologySpreadConstraints` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#topologyspreadconstraint-v1-core[[\\]Kubernetes core/v1.TopologySpreadConstraint]*
|





|===

[#_camel_apache_org_v1_PodSpecTemplate]
=== PodSpecTemplate

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationSpec, IntegrationSpec>>



[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`spec` +
*xref:#_camel_apache_org_v1_PodSpec[PodSpec]*
|





|===

[#_camel_apache_org_v1_PublishTask]
=== PublishTask

*Appears on:*

* <<#_camel_apache_org_v1_BuildahTask, BuildahTask>>
* <<#_camel_apache_org_v1_KanikoTask, KanikoTask>>
* <<#_camel_apache_org_v1_SpectrumTask, SpectrumTask>>

PublishTask --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`contextDir` +
string
|




|`baseImage` +
string
|




|`image` +
string
|




|`registry` +
*xref:#_camel_apache_org_v1_RegistrySpec[RegistrySpec]*
|





|===

[#_camel_apache_org_v1_RawMessage]
=== RawMessage(`[]byte` alias)

*Appears on:*

* <<#_camel_apache_org_v1_Flow, Flow>>
* <<#_camel_apache_org_v1_Template, Template>>
* <<#_camel_apache_org_v1_TraitConfiguration, TraitConfiguration>>

RawMessage is a raw encoded JSON value.
It implements Marshaler and Unmarshaler and can
be used to delay JSON decoding or precompute a JSON encoding.


[#_camel_apache_org_v1_RegistrySpec]
=== RegistrySpec

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationPlatformBuildSpec, IntegrationPlatformBuildSpec>>
* <<#_camel_apache_org_v1_PublishTask, PublishTask>>

RegistrySpec provides the configuration for the container registry

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`insecure` +
bool
|




|`address` +
string
|




|`secret` +
string
|




|`ca` +
string
|




|`organization` +
string
|





|===

[#_camel_apache_org_v1_Repository]
=== Repository

*Appears on:*

* <<#_camel_apache_org_v1_MavenBuildSpec, MavenBuildSpec>>

Repository defines a Maven repository

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`id` +
string
|




|`name` +
string
|




|`url` +
string
|




|`snapshots` +
*xref:#_camel_apache_org_v1_RepositoryPolicy[RepositoryPolicy]*
|




|`releases` +
*xref:#_camel_apache_org_v1_RepositoryPolicy[RepositoryPolicy]*
|





|===

[#_camel_apache_org_v1_RepositoryPolicy]
=== RepositoryPolicy

*Appears on:*

* <<#_camel_apache_org_v1_Repository, Repository>>

RepositoryPolicy defines the policy associated to a Maven repository

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`enabled` +
bool
|




|`updatePolicy` +
string
|




|`checksumPolicy` +
string
|





|===

[#_camel_apache_org_v1_ResourceCondition]
=== ResourceCondition

ResourceCondition is a common type for all conditions


[#_camel_apache_org_v1_ResourceSpec]
=== ResourceSpec

*Appears on:*

* <<#_camel_apache_org_v1_BuilderTask, BuilderTask>>
* <<#_camel_apache_org_v1_IntegrationSpec, IntegrationSpec>>
* <<#_camel_apache_org_v1_IntegrationStatus, IntegrationStatus>>

ResourceSpec --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`DataSpec` +
*xref:#_camel_apache_org_v1_DataSpec[DataSpec]*
|(Members of `DataSpec` are embedded into this type.)




|`type` +
*xref:#_camel_apache_org_v1_ResourceType[ResourceType]*
|




|`mountPath` +
string
|





|===

[#_camel_apache_org_v1_ResourceType]
=== ResourceType(`string` alias)

*Appears on:*

* <<#_camel_apache_org_v1_ResourceSpec, ResourceSpec>>

ResourceType --


[#_camel_apache_org_v1_RuntimeProvider]
=== RuntimeProvider(`string` alias)

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationKitStatus, IntegrationKitStatus>>
* <<#_camel_apache_org_v1_IntegrationPlatformBuildSpec, IntegrationPlatformBuildSpec>>
* <<#_camel_apache_org_v1_IntegrationStatus, IntegrationStatus>>
* <<#_camel_apache_org_v1_RuntimeSpec, RuntimeSpec>>

RuntimeProvider --


[#_camel_apache_org_v1_RuntimeSpec]
=== RuntimeSpec

*Appears on:*

* <<#_camel_apache_org_v1_BuilderTask, BuilderTask>>
* <<#_camel_apache_org_v1_CamelCatalogSpec, CamelCatalogSpec>>

RuntimeSpec --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`version` +
string
|




|`provider` +
*xref:#_camel_apache_org_v1_RuntimeProvider[RuntimeProvider]*
|




|`applicationClass` +
string
|




|`dependencies` +
*xref:#_camel_apache_org_v1_MavenArtifact[[\\]MavenArtifact]*
|




|`metadata` +
map[string]string
|




|`capabilities` +
*xref:#_camel_apache_org_v1_Capability[map[string\\]github.com/apache/camel-k/pkg/apis/camel/v1.Capability]*
|





|===

[#_camel_apache_org_v1_S2iTask]
=== S2iTask

*Appears on:*

* <<#_camel_apache_org_v1_Task, Task>>

S2iTask --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`BaseTask` +
*xref:#_camel_apache_org_v1_BaseTask[BaseTask]*
|(Members of `BaseTask` are embedded into this type.)




|`contextDir` +
string
|




|`tag` +
string
|





|===

[#_camel_apache_org_v1_SourceSpec]
=== SourceSpec

*Appears on:*

* <<#_camel_apache_org_v1_BuilderTask, BuilderTask>>
* <<#_camel_apache_org_v1_IntegrationSpec, IntegrationSpec>>
* <<#_camel_apache_org_v1_IntegrationStatus, IntegrationStatus>>

SourceSpec --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`DataSpec` +
*xref:#_camel_apache_org_v1_DataSpec[DataSpec]*
|(Members of `DataSpec` are embedded into this type.)




|`language` +
*xref:#_camel_apache_org_v1_Language[Language]*
|




|`loader` +
string
|


Loader is an optional id of the org.apache.camel.k.RoutesLoader that will
interpret this source at runtime

|`interceptors` +
[]string
|


Interceptors are optional identifiers the org.apache.camel.k.RoutesLoader
uses to pre/post process sources

|`type` +
*xref:#_camel_apache_org_v1_SourceType[SourceType]*
|


Type defines the kind of source described by this object

|`property-names` +
[]string
|


List of property names defined in the source (e.g. if type is ""template"")


|===

[#_camel_apache_org_v1_SourceType]
=== SourceType(`string` alias)

*Appears on:*

* <<#_camel_apache_org_v1_SourceSpec, SourceSpec>>




[#_camel_apache_org_v1_SpectrumTask]
=== SpectrumTask

*Appears on:*

* <<#_camel_apache_org_v1_Task, Task>>

SpectrumTask --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`BaseTask` +
*xref:#_camel_apache_org_v1_BaseTask[BaseTask]*
|(Members of `BaseTask` are embedded into this type.)




|`PublishTask` +
*xref:#_camel_apache_org_v1_PublishTask[PublishTask]*
|(Members of `PublishTask` are embedded into this type.)





|===

[#_camel_apache_org_v1_Task]
=== Task

*Appears on:*

* <<#_camel_apache_org_v1_BuildSpec, BuildSpec>>

Task --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`builder` +
*xref:#_camel_apache_org_v1_BuilderTask[BuilderTask]*
|




|`buildah` +
*xref:#_camel_apache_org_v1_BuildahTask[BuildahTask]*
|




|`kaniko` +
*xref:#_camel_apache_org_v1_KanikoTask[KanikoTask]*
|




|`spectrum` +
*xref:#_camel_apache_org_v1_SpectrumTask[SpectrumTask]*
|




|`s2i` +
*xref:#_camel_apache_org_v1_S2iTask[S2iTask]*
|





|===

[#_camel_apache_org_v1_Template]
=== Template

Template is an unstructured object representing a Kamelet template in YAML/JSON DSL

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`RawMessage` +
*xref:#_camel_apache_org_v1_RawMessage[RawMessage]*
|(Members of `RawMessage` are embedded into this type.)





|===

[#_camel_apache_org_v1_TraitConfiguration]
=== TraitConfiguration

*Appears on:*

* <<#_camel_apache_org_v1_TraitSpec, TraitSpec>>



[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`RawMessage` +
*xref:#_camel_apache_org_v1_RawMessage[RawMessage]*
|(Members of `RawMessage` are embedded into this type.)





|===

[#_camel_apache_org_v1_TraitProfile]
=== TraitProfile(`string` alias)

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationKitSpec, IntegrationKitSpec>>
* <<#_camel_apache_org_v1_IntegrationPlatformSpec, IntegrationPlatformSpec>>
* <<#_camel_apache_org_v1_IntegrationSpec, IntegrationSpec>>
* <<#_camel_apache_org_v1_IntegrationStatus, IntegrationStatus>>

TraitProfile represents lists of traits that are enabled for the specific installation/integration


[#_camel_apache_org_v1_TraitSpec]
=== TraitSpec

*Appears on:*

* <<#_camel_apache_org_v1_IntegrationKitSpec, IntegrationKitSpec>>
* <<#_camel_apache_org_v1_IntegrationPlatformSpec, IntegrationPlatformSpec>>
* <<#_camel_apache_org_v1_IntegrationSpec, IntegrationSpec>>

A TraitSpec contains the configuration of a trait

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`configuration` +
*xref:#_camel_apache_org_v1_TraitConfiguration[TraitConfiguration]*
|


TraitConfiguration --


|===

[#_camel_apache_org_v1_ValueSource]
=== ValueSource

*Appears on:*

* <<#_camel_apache_org_v1_MavenSpec, MavenSpec>>

ValueSource --

[cols=""2,2a"",options=""header""]
|===
|Field
|Description

|`configMapKeyRef` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#configmapkeyselector-v1-core[Kubernetes core/v1.ConfigMapKeySelector]*
|


Selects a key of a ConfigMap.

|`secretKeyRef` +
*https://kubernetes.io/docs/reference/generated/kubernetes-api/v1.20/#secretkeyselector-v1-core[Kubernetes core/v1.SecretKeySelector]*
|


Selects a key of a secret.


|===",12450,True,3507.4232961892367,median
"parser grammar F5BigipStructured_ltm;

import
  F5BigipStructured_common,
  F5BigipStructured_ltm_data_group,
  F5BigipStructured_ltm_rule;

options {
  tokenVocab = F5BigipStructuredLexer;
}

l_monitor
:
  MONITOR
  (
    lm_dns
    | lm_gateway_icmp
    | lm_http
    | lm_https
    | lm_ldap
    | lm_tcp
    | unrecognized
  )
;

lm_dns
:
  DNS name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lmd_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lmd_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lm_gateway_icmp
:
  GATEWAY_ICMP name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lmg_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lmg_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lm_http
:
  HTTP name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lmh_defaults_from
      | lmh_null
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lmh_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lmh_null
:
  (
    ADAPTIVE
    | DESTINATION
    | INTERVAL
    | IP_DSCP
    | RECV
    | RECV_DISABLE
    | SEND
    | TIME_UNTIL_UP
    | TIMEOUT
  ) ignored
;

lm_https
:
  HTTPS name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lmhs_defaults_from
      | lmhs_null
      | lmhs_ssl_profile
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lmhs_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lmhs_null
:
  (
    ADAPTIVE
    | CIPHERLIST
    | COMPATIBILITY
    | DESTINATION
    | INTERVAL
    | IP_DSCP
    | RECV
    | RECV_DISABLE
    | SEND
    | TIME_UNTIL_UP
    | TIMEOUT
  ) ignored
;

lmhs_ssl_profile
:
  SSL_PROFILE name = structure_name NEWLINE
;

lm_ldap
:
  LDAP name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lml_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lml_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lm_tcp
:
  TCP name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lmt_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lmt_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

l_node
:
  NODE name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      ln_address
      | ln_address6
    )*
  )? BRACE_RIGHT NEWLINE
;

ln_address
:
  ADDRESS address = ip_address NEWLINE
;

ln_address6
:
  ADDRESS address = ipv6_address NEWLINE
;

l_null
:
  (
    DEFAULT_NODE_MONITOR
    | GLOBAL_SETTINGS
    | IFILE
  ) ignored
;

l_persistence
:
  PERSISTENCE
  (
    lper_cookie
    | lper_source_addr
    | lper_ssl
    | unrecognized
  )
;

lper_null
:
  (
    APP_SERVICE
  ) ignored
;

lper_cookie
:
  COOKIE name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lper_cookie_defaults_from
      | lper_cookie_null
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lper_cookie_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lper_cookie_null
:
  (
    APP_SERVICE
    | EXPIRATION
  ) ignored
;

lper_source_addr
:
  SOURCE_ADDR name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lpersa_defaults_from
      | lpersa_null
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lpersa_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lpersa_null
:
  (
    APP_SERVICE
    | TIMEOUT
  ) ignored
;

lper_ssl
:
  SSL name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lperss_defaults_from
      | lperss_null
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lperss_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lperss_null
:
  (
    APP_SERVICE
    | MATCH_ACROSS_POOLS
    | MATCH_ACROSS_SERVICES
    | MATCH_ACROSS_VIRTUALS
    | OVERRIDE_CONNECTION_LIMIT
    | TIMEOUT
  ) ignored
;

l_pool
:
  POOL name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lp_description
      | lp_members
      | lp_monitor
      | lp_null
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lp_description
:
  DESCRIPTION text = word NEWLINE
;

lp_members
:
  MEMBERS BRACE_LEFT
  (
    NEWLINE lpm_member*
  )? BRACE_RIGHT NEWLINE
;

lpm_member
:
  name_with_port = structure_name_with_port BRACE_LEFT
  (
    NEWLINE
    (
      lpmm_address
      | lpmm_address6
      | lpmm_description
      | lpmm_null
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lpmm_address
:
  ADDRESS address = ip_address NEWLINE
;

lpmm_address6
:
  ADDRESS address6 = ipv6_address NEWLINE
;

lp_monitor
:
  MONITOR names += structure_name
  (
    AND names += structure_name
  )* NEWLINE
;

lpmm_description
:
  DESCRIPTION text = word NEWLINE
;

lpmm_null
:
  (
    PRIORITY_GROUP
  ) ignored
;

lp_null
:
  (
    LOAD_BALANCING_MODE
    | MIN_ACTIVE_MEMBERS
    | SERVICE_DOWN_ACTION
    | SLOW_RAMP_TIME
  ) ignored
;

l_profile
:
  PROFILE
  (
    lprof_analytics
    | lprof_certificate_authority
    | lprof_classification
    | lprof_client_ldap
    | lprof_client_ssl
    | lprof_dhcpv4
    | lprof_dhcpv6
    | lprof_diameter
    | lprof_dns
    | lprof_fasthttp
    | lprof_fastl4
    | lprof_fix
    | lprof_ftp
    | lprof_gtp
    | lprof_html
    | lprof_http2
    | lprof_http_compression
    | lprof_http
    | lprof_http_proxy_connect
    | lprof_icap
    | lprof_ilx
    | lprof_ipother
    | lprof_ipsecalg
    | lprof_map_t
    | lprof_mqtt
    | lprof_netflow
    | lprof_ocsp_stapling_params
    | lprof_one_connect
    | lprof_pcp
    | lprof_pptp
    | lprof_qoe
    | lprof_radius
    | lprof_request_adapt
    | lprof_request_log
    | lprof_response_adapt
    | lprof_rewrite
    | lprof_rtsp
    | lprof_sctp
    | lprof_server_ldap
    | lprof_server_ssl
    | lprof_sip
    | lprof_smtps
    | lprof_socks
    | lprof_splitsessionclient
    | lprof_splitsessionserver
    | lprof_statistics
    | lprof_stream
    | lprof_tcp_analytics
    | lprof_tcp
    | lprof_tftp
    | lprof_traffic_acceleration
    | lprof_udp
    | lprof_web_acceleration
    | lprof_web_security
    | lprof_websocket
    | lprof_xml
    | unrecognized
  )
;

lprof_analytics
:
  ANALYTICS name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_analytics_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_analytics_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_certificate_authority
:
  CERTIFICATE_AUTHORITY name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_certificate_authority_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_certificate_authority_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_classification
:
  CLASSIFICATION name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_classification_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_classification_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_client_ldap
:
  CLIENT_LDAP name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_client_ldap_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_client_ldap_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_client_ssl
:
  CLIENT_SSL name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_client_ssl_defaults_from
      | lprof_client_ssl_null
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_client_ssl_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_client_ssl_null
:
  (
    ALERT_TIMEOUT
    | ALLOW_DYNAMIC_RECORD_SIZING
    | ALLOW_NON_SSL
    | APP_SERVICE
    | CACHE_SIZE
    | CACHE_TIMEOUT
    | CERT
    | CERT_EXTENSION_INCLUDES
    | CERT_KEY_CHAIN
    | CERT_LIFESPAN
    | CERT_LOOKUP_BY_IPADDR_PORT
    | CHAIN
    | CIPHER_GROUP
    | CIPHERS
    | GENERIC_ALERT
    | HANDSHAKE_TIMEOUT
    | INHERIT_CERTKEYCHAIN
    | KEY
    | MAX_ACTIVE_HANDSHAKES
    | MAX_AGGREGATE_RENEGOTIATION_PER_MINUTE
    | MAX_RENEGOTIATIONS_PER_MINUTE
    | MAXIMUM_RECORD_SIZE
    | MOD_SSL_METHODS
    | MODE
    | OCSP_STAPLING
    | OPTIONS
    | PASSPHRASE
    | PEER_NO_RENEGOTIATE_TIMEOUT
    | PROXY_CA_CERT
    | PROXY_CA_KEY
    | PROXY_SSL
    | PROXY_SSL_PASSTHROUGH
    | RENEGOTIATE_MAX_RECORD_DELAY
    | RENEGOTIATE_PERIOD
    | RENEGOTIATE_SIZE
    | RENEGOTIATION
    | SECURE_RENEGOTIATION
    | SERVER_NAME
    | SESSION_MIRRORING
    | SESSION_TICKET
    | SESSION_TICKET_TIMEOUT
    | SNI_DEFAULT
    | SNI_REQUIRE
    | SSL_FORWARD_PROXY
    | SSL_FORWARD_PROXY_BYPASS
    | SSL_SIGN_HASH
    | STRICT_RESUME
    | UNCLEAN_SHUTDOWN
  ) ignored
;

lprof_dhcpv4
:
  DHCPV4 name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_dhcpv4_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_dhcpv4_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_dhcpv6
:
  DHCPV6 name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_dhcpv6_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_dhcpv6_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_diameter
:
  DIAMETER name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_diameter_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_diameter_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_dns
:
  DNS name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_dns_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_dns_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_fasthttp
:
  FASTHTTP name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_fasthttp_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_fasthttp_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_fastl4
:
  FASTL4 name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_fastl4_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_fastl4_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_fix
:
  FIX name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_fix_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_fix_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_ftp
:
  FTP name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_ftp_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_ftp_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_gtp
:
  GTP name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_gtp_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_gtp_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_html
:
  HTML name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_html_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_html_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_http2
:
  HTTP2 name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_http2_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_http2_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_http_compression
:
  HTTP_COMPRESSION name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_http_compression_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_http_compression_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_http
:
  HTTP name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_http_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_http_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_http_proxy_connect
:
  HTTP_PROXY_CONNECT name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_http_proxy_connect_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_http_proxy_connect_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_icap
:
  ICAP name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_icap_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_icap_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_ilx
:
  ILX name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_ilx_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_ilx_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_ipother
:
  IPOTHER name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_ipother_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_ipother_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_ipsecalg
:
  IPSECALG name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_ipsecalg_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_ipsecalg_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_map_t
:
  MAP_T name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_map_t_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_map_t_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_mqtt
:
  MQTT name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_mqtt_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_mqtt_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_netflow
:
  NETFLOW name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_netflow_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_netflow_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_ocsp_stapling_params
:
  OCSP_STAPLING_PARAMS name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_ocsp_stapling_params_defaults_from
      | lprof_ocsp_stapling_params_null
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_ocsp_stapling_params_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_ocsp_stapling_params_null
:
  (
    DNS_RESOLVER
    | RESPONDER_URL
    | SIGN_HASH
    | STATUS_AGE
    | TRUSTED_RESPONDERS
  ) ignored
;

lprof_one_connect
:
  ONE_CONNECT name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_one_connect_defaults_from
      | lprof_one_connect_null
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_one_connect_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_one_connect_null
:
  (
    APP_SERVICE
    | IDLE_TIMEOUT_OVERRIDE
    | LIMIT_TYPE
    | MAX_AGE
    | MAX_REUSE
    | MAX_SIZE
    | SOURCE_MASK
  ) ignored
;

lprof_pcp
:
  PCP name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_pcp_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_pcp_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_pptp
:
  PPTP name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_pptp_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_pptp_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_qoe
:
  QOE name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_qoe_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_qoe_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_radius
:
  RADIUS name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_radius_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_radius_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_request_adapt
:
  REQUEST_ADAPT name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_request_adapt_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_request_adapt_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_request_log
:
  REQUEST_LOG name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_request_log_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_request_log_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_response_adapt
:
  RESPONSE_ADAPT name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_response_adapt_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_response_adapt_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_rewrite
:
  REWRITE name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_rewrite_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_rewrite_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_rtsp
:
  RTSP name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_rtsp_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_rtsp_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_sctp
:
  SCTP name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_sctp_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_sctp_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_server_ldap
:
  SERVER_LDAP name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_server_ldap_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_server_ldap_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_server_ssl
:
  SERVER_SSL name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_server_ssl_defaults_from
      | lprof_server_ssl_null
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_server_ssl_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_server_ssl_null
:
  (
    ALERT_TIMEOUT
    | APP_SERVICE
    | CACHE_SIZE
    | CACHE_TIMEOUT
    | CERT
    | CHAIN
    | CIPHER_GROUP
    | CIPHERS
    | GENERIC_ALERT
    | HANDSHAKE_TIMEOUT
    | KEY
    | MAX_ACTIVE_HANDSHAKES
    | MOD_SSL_METHODS
    | MODE
    | OPTIONS
    | PROXY_SSL
    | PROXY_SSL_PASSTHROUGH
    | RENEGOTIATE_PERIOD
    | RENEGOTIATE_SIZE
    | RENEGOTIATION
    | SECURE_RENEGOTIATION
    | SERVER_NAME
    | SESSION_MIRRORING
    | SESSION_TICKET
    | SNI_DEFAULT
    | SNI_REQUIRE
    | SSL_FORWARD_PROXY
    | SSL_FORWARD_PROXY_BYPASS
    | SSL_SIGN_HASH
    | STRICT_RESUME
    | UNCLEAN_SHUTDOWN
  ) ignored
;

lprof_sip
:
  SIP name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_sip_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_sip_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_smtps
:
  SMTPS name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_smtps_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_smtps_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_socks
:
  SOCKS name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_socks_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_socks_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_splitsessionclient
:
  SPLITSESSIONCLIENT name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_splitsessionclient_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_splitsessionclient_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_splitsessionserver
:
  SPLITSESSIONSERVER name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_splitsessionserver_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_splitsessionserver_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_statistics
:
  STATISTICS name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_statistics_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_statistics_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_stream
:
  STREAM name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_stream_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_stream_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_tcp_analytics
:
  TCP_ANALYTICS name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_tcp_analytics_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_tcp_analytics_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_tcp
:
  TCP name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_tcp_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_tcp_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_tftp
:
  TFTP name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_tftp_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_tftp_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_traffic_acceleration
:
  TRAFFIC_ACCELERATION name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_traffic_acceleration_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_traffic_acceleration_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_udp
:
  UDP name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_udp_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_udp_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_web_acceleration
:
  WEB_ACCELERATION name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_web_acceleration_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_web_acceleration_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_web_security
:
  WEB_SECURITY name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_web_security_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_web_security_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_websocket
:
  WEBSOCKET name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_websocket_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_websocket_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

lprof_xml
:
  XML name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lprof_xml_defaults_from
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lprof_xml_defaults_from
:
  DEFAULTS_FROM name = structure_name NEWLINE
;

l_snat
:
  SNAT name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      ls_origins
      | ls_snatpool
      | ls_vlans
      | ls_vlans_disabled
      | ls_vlans_enabled
    )*
  )? BRACE_RIGHT NEWLINE
;

ls_origins
:
  ORIGINS BRACE_LEFT
  (
    NEWLINE
    (
      lso_origin
      | lso_origin6
    )*
  )? BRACE_RIGHT NEWLINE
;

lso_origin
:
  origin = ip_prefix BRACE_LEFT
  (
    NEWLINE unrecognized*
  )? BRACE_RIGHT NEWLINE
;

lso_origin6
:
  origin6 = ipv6_prefix BRACE_LEFT
  (
    NEWLINE unrecognized*
  )? BRACE_RIGHT NEWLINE
;

ls_snatpool
:
  SNATPOOL name = structure_name NEWLINE
;

ls_vlans
:
  VLANS BRACE_LEFT
  (
    NEWLINE lsv_vlan*
  )? BRACE_RIGHT NEWLINE
;

lsv_vlan
:
  name = structure_name NEWLINE
;

ls_vlans_disabled
:
  VLANS_DISABLED NEWLINE
;

ls_vlans_enabled
:
  VLANS_ENABLED NEWLINE
;

l_snat_translation
:
  SNAT_TRANSLATION name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lst_address
      | lst_address6
      | lst_traffic_group
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lst_address
:
  ADDRESS address = ip_address NEWLINE
;

lst_address6
:
  ADDRESS address6 = ipv6_address NEWLINE
;

lst_traffic_group
:
  TRAFFIC_GROUP name = structure_name NEWLINE
;

l_snatpool
:
  SNATPOOL name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lsp_members
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lsp_members
:
  MEMBERS BRACE_LEFT
  (
    NEWLINE lspm_member*
  )? BRACE_RIGHT NEWLINE
;

lspm_member
:
  name = structure_name NEWLINE
;

l_virtual
:
  VIRTUAL name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lv_description
      | lv_destination
      | lv_disabled
      | lv_enabled
      | lv_ip_forward
      | lv_ip_protocol
      | lv_mask
      | lv_mask6
      | lv_persist
      | lv_pool
      | lv_profiles
      | lv_reject
      | lv_rules
      | lv_source
      | lv_source6
      | lv_source_address_translation
      | lv_translate_address
      | lv_translate_port
      | lv_vlans
      | lv_vlans_disabled
      | lv_vlans_enabled
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lv_description
:
  DESCRIPTION text = word NEWLINE
;

lv_destination
:
  DESTINATION name_with_port = structure_name_with_port NEWLINE
;

lv_disabled
:
  DISABLED NEWLINE
;

lv_enabled
:
  ENABLED NEWLINE
;

lv_ip_forward
:
  IP_FORWARD NEWLINE
;

lv_ip_protocol
:
  IP_PROTOCOL ip_protocol NEWLINE
;

lv_mask
:
  MASK mask = ip_address NEWLINE
;

lv_mask6
:
  MASK mask6 = ipv6_address NEWLINE
;

lv_persist
:
  PERSIST BRACE_LEFT
  (
    NEWLINE lvp_persistence*
  )? BRACE_RIGHT NEWLINE
;

lvp_persistence
:
  name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lvpp_null
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lvpp_null
:
  (
    DEFAULT
  ) ignored
;

lv_pool
:
  POOL name = structure_name NEWLINE
;

lv_profiles
:
  PROFILES BRACE_LEFT
  (
    NEWLINE lv_profiles_profile*
  )? BRACE_RIGHT NEWLINE
;

lv_profiles_profile
:
  name = structure_name BRACE_LEFT
  (
    NEWLINE unrecognized*
  )? BRACE_RIGHT NEWLINE
;

lv_reject
:
  REJECT NEWLINE
;

lv_rules
:
  RULES BRACE_LEFT
  (
    NEWLINE lvr_rule*
  )? BRACE_RIGHT NEWLINE
;

lvr_rule
:
  name = structure_name NEWLINE
;

lv_source
:
  SOURCE source = ip_prefix NEWLINE
;

lv_source6
:
  SOURCE source6 = ipv6_prefix NEWLINE
;

lv_source_address_translation
:
  SOURCE_ADDRESS_TRANSLATION BRACE_LEFT
  (
    NEWLINE
    (
      lvsat_pool
      | lvsat_type
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lvsat_pool
:
  POOL name = structure_name NEWLINE
;

lvsat_type
:
  TYPE source_address_translation_type NEWLINE
;

lv_translate_address
:
  TRANSLATE_ADDRESS
  (
    DISABLED
    | ENABLED
  ) NEWLINE
;

lv_translate_port
:
  TRANSLATE_PORT
  (
    DISABLED
    | ENABLED
  ) NEWLINE
;

lv_vlans
:
  VLANS BRACE_LEFT
  (
    NEWLINE lvv_vlan*
  )? BRACE_RIGHT NEWLINE
;

lvv_vlan
:
  name = structure_name NEWLINE
;

lv_vlans_disabled
:
  VLANS_DISABLED NEWLINE
;

lv_vlans_enabled
:
  VLANS_ENABLED NEWLINE
;

l_virtual_address
:
  VIRTUAL_ADDRESS name = structure_name BRACE_LEFT
  (
    NEWLINE
    (
      lva_address
      | lva_address6
      | lva_arp
      | lva_icmp_echo
      | lva_mask
      | lva_mask6
      | lva_route_advertisement
      | lva_traffic_group
      | unrecognized
    )*
  )? BRACE_RIGHT NEWLINE
;

lva_address
:
  ADDRESS address = ip_address NEWLINE
;

lva_address6
:
  ADDRESS address = ipv6_address NEWLINE
;

lva_arp
:
  ARP
  (
    DISABLED
    | ENABLED
  ) NEWLINE
;

lva_icmp_echo
:
  ICMP_ECHO
  (
    DISABLED
    | ENABLED
  ) NEWLINE
;

lva_mask
:
  MASK mask = ip_address NEWLINE
;

lva_mask6
:
  MASK mask6 = ipv6_address NEWLINE
;

lva_route_advertisement
:
  ROUTE_ADVERTISEMENT ramode = route_advertisement_mode NEWLINE
;

lva_traffic_group
:
  TRAFFIC_GROUP name = structure_name NEWLINE
;

s_ltm
:
  LTM
  (
    l_data_group
    | l_monitor
    | l_node
    | l_null
    | l_persistence
    | l_pool
    | l_profile
    | l_rule
    | l_snat
    | l_snat_translation
    | l_snatpool
    | l_virtual
    | l_virtual_address
    | unrecognized
  )
;

ip_protocol
:
  TCP
  | UDP
;

route_advertisement_mode
:
  ALL
  | ALWAYS
  | ANY
  | DISABLED
  | ENABLED
  | SELECTIVE
;

source_address_translation_type
:
  SNAT
;
",8163,True,2603.0197464527355,median
"//===--- GenFunc.cpp - Swift IR Generation for Function Types -------------===//
//
// This source file is part of the Swift.org open source project
//
// Copyright (c) 2014 - 2017 Apple Inc. and the Swift project authors
// Licensed under Apache License v2.0 with Runtime Library Exception
//
// See https://swift.org/LICENSE.txt for license information
// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
//
//===----------------------------------------------------------------------===//
//
//  This file implements IR generation for function types in Swift.  This
//  includes creating the IR type as well as capturing variables and
//  performing calls.
//
//  Swift supports three representations of functions:
//
//    - thin, which are just a function pointer;
//
//    - thick, which are a pair of a function pointer and
//      an optional ref-counted opaque context pointer; and
//
//    - block, which match the Apple blocks extension: a ref-counted
//      pointer to a mostly-opaque structure with the function pointer
//      stored at a fixed offset.
//
//  The order of function parameters is as follows:
//
//    - indirect return pointer
//    - block context parameter, if applicable
//    - expanded formal parameter types
//    - implicit generic parameters
//    - thick context parameter, if applicable
//    - error result out-parameter, if applicable
//    - witness_method generic parameters, if applicable
//
//  The context and error parameters are last because they are
//  optional: we'd like to be able to turn a thin function into a
//  thick function, or a non-throwing function into a throwing one,
//  without adding a thunk.  A thick context parameter is required
//  (but can be passed undef) if an error result is required.
//
//  The additional generic parameters for witness methods follow the
//  same logic: we'd like to be able to use non-generic method
//  implementations directly as protocol witnesses if the rest of the
//  ABI matches up.
//
//  Note that some of this business with context parameters and error
//  results is just IR formalism; on most of our targets, both of
//  these are passed in registers.  This is also why passing them
//  as the final argument isn't bad for performance.
//
//  For now, function pointer types are always stored as opaque
//  pointers in LLVM IR; using a well-typed function type is
//  very challenging because of issues with recursive type expansion,
//  which can potentially introduce infinite types.  For example:
//    struct A {
//      var fn: (A) -> ()
//    }
//  Our CC lowering expands the fields of A into the argument list
//  of A.fn, which is necessarily infinite.  Attempting to use better
//  types when not in a situation like this would just make the
//  compiler complacent, leading to a long tail of undiscovered
//  crashes.  So instead we always store as i8* and require the
//  bitcast whenever we change representations.
//
//===----------------------------------------------------------------------===//

#include ""swift/AST/ASTContext.h""
#include ""swift/AST/ASTWalker.h""
#include ""swift/AST/Builtins.h""
#include ""swift/AST/Decl.h""
#include ""swift/AST/IRGenOptions.h""
#include ""swift/AST/Module.h""
#include ""swift/AST/Pattern.h""
#include ""swift/AST/PrettyStackTrace.h""
#include ""swift/AST/SubstitutionMap.h""
#include ""swift/AST/Types.h""
#include ""swift/IRGen/Linking.h""
#include ""clang/AST/ASTContext.h""
#include ""clang/CodeGen/CodeGenABITypes.h""
#include ""llvm/IR/Constants.h""
#include ""llvm/IR/DerivedTypes.h""
#include ""llvm/IR/Function.h""
#include ""llvm/IR/Module.h""
#include ""llvm/ProfileData/InstrProf.h""
#include ""llvm/Support/Debug.h""
#include ""llvm/ADT/StringSwitch.h""

#include ""BitPatternBuilder.h""
#include ""Callee.h""
#include ""ConstantBuilder.h""
#include ""EnumPayload.h""
#include ""Explosion.h""
#include ""FixedTypeInfo.h""
#include ""GenCall.h""
#include ""GenClass.h""
#include ""GenFunc.h""
#include ""GenHeap.h""
#include ""GenMeta.h""
#include ""GenObjC.h""
#include ""GenPoly.h""
#include ""GenProto.h""
#include ""GenType.h""
#include ""HeapTypeInfo.h""
#include ""IRGenDebugInfo.h""
#include ""IRGenFunction.h""
#include ""IRGenModule.h""
#include ""IndirectTypeInfo.h""
#include ""ScalarPairTypeInfo.h""
#include ""Signature.h""
#include ""IRGenMangler.h""

using namespace swift;
using namespace irgen;

namespace {
  /// Information about the IR-level signature of a function type.
  class FuncSignatureInfo {
  private:
    /// The SIL function type being represented.
    const CanSILFunctionType FormalType;
    
    mutable Signature TheSignature;
    
  public:
    FuncSignatureInfo(CanSILFunctionType formalType)
      : FormalType(formalType) {}
    
    Signature getSignature(IRGenModule &IGM) const;
  };

  /// The @thin function type-info class.
  class ThinFuncTypeInfo : public PODSingleScalarTypeInfo<ThinFuncTypeInfo,
                                                          LoadableTypeInfo>,
                           public FuncSignatureInfo {
    ThinFuncTypeInfo(CanSILFunctionType formalType, llvm::Type *storageType,
                     Size size, Alignment align,
                     const SpareBitVector &spareBits)
      : PODSingleScalarTypeInfo(storageType, size, spareBits, align),
        FuncSignatureInfo(formalType)
    {
    }

  public:
    static const ThinFuncTypeInfo *create(CanSILFunctionType formalType,
                                          llvm::Type *storageType,
                                          Size size, Alignment align,
                                          const SpareBitVector &spareBits) {
      return new ThinFuncTypeInfo(formalType, storageType, size, align,
                                  spareBits);
    }

    bool mayHaveExtraInhabitants(IRGenModule &IGM) const override {
      return true;
    }

    unsigned getFixedExtraInhabitantCount(IRGenModule &IGM) const override {
      return getFunctionPointerExtraInhabitantCount(IGM);
    }

    APInt getFixedExtraInhabitantValue(IRGenModule &IGM,
                                       unsigned bits,
                                       unsigned index) const override {
      return getFunctionPointerFixedExtraInhabitantValue(IGM, bits, index, 0);
    }

    llvm::Value *getExtraInhabitantIndex(IRGenFunction &IGF, Address src,
                                         SILType T, bool isOutlined)
    const override {
      return getFunctionPointerExtraInhabitantIndex(IGF, src);
    }

    void storeExtraInhabitant(IRGenFunction &IGF, llvm::Value *index,
                              Address dest, SILType T, bool isOutlined)
    const override {
      return storeFunctionPointerExtraInhabitant(IGF, index, dest);
    }
  };

  /// The @thick function type-info class.
  class FuncTypeInfo :
      public ScalarPairTypeInfo<FuncTypeInfo, ReferenceTypeInfo>,
      public FuncSignatureInfo {
    FuncTypeInfo(CanSILFunctionType formalType, llvm::StructType *storageType,
                 Size size, Alignment align, SpareBitVector &&spareBits,
                 IsPOD_t pod)
      : ScalarPairTypeInfo(storageType, size, std::move(spareBits), align, pod),
        FuncSignatureInfo(formalType)
    {
    }

  public:
    static const FuncTypeInfo *create(CanSILFunctionType formalType,
                                      llvm::StructType *storageType,
                                      Size size, Alignment align,
                                      SpareBitVector &&spareBits,
                                      IsPOD_t pod) {
      return new FuncTypeInfo(formalType, storageType, size, align,
                              std::move(spareBits), pod);
    }
    
    // Function types do not satisfy allowsOwnership.
#define REF_STORAGE(Name, name, ...) \\
    const TypeInfo * \\
    create##Name##StorageType(TypeConverter &TC, \\
                              bool isOptional) const override { \\
      llvm_unreachable(""["" #name ""] function type""); \\
    }
#include ""swift/AST/ReferenceStorage.def""

    static Size getFirstElementSize(IRGenModule &IGM) {
      return IGM.getPointerSize();
    }
    static StringRef getFirstElementLabel() {
      return "".fn"";
    }
    static bool isFirstElementTrivial() {
      return true;
    }
    void emitRetainFirstElement(IRGenFunction &IGF, llvm::Value *fn,
                                Optional<Atomicity> atomicity = None) const {}
    void emitReleaseFirstElement(IRGenFunction &IGF, llvm::Value *fn,
                                 Optional<Atomicity> atomicity = None) const {}
    void emitAssignFirstElement(IRGenFunction &IGF, llvm::Value *fn,
                                Address fnAddr) const {
      IGF.Builder.CreateStore(fn, fnAddr);
    }

    static Size getSecondElementOffset(IRGenModule &IGM) {
      return IGM.getPointerSize();
    }
    static Size getSecondElementSize(IRGenModule &IGM) {
      return IGM.getPointerSize();
    }
    static StringRef getSecondElementLabel() {
      return "".data"";
    }
    bool isSecondElementTrivial() const {
      return isPOD(ResilienceExpansion::Maximal);
    }
    void emitRetainSecondElement(IRGenFunction &IGF, llvm::Value *data,
                                 Optional<Atomicity> atomicity = None) const {
      if (!isPOD(ResilienceExpansion::Maximal)) {
        if (!atomicity) atomicity = IGF.getDefaultAtomicity();
        IGF.emitNativeStrongRetain(data, *atomicity);
      }
    }
    void emitReleaseSecondElement(IRGenFunction &IGF, llvm::Value *data,
                                  Optional<Atomicity> atomicity = None) const {
      if (!isPOD(ResilienceExpansion::Maximal)) {
        if (!atomicity) atomicity = IGF.getDefaultAtomicity();
        IGF.emitNativeStrongRelease(data, *atomicity);
      }
    }
    void emitAssignSecondElement(IRGenFunction &IGF, llvm::Value *context,
                                 Address dataAddr) const {
      if (isPOD(ResilienceExpansion::Maximal))
        IGF.Builder.CreateStore(context, dataAddr);
      else
        IGF.emitNativeStrongAssign(context, dataAddr);
    }

    Address projectFunction(IRGenFunction &IGF, Address address) const {
      return projectFirstElement(IGF, address);
    }

    Address projectData(IRGenFunction &IGF, Address address) const {
      return IGF.Builder.CreateStructGEP(address, 1, IGF.IGM.getPointerSize(),
                                         address->getName() + "".data"");
    }

    void strongRetain(IRGenFunction &IGF, Explosion &e,
                      Atomicity atomicity) const override {
      e.claimNext();
      emitRetainSecondElement(IGF, e.claimNext(), atomicity);
    }

    void strongRelease(IRGenFunction &IGF, Explosion &e,
                       Atomicity atomicity) const override {
      e.claimNext();
      emitReleaseSecondElement(IGF, e.claimNext(), atomicity);
    }

#define NEVER_LOADABLE_CHECKED_REF_STORAGE(Name, name, ...) \\
    void name##LoadStrong(IRGenFunction &IGF, Address src, \\
                          Explosion &out, bool isOptional) const override { \\
      llvm_unreachable(#name "" references to functions are not supported""); \\
    } \\
    void name##TakeStrong(IRGenFunction &IGF, Address src, \\
                          Explosion &out, bool isOptional) const override { \\
      llvm_unreachable(#name "" references to functions are not supported""); \\
    } \\
    void name##Init(IRGenFunction &IGF, Explosion &in, \\
                    Address dest, bool isOptional) const override { \\
      llvm_unreachable(#name "" references to functions are not supported""); \\
    } \\
    void name##Assign(IRGenFunction &IGF, Explosion &in, \\
                       Address dest, bool isOptional) const override { \\
      llvm_unreachable(#name "" references to functions are not supported""); \\
    }
#define ALWAYS_LOADABLE_CHECKED_REF_STORAGE(Name, name, ...) \\
    void strongRetain##Name(IRGenFunction &IGF, Explosion &e, \\
                            Atomicity atomicity) const override { \\
      llvm_unreachable(#name "" references to functions are not supported""); \\
    } \\
    void strongRetain##Name##Release(IRGenFunction &IGF, \\
                                     Explosion &e, \\
                                     Atomicity atomicity) const override { \\
      llvm_unreachable(#name "" references to functions are not supported""); \\
    } \\
    void name##Retain(IRGenFunction &IGF, Explosion &e, \\
                       Atomicity atomicity) const override { \\
      llvm_unreachable(#name "" references to functions are not supported""); \\
    } \\
    void name##Release(IRGenFunction &IGF, Explosion &e, \\
                        Atomicity atomicity) const override { \\
      llvm_unreachable(#name "" references to functions are not supported""); \\
    }
#define SOMETIMES_LOADABLE_CHECKED_REF_STORAGE(Name, name, ...) \\
    NEVER_LOADABLE_CHECKED_REF_STORAGE(Name, name, ""..."") \\
    ALWAYS_LOADABLE_CHECKED_REF_STORAGE(Name, name, ""..."")
#include ""swift/AST/ReferenceStorage.def""

    bool mayHaveExtraInhabitants(IRGenModule &IGM) const override {
      return true;
    }

    unsigned getFixedExtraInhabitantCount(IRGenModule &IGM) const override {
      return getFunctionPointerExtraInhabitantCount(IGM);
    }

    APInt getFixedExtraInhabitantValue(IRGenModule &IGM,
                                       unsigned bits,
                                       unsigned index) const override {
      return getFunctionPointerFixedExtraInhabitantValue(IGM, bits, index, 0);
    }

    llvm::Value *getExtraInhabitantIndex(IRGenFunction &IGF, Address src,
                                         SILType T, bool isOutlined)
    const override {
      src = projectFunction(IGF, src);
      return getFunctionPointerExtraInhabitantIndex(IGF, src);
    }

    APInt getFixedExtraInhabitantMask(IRGenModule &IGM) const override {
      // Only the function pointer value is used for extra inhabitants.
      auto pointerSize = IGM.getPointerSize();
      auto mask = BitPatternBuilder(IGM.Triple.isLittleEndian());
      mask.appendSetBits(pointerSize.getValueInBits());
      mask.appendClearBits(pointerSize.getValueInBits());
      return mask.build().getValue();
    }

    void storeExtraInhabitant(IRGenFunction &IGF, llvm::Value *index,
                              Address dest, SILType T, bool isOutlined)
    const override {
      dest = projectFunction(IGF, dest);
      return storeFunctionPointerExtraInhabitant(IGF, index, dest);
    }
  };

  /// The type-info class for ObjC blocks, which are represented by an ObjC
  /// heap pointer.
  class BlockTypeInfo : public HeapTypeInfo<BlockTypeInfo>,
                        public FuncSignatureInfo
  {
  public:
    BlockTypeInfo(CanSILFunctionType ty,
                  llvm::PointerType *storageType,
                  Size size, SpareBitVector spareBits, Alignment align)
      : HeapTypeInfo(storageType, size, spareBits, align),
        FuncSignatureInfo(ty)
    {
    }

    ReferenceCounting getReferenceCounting() const {
      return ReferenceCounting::Block;
    }
  };
  
  /// The type info class for the on-stack representation of an ObjC block.
  ///
  /// TODO: May not be fixed-layout if we capture generics.
  class BlockStorageTypeInfo final
    : public IndirectTypeInfo<BlockStorageTypeInfo, FixedTypeInfo>
  {
    Size CaptureOffset;
  public:
    BlockStorageTypeInfo(llvm::Type *type, Size size, Alignment align,
                         SpareBitVector &&spareBits,
                         IsPOD_t pod, IsBitwiseTakable_t bt, Size captureOffset)
      : IndirectTypeInfo(type, size, std::move(spareBits), align, pod, bt,
                         IsFixedSize),
        CaptureOffset(captureOffset)
    {}
    
    // The lowered type should be an LLVM struct comprising the block header
    // (IGM.ObjCBlockStructTy) as its first element and the capture as its
    // second.
    
    Address projectBlockHeader(IRGenFunction &IGF, Address storage) const {
      return IGF.Builder.CreateStructGEP(storage, 0, Size(0));
    }
    
    Address projectCapture(IRGenFunction &IGF, Address storage) const {
      return IGF.Builder.CreateStructGEP(storage, 1, CaptureOffset);
    }
    
    // TODO
    // The frontend will currently never emit copy_addr or destroy_addr for
    // block storage.

    void assignWithCopy(IRGenFunction &IGF, Address dest, Address src,
                        SILType T, bool isOutlined) const override {
      IGF.unimplemented(SourceLoc(), ""copying @block_storage"");
    }
    void initializeWithCopy(IRGenFunction &IGF, Address dest, Address src,
                            SILType T, bool isOutlined) const override {
      IGF.unimplemented(SourceLoc(), ""copying @block_storage"");
    }
    void destroy(IRGenFunction &IGF, Address addr, SILType T,
                 bool isOutlined) const override {
      IGF.unimplemented(SourceLoc(), ""destroying @block_storage"");
    }
  };
} // end anonymous namespace

const TypeInfo *TypeConverter::convertBlockStorageType(SILBlockStorageType *T) {
  // The block storage consists of the block header (ObjCBlockStructTy)
  // followed by the lowered type of the capture.
  auto &capture = IGM.getTypeInfoForLowered(T->getCaptureType());
  
  // TODO: Support dynamic-sized captures.
  const auto *fixedCapture = dyn_cast<FixedTypeInfo>(&capture);
  llvm::Type *fixedCaptureTy;
  // The block header is pointer aligned. The capture may be worse aligned.
  Alignment align = IGM.getPointerAlignment();
  Size captureOffset(
    IGM.DataLayout.getStructLayout(IGM.ObjCBlockStructTy)->getSizeInBytes());
  auto spareBits = BitPatternBuilder(IGM.Triple.isLittleEndian());
  spareBits.appendClearBits(captureOffset.getValueInBits());

  Size size = captureOffset;
  IsPOD_t pod = IsNotPOD;
  IsBitwiseTakable_t bt = IsNotBitwiseTakable;
  if (!fixedCapture) {
    IGM.unimplemented(SourceLoc(), ""dynamic @block_storage capture"");
    fixedCaptureTy = llvm::StructType::get(IGM.getLLVMContext(), {});
  } else {
    fixedCaptureTy = cast<FixedTypeInfo>(capture).getStorageType();
    align = std::max(align, fixedCapture->getFixedAlignment());
    captureOffset = captureOffset.roundUpToAlignment(align);
    spareBits.padWithSetBitsTo(captureOffset.getValueInBits());
    spareBits.append(fixedCapture->getSpareBits());

    size = captureOffset + fixedCapture->getFixedSize();
    pod = fixedCapture->isPOD(ResilienceExpansion::Maximal);
    bt = fixedCapture->isBitwiseTakable(ResilienceExpansion::Maximal);
  }

  llvm::Type *storageElts[] = {
    IGM.ObjCBlockStructTy,
    fixedCaptureTy,
  };

  auto storageTy = llvm::StructType::get(IGM.getLLVMContext(), storageElts,
                                         /*packed*/ false);
  return new BlockStorageTypeInfo(storageTy, size, align, spareBits.build(),
                                  pod, bt, captureOffset);
}

Address irgen::projectBlockStorageCapture(IRGenFunction &IGF,
                                          Address storageAddr,
                                          CanSILBlockStorageType storageTy) {
  auto &tl = IGF.getTypeInfoForLowered(storageTy).as<BlockStorageTypeInfo>();
  return tl.projectCapture(IGF, storageAddr);
}

const TypeInfo *TypeConverter::convertFunctionType(SILFunctionType *T) {
  // SWIFT_ENABLE_TENSORFLOW
  if (T->isDifferentiable())
    return convertDifferentiableFunctionType(T);

  switch (T->getRepresentation()) {
  case SILFunctionType::Representation::Block:
    return new BlockTypeInfo(CanSILFunctionType(T),
                             IGM.ObjCBlockPtrTy,
                             IGM.getPointerSize(),
                             IGM.getHeapObjectSpareBits(),
                             IGM.getPointerAlignment());
      
  case SILFunctionType::Representation::Thin:
  case SILFunctionType::Representation::Method:
  case SILFunctionType::Representation::WitnessMethod:
  case SILFunctionType::Representation::ObjCMethod:
  case SILFunctionType::Representation::CFunctionPointer:
  case SILFunctionType::Representation::Closure:
    return ThinFuncTypeInfo::create(CanSILFunctionType(T),
                                    IGM.FunctionPtrTy,
                                    IGM.getPointerSize(),
                                    IGM.getPointerAlignment(),
                                    IGM.getFunctionPointerSpareBits());

  case SILFunctionType::Representation::Thick: {
    SpareBitVector spareBits;
    spareBits.append(IGM.getFunctionPointerSpareBits());
    // Although the context pointer of a closure (at least, an escaping one)
    // is a refcounted pointer, we'd like to reserve the right to pack small
    // contexts into the pointer value, so let's not take any spare bits from
    // it.
    spareBits.appendClearBits(IGM.getPointerSize().getValueInBits());
    if (T->isNoEscape()) {
      // @noescape thick functions are trivial types.
      return FuncTypeInfo::create(
          CanSILFunctionType(T), IGM.NoEscapeFunctionPairTy,
          IGM.getPointerSize() * 2, IGM.getPointerAlignment(),
          std::move(spareBits), IsPOD);
    }
    return FuncTypeInfo::create(
        CanSILFunctionType(T), IGM.FunctionPairTy, IGM.getPointerSize() * 2,
        IGM.getPointerAlignment(), std::move(spareBits), IsNotPOD);
  }
  }
  llvm_unreachable(""bad function type representation"");
}

Signature FuncSignatureInfo::getSignature(IRGenModule &IGM) const {
  // If it's already been filled in, we're done.
  if (TheSignature.isValid())
    return TheSignature;

  // Update the cache and return.
  TheSignature = Signature::getUncached(IGM, FormalType);
  assert(TheSignature.isValid());
  return TheSignature;
}

static const FuncSignatureInfo &
getFuncSignatureInfoForLowered(IRGenModule &IGM, CanSILFunctionType type) {
  auto &ti = IGM.getTypeInfoForLowered(type);
  switch (type->getRepresentation()) {
  case SILFunctionType::Representation::Block:
    return ti.as<BlockTypeInfo>();
  case SILFunctionType::Representation::Thin:
  case SILFunctionType::Representation::CFunctionPointer:
  case SILFunctionType::Representation::Method:
  case SILFunctionType::Representation::WitnessMethod:
  case SILFunctionType::Representation::ObjCMethod:
  case SILFunctionType::Representation::Closure:
    return ti.as<ThinFuncTypeInfo>();
  case SILFunctionType::Representation::Thick:
    return ti.as<FuncTypeInfo>();
  }
  llvm_unreachable(""bad function type representation"");
}

Signature
IRGenModule::getSignature(CanSILFunctionType type) {
  auto &sigInfo = getFuncSignatureInfoForLowered(*this, type);
  return sigInfo.getSignature(*this);
}

llvm::FunctionType *
IRGenModule::getFunctionType(CanSILFunctionType type,
                             llvm::AttributeList &attrs,
                             ForeignFunctionInfo *foreignInfo) {
  auto &sigInfo = getFuncSignatureInfoForLowered(*this, type);
  Signature sig = sigInfo.getSignature(*this);
  attrs = sig.getAttributes();
  if (foreignInfo) *foreignInfo = sig.getForeignInfo();
  return sig.getType();
}

ForeignFunctionInfo
IRGenModule::getForeignFunctionInfo(CanSILFunctionType type) {
  if (type->getLanguage() == SILFunctionLanguage::Swift)
    return ForeignFunctionInfo();

  auto &sigInfo = getFuncSignatureInfoForLowered(*this, type);
  return sigInfo.getSignature(*this).getForeignInfo();
}

static void emitApplyArgument(IRGenFunction &IGF,
                              SILParameterInfo origParam,
                              SILParameterInfo substParam,
                              Explosion &in,
                              Explosion &out) {
  auto silConv = IGF.IGM.silConv;

  bool isSubstituted =
      (silConv.getSILType(substParam) != silConv.getSILType(origParam));

  // For indirect arguments, we just need to pass a pointer.
  if (silConv.isSILIndirect(origParam)) {
    // This address is of the substituted type.
    auto addr = in.claimNext();
    
    // If a substitution is in play, just bitcast the address.
    if (isSubstituted) {
      auto origType =
          IGF.IGM.getStoragePointerType(silConv.getSILType(origParam));
      addr = IGF.Builder.CreateBitCast(addr, origType);
    }
    
    out.add(addr);
    return;
  }
  assert(!silConv.isSILIndirect(origParam)
         && ""Unexpected opaque apply parameter."");

  // Otherwise, it's an explosion, which we may need to translate,
  // both in terms of explosion level and substitution levels.

  // Handle the last unsubstituted case.
  if (!isSubstituted) {
    auto &substArgTI =
        cast<LoadableTypeInfo>(IGF.getTypeInfo(silConv.getSILType(substParam)));
    substArgTI.reexplode(IGF, in, out);
    return;
  }

  reemitAsUnsubstituted(IGF, silConv.getSILType(origParam),
                        silConv.getSILType(substParam), in, out);
}

static CanType getArgumentLoweringType(CanType type,
                                       SILParameterInfo paramInfo) {
  switch (paramInfo.getConvention()) {
  // Capture value parameters by value, consuming them.
  case ParameterConvention::Direct_Owned:
  case ParameterConvention::Direct_Unowned:
  case ParameterConvention::Direct_Guaranteed:
  case ParameterConvention::Indirect_In:
  case ParameterConvention::Indirect_In_Constant:
  case ParameterConvention::Indirect_In_Guaranteed:
    return type;

  // Capture inout parameters by pointer.
  case ParameterConvention::Indirect_Inout:
  case ParameterConvention::Indirect_InoutAliasable:
    return CanInOutType::get(type);
  }
  llvm_unreachable(""unhandled convention"");
}

static bool isABIIgnoredParameterWithoutStorage(IRGenModule &IGM,
                                                IRGenFunction &IGF,
                                                CanSILFunctionType substType,
                                                unsigned paramIdx) {
  auto param = substType->getParameters()[paramIdx];
  if (param.isFormalIndirect())
    return false;

  SILType argType = IGM.silConv.getSILType(param);
  auto &ti = IGF.getTypeInfoForLowered(argType.getASTType());
  // Empty values don't matter.
  return ti.getSchema().empty();
}

/// Find the parameter index for the one (assuming there was only one) partially
/// applied argument ignoring empty types that are not passed as part of the
/// ABI.
static unsigned findSinglePartiallyAppliedParameterIndexIgnoringEmptyTypes(
    IRGenFunction &IGF, CanSILFunctionType substType,
    CanSILFunctionType outType) {
  auto substParameters = substType->getParameters();
  auto outParamters = outType->getParameters();
  unsigned firstNonEmpty = -1U;
  for (unsigned paramIdx = outParamters.size() ; paramIdx != substParameters.size(); ++paramIdx) {
    bool isEmpty =
        isABIIgnoredParameterWithoutStorage(IGF.IGM, IGF, substType, paramIdx);
    assert((isEmpty || firstNonEmpty == -1U) && ""Expect at most one partially ""
                                                ""applied that is passed as an ""
                                                ""ABI argument"");
    if (!isEmpty)
      firstNonEmpty = paramIdx;
  }
  assert(firstNonEmpty != -1U);
  return firstNonEmpty;
}

/// Emit the forwarding stub function for a partial application.
///
/// If 'layout' is null, there is a single captured value of
/// Swift-refcountable type that is being used directly as the
/// context object.
static llvm::Function *emitPartialApplicationForwarder(IRGenModule &IGM,
                                   const Optional<FunctionPointer> &staticFnPtr,
                                   bool calleeHasContext,
                                   const Signature &origSig,
                                   CanSILFunctionType origType,
                                   CanSILFunctionType substType,
                                   CanSILFunctionType outType,
                                   SubstitutionMap subs,
                                   HeapLayout const *layout,
                                   ArrayRef<ParameterConvention> conventions) {
  auto outSig = IGM.getSignature(outType);
  llvm::AttributeList outAttrs = outSig.getAttributes();
  llvm::FunctionType *fwdTy = outSig.getType();
  SILFunctionConventions outConv(outType, IGM.getSILModule());

  StringRef FnName;
  if (staticFnPtr)
    FnName = staticFnPtr->getPointer()->getName();

  IRGenMangler Mangler;
  std::string thunkName = Mangler.manglePartialApplyForwarder(FnName);

  // FIXME: Maybe cache the thunk by function and closure types?.
  llvm::Function *fwd =
    llvm::Function::Create(fwdTy, llvm::Function::InternalLinkage,
                           llvm::StringRef(thunkName), &IGM.Module);
  fwd->setCallingConv(outSig.getCallingConv());

  fwd->setAttributes(outAttrs);
  // Merge initial attributes with outAttrs.
  llvm::AttrBuilder b;
  IGM.constructInitialFnAttributes(b);
  fwd->addAttributes(llvm::AttributeList::FunctionIndex, b);

  IRGenFunction subIGF(IGM, fwd);
  if (IGM.DebugInfo)
    IGM.DebugInfo->emitArtificialFunction(subIGF, fwd);
  
  Explosion origParams = subIGF.collectParameters();

  // Create a new explosion for potentially reabstracted parameters.
  Explosion args;

  Address resultValueAddr;

  {
    // Lower the forwarded arguments in the original function's generic context.
    GenericContextScope scope(IGM, origType->getGenericSignature());

    SILFunctionConventions origConv(origType, IGM.getSILModule());
    auto &outResultTI = IGM.getTypeInfo(outConv.getSILResultType());
    auto &nativeResultSchema = outResultTI.nativeReturnValueSchema(IGM);
    auto &origResultTI = IGM.getTypeInfo(origConv.getSILResultType());
    auto &origNativeSchema = origResultTI.nativeReturnValueSchema(IGM);

    // Forward the indirect return values. We might have to reabstract the
    // return value.
    if (nativeResultSchema.requiresIndirect()) {
      assert(origNativeSchema.requiresIndirect());
      auto resultAddr = origParams.claimNext();
      resultAddr = subIGF.Builder.CreateBitCast(
          resultAddr, IGM.getStoragePointerType(origConv.getSILResultType()));
      args.add(resultAddr);
    } else if (origNativeSchema.requiresIndirect()) {
      assert(!nativeResultSchema.requiresIndirect());
      auto stackAddr = outResultTI.allocateStack(
          subIGF, outConv.getSILResultType(), ""return.temp"");
      resultValueAddr = stackAddr.getAddress();
      auto resultAddr = subIGF.Builder.CreateBitCast(
          resultValueAddr,
          IGM.getStoragePointerType(origConv.getSILResultType()));
      args.add(resultAddr.getAddress());
    }

    for (auto resultType : origConv.getIndirectSILResultTypes()) {
      auto addr = origParams.claimNext();
      addr = subIGF.Builder.CreateBitCast(
          addr, IGM.getStoragePointerType(resultType));
      args.add(addr);
    }
    
    // Reemit the parameters as unsubstituted.
    for (unsigned i = 0; i < outType->getParameters().size(); ++i) {
      auto origParamInfo = origType->getParameters()[i];
      auto &ti = IGM.getTypeInfoForLowered(origParamInfo.getType());
      auto schema = ti.getSchema();
      
      auto origParamSILType = IGM.silConv.getSILType(origParamInfo);
      // Forward the address of indirect value params.
      auto &nativeSchemaOrigParam = ti.nativeParameterValueSchema(IGM);
      bool isIndirectParam = origConv.isSILIndirect(origParamInfo);
      if (!isIndirectParam && nativeSchemaOrigParam.requiresIndirect()) {
        auto addr = origParams.claimNext();
        if (addr->getType() != ti.getStorageType()->getPointerTo())
          addr = subIGF.Builder.CreateBitCast(addr,
                                           ti.getStorageType()->getPointerTo());
        args.add(addr);
        continue;
      }

      auto outTypeParamInfo = outType->getParameters()[i];
      // Indirect parameters need no mapping through the native calling
      // convention.
      if (isIndirectParam) {
        emitApplyArgument(subIGF, origParamInfo, outTypeParamInfo, origParams,
                          args);
        continue;
      }

      // Map from the native calling convention into the explosion schema.
      auto outTypeParamSILType = IGM.silConv.getSILType(origParamInfo);
      auto &nativeSchemaOutTypeParam =
          IGM.getTypeInfo(outTypeParamSILType).nativeParameterValueSchema(IGM);
      Explosion nativeParam;
      origParams.transferInto(nativeParam, nativeSchemaOutTypeParam.size());

      bindPolymorphicParameter(subIGF, origType, substType, nativeParam, i);

      Explosion nonNativeParam = nativeSchemaOutTypeParam.mapFromNative(
          subIGF.IGM, subIGF, nativeParam, outTypeParamSILType);
      assert(nativeParam.empty());

      // Emit unsubstituted argument for call.
      Explosion nonNativeApplyArg;
      emitApplyArgument(subIGF, origParamInfo, outTypeParamInfo, nonNativeParam,
                        nonNativeApplyArg);
      assert(nonNativeParam.empty());
      // Map back from the explosion scheme to the native calling convention for
      // the call.
      Explosion nativeApplyArg = nativeSchemaOrigParam.mapIntoNative(
          subIGF.IGM, subIGF, nonNativeApplyArg, origParamSILType, false);
      assert(nonNativeApplyArg.empty());
      nativeApplyArg.transferInto(args, nativeApplyArg.size());
    }
  }

  struct AddressToDeallocate {
    SILType Type;
    const TypeInfo &TI;
    StackAddress Addr;
  };
  SmallVector<AddressToDeallocate, 4> addressesToDeallocate;

  bool dependsOnContextLifetime = false;
  bool consumesContext;
  bool needsAllocas = false;
  
  switch (outType->getCalleeConvention()) {
  case ParameterConvention::Direct_Owned:
    consumesContext = true;
    break;
  case ParameterConvention::Direct_Unowned:
  case ParameterConvention::Direct_Guaranteed:
    consumesContext = false;
    break;
  case ParameterConvention::Indirect_Inout:
  case ParameterConvention::Indirect_InoutAliasable:
  case ParameterConvention::Indirect_In:
  case ParameterConvention::Indirect_In_Constant:
  case ParameterConvention::Indirect_In_Guaranteed:
    llvm_unreachable(""indirect callables not supported"");
  }

  // Lower the captured arguments in the original function's generic context.
  GenericContextScope scope(IGM, origType->getGenericSignature());

  // This is where the context parameter appears.
  llvm::Value *rawData = nullptr;
  Address data;
  unsigned nextCapturedField = 0;
  if (!layout) {
    rawData = origParams.claimNext();
  } else if (!layout->isKnownEmpty()) {
    rawData = origParams.claimNext();
    data = layout->emitCastTo(subIGF, rawData);

    // Restore type metadata bindings, if we have them.
    if (layout->hasBindings()) {
      auto bindingLayout = layout->getElement(nextCapturedField++);
      // The bindings should be fixed-layout inside the object, so we can
      // pass None here. If they weren't, we'd have a chicken-egg problem.
      auto bindingsAddr = bindingLayout.project(subIGF, data, /*offsets*/ None);
      layout->getBindings().restore(subIGF, bindingsAddr,
                                    MetadataState::Complete);
    }

  // There's still a placeholder to claim if the target type is thick
  // or there's an error result.
  } else if (outType->getRepresentation()==SILFunctionTypeRepresentation::Thick
             || outType->hasErrorResult()) {
    llvm::Value *contextPtr = origParams.claimNext(); (void)contextPtr;
    assert(contextPtr->getType() == IGM.RefCountedPtrTy);
  }

  Explosion polyArgs;

  // Emit the polymorphic arguments.
  assert((subs.hasAnySubstitutableParams()
            == hasPolymorphicParameters(origType) ||
         (!subs.hasAnySubstitutableParams() && origType->getRepresentation() ==
             SILFunctionTypeRepresentation::WitnessMethod))
         && ""should have substitutions iff original function is generic"");
  WitnessMetadata witnessMetadata;

  // If we have a layout we might have to bind polymorphic arguments from the
  // captured arguments which we will do later. Otherwise, we have to
  // potentially bind polymorphic arguments from the context if it was a
  // partially applied argument.
  bool hasPolymorphicParams = hasPolymorphicParameters(origType);
  if (!layout && hasPolymorphicParams) {
    assert(conventions.size() == 1);
    // We could have either partially applied an argument from the function
    // signature or otherwise we could have a closure context to forward. We only
    // care for the former for the purpose of reconstructing polymorphic
    // parameters from regular arguments.
    if (!calleeHasContext) {
      unsigned paramI =
          findSinglePartiallyAppliedParameterIndexIgnoringEmptyTypes(
              subIGF, substType, outType);
      auto paramInfo = substType->getParameters()[paramI];
      auto &ti = IGM.getTypeInfoForLowered(paramInfo.getType());
      Explosion param;
      auto ref = rawData;
      // We can get a '{ swift.refcounted* }' type for AnyObject on linux.
      if (!ti.getStorageType()->isPointerTy() &&
          ti.isSingleSwiftRetainablePointer(ResilienceExpansion::Maximal))
        ref = subIGF.coerceValue(rawData, ti.getStorageType(),
                                 subIGF.IGM.DataLayout);
      else
        ref = subIGF.Builder.CreateBitCast(rawData, ti.getStorageType());
      param.add(ref);
      bindPolymorphicParameter(subIGF, origType, substType, param, paramI);
      (void)param.claimAll();
    }

    emitPolymorphicArguments(subIGF, origType, subs,
                             &witnessMetadata, polyArgs);
  }

  auto haveContextArgument =
      calleeHasContext || hasSelfContextParameter(origType);

  // Witness method calls expect self, followed by the self type followed by,
  // the witness table at the end of the parameter list. But polymorphic
  // arguments come before this.
  bool isWitnessMethodCallee = origType->getRepresentation() ==
      SILFunctionTypeRepresentation::WitnessMethod;
  Explosion witnessMethodSelfValue;

  // If there's a data pointer required, but it's a swift-retainable
  // value being passed as the context, just forward it down.
  if (!layout) {
    assert(conventions.size() == 1);

    // We need to retain the parameter if:
    //   - we received at +0 (either) and are passing as owned
    //   - we received as unowned and are passing as guaranteed
    auto argConvention = conventions[nextCapturedField++];
    switch (argConvention) {
    case ParameterConvention::Indirect_In:
    case ParameterConvention::Indirect_In_Constant:
    case ParameterConvention::Direct_Owned:
      if (!consumesContext) subIGF.emitNativeStrongRetain(rawData, subIGF.getDefaultAtomicity());
      break;

    case ParameterConvention::Indirect_In_Guaranteed:
    case ParameterConvention::Direct_Guaranteed:
      dependsOnContextLifetime = true;
      if (outType->getCalleeConvention() ==
            ParameterConvention::Direct_Unowned) {
        subIGF.emitNativeStrongRetain(rawData, subIGF.getDefaultAtomicity());
        consumesContext = true;
      }
      break;

    case ParameterConvention::Direct_Unowned:
      // Make sure we release later if we received at +1.
      if (consumesContext)
        dependsOnContextLifetime = true;
      break;

    case ParameterConvention::Indirect_Inout:
    case ParameterConvention::Indirect_InoutAliasable:
      llvm_unreachable(""should never happen!"");
    }

    // FIXME: The naming and documentation here isn't ideal. This
    // parameter is always present which is evident since we always
    // grab a type to cast to, but sometimes after the polymorphic
    // arguments. This is just following the lead of existing (and not
    // terribly easy to follow) code.

    // If there is a context argument, it comes after the polymorphic
    // arguments.
    auto argIndex = args.size();
    if (haveContextArgument)
      argIndex += polyArgs.size();

    llvm::Type *expectedArgTy = origSig.getType()->getParamType(argIndex);

    llvm::Value *argValue;
    if (isIndirectFormalParameter(argConvention)) {
      // We can use rawData's type for the alloca because it is a swift
      // retainable value. Defensively, give it that type. We can't use the
      // expectedArgType because it might be a generic parameter and therefore
      // have opaque storage.
      auto RetainableValue = rawData;
      if (RetainableValue->getType() != subIGF.IGM.RefCountedPtrTy)
        RetainableValue = subIGF.Builder.CreateBitCast(
            RetainableValue, subIGF.IGM.RefCountedPtrTy);
      needsAllocas = true;
      auto temporary = subIGF.createAlloca(RetainableValue->getType(),
                                           subIGF.IGM.getPointerAlignment(),
                                           ""partial-apply.context"");
      subIGF.Builder.CreateStore(RetainableValue, temporary);
      argValue = temporary.getAddress();
      argValue = subIGF.Builder.CreateBitCast(argValue, expectedArgTy);
    } else {
      argValue = subIGF.Builder.CreateBitCast(rawData, expectedArgTy);
    }
    args.add(argValue);

  // If there's a data pointer required, grab it and load out the
  // extra, previously-curried parameters.
  } else {
    unsigned origParamI = outType->getParameters().size();
    assert(layout->getElements().size() == conventions.size()
           && ""conventions don't match context layout"");

    // Calculate non-fixed field offsets.
    HeapNonFixedOffsets offsets(subIGF, *layout);

    // Perform the loads.
    for (unsigned n = layout->getElements().size();
         nextCapturedField < n;
         ++nextCapturedField) {
      auto &fieldLayout = layout->getElement(nextCapturedField);
      auto &fieldTy = layout->getElementTypes()[nextCapturedField];
      auto fieldConvention = conventions[nextCapturedField];
      Address fieldAddr = fieldLayout.project(subIGF, data, offsets);
      auto &fieldTI = fieldLayout.getType();
      auto fieldSchema = fieldTI.getSchema();
      
      Explosion param;
      switch (fieldConvention) {
      case ParameterConvention::Indirect_In:
      case ParameterConvention::Indirect_In_Constant: {
        // The +1 argument is passed indirectly, so we need to copy into a
        // temporary.
        needsAllocas = true;
        auto stackAddr = fieldTI.allocateStack(subIGF, fieldTy, ""arg.temp"");
        auto addressPointer = stackAddr.getAddress().getAddress();
        fieldTI.initializeWithCopy(subIGF, stackAddr.getAddress(), fieldAddr,
                                   fieldTy, false);
        param.add(addressPointer);
        
        // Remember to deallocate later.
        addressesToDeallocate.push_back(
            AddressToDeallocate{fieldTy, fieldTI, stackAddr});

        break;
      }
      case ParameterConvention::Indirect_In_Guaranteed:
        // The argument is +0, so we can use the address of the param in
        // the context directly.
        param.add(fieldAddr.getAddress());
        dependsOnContextLifetime = true;
        break;
      case ParameterConvention::Indirect_Inout:
      case ParameterConvention::Indirect_InoutAliasable:
        // Load the address of the inout parameter.
        cast<LoadableTypeInfo>(fieldTI).loadAsCopy(subIGF, fieldAddr, param);
        break;
      case ParameterConvention::Direct_Guaranteed:
      case ParameterConvention::Direct_Unowned:
        // If the type is nontrivial, keep the context alive since the field
        // depends on the context to not be deallocated.
        if (!fieldTI.isPOD(ResilienceExpansion::Maximal))
          dependsOnContextLifetime = true;

        // Load these parameters directly. We can ""take"" since the parameter is
        // +0. This can happen since the context will keep the parameter alive.
        cast<LoadableTypeInfo>(fieldTI).loadAsTake(subIGF, fieldAddr, param);
        break;
      case ParameterConvention::Direct_Owned:
        // Copy the value out at +1.
        cast<LoadableTypeInfo>(fieldTI).loadAsCopy(subIGF, fieldAddr, param);
        break;
      }
      
      // Reemit the capture params as unsubstituted.

      // Skip empty parameters.
      while (origParamI < origType->getParameters().size()) {
        if (!isABIIgnoredParameterWithoutStorage(IGM, subIGF, substType,
                                                 origParamI))
          break;
        origParamI++;
      }

      if (origParamI < origType->getParameters().size()) {
        Explosion origParam;
        auto origParamInfo = origType->getParameters()[origParamI];
        if (hasPolymorphicParams)
          bindPolymorphicParameter(subIGF, origType, substType, param,
                                   origParamI);
        emitApplyArgument(subIGF, origParamInfo,
                          substType->getParameters()[origParamI],
                          param, origParam);
        bool isWitnessMethodCalleeSelf = (isWitnessMethodCallee &&
            origParamI + 1 == origType->getParameters().size());
        needsAllocas |= addNativeArgument(
            subIGF, origParam, origParamInfo,
            isWitnessMethodCalleeSelf ? witnessMethodSelfValue : args, false);
        ++origParamI;
      } else {
        args.add(param.claimAll());
      }
      
    }
    
    // If the parameters can live independent of the context, release it now
    // so we can tail call. The safety of this assumes that neither this release
    // nor any of the loads can throw.
    if (consumesContext && !dependsOnContextLifetime && rawData) {
      assert(!outType->isNoEscape() && ""Trivial context must not be released"");
      subIGF.emitNativeStrongRelease(rawData, subIGF.getDefaultAtomicity());
    }

    // Now that we have bound generic parameters from the captured arguments
    // emit the polymorphic arguments.
    if (hasPolymorphicParameters(origType)) {
      emitPolymorphicArguments(subIGF, origType, subs,
                               &witnessMetadata, polyArgs);
    }
  }

  // Derive the callee function pointer.
  auto fnTy = origSig.getType()->getPointerTo();
  FunctionPointer fnPtr = [&]() -> FunctionPointer {
    // If we found a function pointer statically, great.
    if (staticFnPtr) {
      assert(staticFnPtr->getPointer()->getType() == fnTy &&
             ""static function type mismatch?!"");
      return *staticFnPtr;
    }

    // Otherwise, it was the last thing we added to the layout.

    // The dynamic function pointer is packed ""last"" into the context,
    // and we pulled it out as an argument.  Just pop it off.
    auto fnPtr = args.takeLast();

    // It comes out of the context as an i8*. Cast to the function type.
    fnPtr = subIGF.Builder.CreateBitCast(fnPtr, fnTy);

    return FunctionPointer(fnPtr, origSig);
  }();

  // Derive the context argument if needed.  This is either:
  //   - the saved context argument, in which case it was the last
  //     thing we added to the layout other than a possible non-static
  //     function pointer (which we already popped off of 'args'); or
  //   - 'self', in which case it was the last formal argument.
  // In either case, it's the last thing in 'args'.
  llvm::Value *fnContext = nullptr;
  if (haveContextArgument)
    fnContext = args.takeLast();

  polyArgs.transferInto(args, polyArgs.size());

  // If we have a witness method call, the inner context is the
  // witness table. Metadata for Self is derived inside the partial
  // application thunk and doesn't need to be stored in the outer
  // context.
  if (isWitnessMethodCallee) {
    assert(fnContext->getType() == IGM.Int8PtrTy);
    llvm::Value *wtable = subIGF.Builder.CreateBitCast(
        fnContext, IGM.WitnessTablePtrTy);
    assert(wtable->getType() == IGM.WitnessTablePtrTy);
    witnessMetadata.SelfWitnessTable = wtable;

  // Okay, this is where the callee context goes.
  } else if (fnContext) {
    args.add(fnContext);

  // Pass a placeholder for thin function calls.
  } else if (origType->hasErrorResult()) {
    args.add(llvm::UndefValue::get(IGM.RefCountedPtrTy));
  }

  // Add the witness methods self argument before the error parameter after the
  // polymorphic arguments.
  if (isWitnessMethodCallee)
    witnessMethodSelfValue.transferInto(args, witnessMethodSelfValue.size());

  // Pass down the error result.
  if (origType->hasErrorResult()) {
    llvm::Value *errorResultPtr = origParams.claimNext();
    args.add(errorResultPtr);
  }

  assert(origParams.empty());

  if (isWitnessMethodCallee) {
    assert(witnessMetadata.SelfMetadata->getType() == IGM.TypeMetadataPtrTy);
    args.add(witnessMetadata.SelfMetadata);
    assert(witnessMetadata.SelfWitnessTable->getType() == IGM.WitnessTablePtrTy);
    args.add(witnessMetadata.SelfWitnessTable);
  }

  llvm::CallInst *call = subIGF.Builder.CreateCall(fnPtr, args.claimAll());
  
  if (addressesToDeallocate.empty() && !needsAllocas &&
      (!consumesContext || !dependsOnContextLifetime))
    call->setTailCall();

  // Deallocate everything we allocated above.
  // FIXME: exceptions?
  for (auto &entry : addressesToDeallocate) {
    entry.TI.deallocateStack(subIGF, entry.Addr, entry.Type);
  }
  
  // If the parameters depended on the context, consume the context now.
  if (rawData && consumesContext && dependsOnContextLifetime) {
    assert(!outType->isNoEscape() && ""Trivial context must not be released"");
    subIGF.emitNativeStrongRelease(rawData, subIGF.getDefaultAtomicity());
  }

  // Reabstract the result value as substituted.
  SILFunctionConventions origConv(origType, IGM.getSILModule());
  auto &outResultTI = IGM.getTypeInfo(outConv.getSILResultType());
  auto &nativeResultSchema = outResultTI.nativeReturnValueSchema(IGM);
  if (call->getType()->isVoidTy()) {
    if (!resultValueAddr.isValid())
      subIGF.Builder.CreateRetVoid();
    else {
      // Okay, we have called a function that expects an indirect return type
      // but the partially applied return type is direct.
      assert(!nativeResultSchema.requiresIndirect());
      Explosion loadedResult;
      cast<LoadableTypeInfo>(outResultTI)
          .loadAsTake(subIGF, resultValueAddr, loadedResult);
      Explosion nativeResult = nativeResultSchema.mapIntoNative(
          IGM, subIGF, loadedResult, outConv.getSILResultType(), false);
      outResultTI.deallocateStack(subIGF, resultValueAddr,
                                  outConv.getSILResultType());
      if (nativeResult.size() == 1)
        subIGF.Builder.CreateRet(nativeResult.claimNext());
      else {
        llvm::Value *nativeAgg =
            llvm::UndefValue::get(nativeResultSchema.getExpandedType(IGM));
        for (unsigned i = 0, e = nativeResult.size(); i != e; ++i) {
          auto *elt = nativeResult.claimNext();
          nativeAgg = subIGF.Builder.CreateInsertValue(nativeAgg, elt, i);
        }
        subIGF.Builder.CreateRet(nativeAgg);
      }
    }
  } else {
    llvm::Value *callResult = call;
    // If the result type is dependent on a type parameter we might have to
    // cast to the result type - it could be substituted.
    if (origConv.getSILResultType().hasTypeParameter()) {
      auto ResType = fwd->getReturnType();
      if (ResType != callResult->getType())
        callResult = subIGF.coerceValue(callResult, ResType, subIGF.IGM.DataLayout);
    }
    subIGF.Builder.CreateRet(callResult);
  }

  return fwd;
}

/// Emit a partial application thunk for a function pointer applied to a partial
/// set of argument values.
Optional<StackAddress> irgen::emitFunctionPartialApplication(
    IRGenFunction &IGF, SILFunction &SILFn, const FunctionPointer &fn,
    llvm::Value *fnContext, Explosion &args, ArrayRef<SILParameterInfo> params,
    SubstitutionMap subs, CanSILFunctionType origType,
    CanSILFunctionType substType, CanSILFunctionType outType, Explosion &out,
    bool isOutlined) {
  // If we have a single Swift-refcounted context value, we can adopt it
  // directly as our closure context without creating a box and thunk.
  enum HasSingleSwiftRefcountedContext { Maybe, Yes, No, Thunkable }
    hasSingleSwiftRefcountedContext = Maybe;
  Optional<ParameterConvention> singleRefcountedConvention;
  
  SmallVector<const TypeInfo *, 4> argTypeInfos;
  SmallVector<SILType, 4> argValTypes;
  SmallVector<ParameterConvention, 4> argConventions;

  // Reserve space for polymorphic bindings.
  auto bindings = NecessaryBindings::forFunctionInvocations(IGF.IGM,
                                                            origType, subs);
  if (!bindings.empty()) {
    hasSingleSwiftRefcountedContext = No;
    auto bindingsSize = bindings.getBufferSize(IGF.IGM);
    auto &bindingsTI = IGF.IGM.getOpaqueStorageTypeInfo(bindingsSize,
                                                 IGF.IGM.getPointerAlignment());
    argValTypes.push_back(SILType());
    argTypeInfos.push_back(&bindingsTI);
    argConventions.push_back(ParameterConvention::Direct_Unowned);
  }

  // Collect the type infos for the context parameters.
  for (auto param : params) {
    SILType argType = IGF.IGM.silConv.getSILType(param);

    auto argLoweringTy = getArgumentLoweringType(argType.getASTType(), param);

    auto &ti = IGF.getTypeInfoForLowered(argLoweringTy);

    // Empty values don't matter.
    auto schema = ti.getSchema();
    if (schema.empty() && !param.isFormalIndirect())
      continue;

    argValTypes.push_back(argType);
    argConventions.push_back(param.getConvention());
    argTypeInfos.push_back(&ti);

    // Update the single-swift-refcounted check, unless we already ruled that
    // out.
    if (hasSingleSwiftRefcountedContext == No)
      continue;
    
    
    // Adding nonempty values when we already have a single refcounted pointer
    // means we don't have a single value anymore.
    if (hasSingleSwiftRefcountedContext != Maybe) {
      hasSingleSwiftRefcountedContext = No;
      continue;
    }
      
    if (ti.isSingleSwiftRetainablePointer(ResilienceExpansion::Maximal)) {
      hasSingleSwiftRefcountedContext = Yes;
      singleRefcountedConvention = param.getConvention();
    } else {
      hasSingleSwiftRefcountedContext = No;
    }
  }

  // We can't just bitcast if there's an error parameter to forward.
  // This is an unfortunate restriction arising from the fact that a
  // thin throwing function will have the signature:
  //   %result (%arg*, %context*, %error*)
  // but the output signature needs to be
  //   %result (%context*, %error*)
  //
  // 'swifterror' fixes this physically, but there's still a risk of
  // miscompiles because the LLVM optimizer may forward arguments
  // positionally without considering 'swifterror'.
  //
  // Note, however, that we will override this decision below if the
  // only thing we have to forward is already a context pointer.
  // That's fine.
  //
  // The proper long-term fix is that closure functions should be
  // emitted with a convention that takes the closure box as the
  // context parameter.  When we do that, all of this code will
  // disappear.
  if (hasSingleSwiftRefcountedContext == Yes &&
      origType->hasErrorResult()) {
    hasSingleSwiftRefcountedContext = Thunkable;
  }
  
  // If the function pointer is a witness method call, include the witness
  // table in the context.
  if (origType->getRepresentation() ==
        SILFunctionTypeRepresentation::WitnessMethod) {
    llvm::Value *wtable = fnContext;
    assert(wtable->getType() == IGF.IGM.WitnessTablePtrTy);

    // TheRawPointerType lowers as i8*, not i8**.
    args.add(IGF.Builder.CreateBitCast(wtable, IGF.IGM.Int8PtrTy));

    argValTypes.push_back(SILType::getRawPointerType(IGF.IGM.Context));
    argTypeInfos.push_back(
         &IGF.getTypeInfoForLowered(IGF.IGM.Context.TheRawPointerType));
    argConventions.push_back(ParameterConvention::Direct_Unowned);
    hasSingleSwiftRefcountedContext = No;

  // Otherwise, we might have a reference-counted context pointer.
  } else if (fnContext) {
    args.add(fnContext);
    argValTypes.push_back(SILType::getNativeObjectType(IGF.IGM.Context));
    argConventions.push_back(origType->getCalleeConvention());
    argTypeInfos.push_back(
         &IGF.getTypeInfoForLowered(IGF.IGM.Context.TheNativeObjectType));
    // If this is the only context argument we end up with, we can just share
    // it.
    if (args.size() == 1) {
      assert(bindings.empty());
      hasSingleSwiftRefcountedContext = Yes;
      singleRefcountedConvention = origType->getCalleeConvention();
    }
  }
  
  // If we have a single refcounted pointer context (and no polymorphic args
  // to capture), and the dest ownership semantics match the parameter's,
  // skip building the box and thunk and just take the pointer as
  // context.
  // TODO: We can only do this and use swiftself if all our swiftcc emit the
  // last parameter that fits into a register as swiftself.
  // We should get this optimization back using the @convention(closure) whose
  // box argument should just be swift self.
  if (/* DISABLES CODE */ (false) &&
      !origType->isPolymorphic() &&
      hasSingleSwiftRefcountedContext == Yes &&
      outType->getCalleeConvention() == *singleRefcountedConvention) {
    assert(args.size() == 1);
    auto fnPtr = fn.getPointer();
    fnPtr = IGF.Builder.CreateBitCast(fnPtr, IGF.IGM.Int8PtrTy);
    out.add(fnPtr);
    llvm::Value *ctx = args.claimNext();
    ctx = IGF.Builder.CreateBitCast(ctx, IGF.IGM.RefCountedPtrTy);
    out.add(ctx);
    return {};
  }
  
  Optional<FunctionPointer> staticFn;
  if (fn.isConstant()) staticFn = fn;

  // If the function pointer is dynamic, include it in the context.
  size_t nonStaticFnIndex = ~size_t(0);
  if (!staticFn) {
    nonStaticFnIndex = argTypeInfos.size();
    argValTypes.push_back(SILType::getRawPointerType(IGF.IGM.Context));
    argTypeInfos.push_back(
         &IGF.getTypeInfoForLowered(IGF.IGM.Context.TheRawPointerType));
    argConventions.push_back(ParameterConvention::Direct_Unowned);
    hasSingleSwiftRefcountedContext = No;
  }

  // If we only need to capture a single Swift-refcounted object, we
  // still need to build a thunk, but we don't need to allocate anything.
  if ((hasSingleSwiftRefcountedContext == Yes ||
       hasSingleSwiftRefcountedContext == Thunkable) &&
      *singleRefcountedConvention != ParameterConvention::Indirect_Inout &&
      *singleRefcountedConvention !=
        ParameterConvention::Indirect_InoutAliasable) {
    assert(bindings.empty());
    assert(args.size() == 1);

    auto origSig = IGF.IGM.getSignature(origType);

    llvm::Value *forwarder =
      emitPartialApplicationForwarder(IGF.IGM, staticFn, fnContext != nullptr,
                                      origSig, origType, substType,
                                      outType, subs, nullptr, argConventions);
    forwarder = IGF.Builder.CreateBitCast(forwarder, IGF.IGM.Int8PtrTy);
    out.add(forwarder);

    llvm::Value *ctx = args.claimNext();
    if (isIndirectFormalParameter(*singleRefcountedConvention))
      ctx = IGF.Builder.CreateLoad(ctx, IGF.IGM.getPointerAlignment());

    auto expectedClosureTy =
        outType->isNoEscape() ? IGF.IGM.OpaquePtrTy : IGF.IGM.RefCountedPtrTy;

    // We might get a struct containing a pointer e.g type <{ %AClass* }>
    if (ctx->getType() != expectedClosureTy)
      ctx = IGF.coerceValue(ctx, expectedClosureTy, IGF.IGM.DataLayout);
    out.add(ctx);
    if (outType->isNoEscape())
      return StackAddress();
    return {};
  }

  // Store the context arguments on the heap/stack.
  assert(argValTypes.size() == argTypeInfos.size()
         && argTypeInfos.size() == argConventions.size()
         && ""argument info lists out of sync"");
  HeapLayout layout(IGF.IGM, LayoutStrategy::Optimal, argValTypes, argTypeInfos,
                    /*typeToFill*/ nullptr,
                    std::move(bindings));

  llvm::Value *data;

  Optional<StackAddress> stackAddr;

  if (args.empty() && layout.isKnownEmpty()) {
    if (outType->isNoEscape())
      data = llvm::ConstantPointerNull::get(IGF.IGM.OpaquePtrTy);
    else
      data = IGF.IGM.RefCountedNull;
  } else {

    // Allocate a new object on the heap or stack.
    HeapNonFixedOffsets offsets(IGF, layout);
    if (outType->isNoEscape()) {
      stackAddr = IGF.emitDynamicAlloca(
          IGF.IGM.Int8Ty, layout.emitSize(IGF.IGM), Alignment(16));
      stackAddr = stackAddr->withAddress(IGF.Builder.CreateBitCast(
          stackAddr->getAddress(), IGF.IGM.OpaquePtrTy));
      data = stackAddr->getAddress().getAddress();
    } else {
        auto descriptor = IGF.IGM.getAddrOfCaptureDescriptor(SILFn, origType,
                                                       substType, subs,
                                                       layout);

        data = IGF.emitUnmanagedAlloc(layout, ""closure"", descriptor, &offsets);
    }
    Address dataAddr = layout.emitCastTo(IGF, data);
    
    unsigned i = 0;
    
    // Store necessary bindings, if we have them.
    if (layout.hasBindings()) {
      auto &bindingsLayout = layout.getElement(i);
      Address bindingsAddr = bindingsLayout.project(IGF, dataAddr, offsets);
      layout.getBindings().save(IGF, bindingsAddr);
      ++i;
    }
    
    // Store the context arguments.
    for (unsigned end = layout.getElements().size(); i < end; ++i) {
      auto &fieldLayout = layout.getElement(i);
      auto &fieldTy = layout.getElementTypes()[i];
      Address fieldAddr = fieldLayout.project(IGF, dataAddr, offsets);

      // We don't add non-constant function pointers to the explosion above,
      // so we need to handle them specially now.
      if (i == nonStaticFnIndex) {
        llvm::Value *fnPtr = fn.getPointer();
        fnPtr = IGF.Builder.CreateBitCast(fnPtr, IGF.IGM.Int8PtrTy);
        IGF.Builder.CreateStore(fnPtr, fieldAddr);
        continue;
      }

      switch (argConventions[i]) {
      // Take indirect value arguments out of memory.
      case ParameterConvention::Indirect_In:
      case ParameterConvention::Indirect_In_Constant:
      case ParameterConvention::Indirect_In_Guaranteed: {
        auto addr = fieldLayout.getType().getAddressForPointer(args.claimNext());
        fieldLayout.getType().initializeWithTake(IGF, fieldAddr, addr, fieldTy,
                                                 isOutlined);
        break;
      }
      // Take direct value arguments and inout pointers by value.
      case ParameterConvention::Direct_Unowned:
      case ParameterConvention::Direct_Owned:
      case ParameterConvention::Direct_Guaranteed:
      case ParameterConvention::Indirect_Inout:
      case ParameterConvention::Indirect_InoutAliasable:
        cast<LoadableTypeInfo>(fieldLayout.getType())
            .initialize(IGF, args, fieldAddr, isOutlined);
        break;
      }
    }
  }
  assert(args.empty() && ""unused args in partial application?!"");
  
  // Create the forwarding stub.
  auto origSig = IGF.IGM.getSignature(origType);

  llvm::Value *forwarder = emitPartialApplicationForwarder(IGF.IGM,
                                                              staticFn,
                                                          fnContext != nullptr,
                                                              origSig,
                                                              origType,
                                                              substType,
                                                              outType,
                                                              subs,
                                                              &layout,
                                                              argConventions);
  forwarder = IGF.Builder.CreateBitCast(forwarder, IGF.IGM.Int8PtrTy);
  out.add(forwarder);
  out.add(data);
  return stackAddr;
}

/// Emit the block copy helper for a block.
static llvm::Function *emitBlockCopyHelper(IRGenModule &IGM,
                                           CanSILBlockStorageType blockTy,
                                           const BlockStorageTypeInfo &blockTL){
  // See if we've produced a block copy helper for this type before.
  // TODO
  
  // Create the helper.
  llvm::Type *args[] = {
    blockTL.getStorageType()->getPointerTo(),
    blockTL.getStorageType()->getPointerTo(),
  };
  auto copyTy = llvm::FunctionType::get(IGM.VoidTy, args, /*vararg*/ false);
  // TODO: Give these predictable mangled names and shared linkage.
  auto func = llvm::Function::Create(copyTy, llvm::GlobalValue::InternalLinkage,
                                     ""block_copy_helper"",
                                     IGM.getModule());
  func->setAttributes(IGM.constructInitialAttributes());
  IRGenFunction IGF(IGM, func);
  if (IGM.DebugInfo)
    IGM.DebugInfo->emitArtificialFunction(IGF, func);
  
  // Copy the captures from the source to the destination.
  Explosion params = IGF.collectParameters();
  auto dest = Address(params.claimNext(), blockTL.getFixedAlignment());
  auto src = Address(params.claimNext(), blockTL.getFixedAlignment());
  
  auto destCapture = blockTL.projectCapture(IGF, dest);
  auto srcCapture = blockTL.projectCapture(IGF, src);
  auto &captureTL = IGM.getTypeInfoForLowered(blockTy->getCaptureType());
  captureTL.initializeWithCopy(IGF, destCapture, srcCapture,
                               blockTy->getCaptureAddressType(), false);

  IGF.Builder.CreateRetVoid();
  
  return func;
}

/// Emit the block copy helper for a block.
static llvm::Function *emitBlockDisposeHelper(IRGenModule &IGM,
                                           CanSILBlockStorageType blockTy,
                                           const BlockStorageTypeInfo &blockTL){
  // See if we've produced a block destroy helper for this type before.
  // TODO
  
  // Create the helper.
  auto destroyTy = llvm::FunctionType::get(IGM.VoidTy,
                                       blockTL.getStorageType()->getPointerTo(),
                                       /*vararg*/ false);
  // TODO: Give these predictable mangled names and shared linkage.
  auto func = llvm::Function::Create(destroyTy,
                                     llvm::GlobalValue::InternalLinkage,
                                     ""block_destroy_helper"",
                                     IGM.getModule());
  func->setAttributes(IGM.constructInitialAttributes());
  IRGenFunction IGF(IGM, func);
  assert(!func->hasFnAttribute(llvm::Attribute::SanitizeThread));
  if (IGM.DebugInfo)
    IGM.DebugInfo->emitArtificialFunction(IGF, func);
  
  // Destroy the captures.
  Explosion params = IGF.collectParameters();
  auto storage = Address(params.claimNext(), blockTL.getFixedAlignment());
  auto capture = blockTL.projectCapture(IGF, storage);
  auto &captureTL = IGM.getTypeInfoForLowered(blockTy->getCaptureType());
  captureTL.destroy(IGF, capture, blockTy->getCaptureAddressType(),
                    false /*block storage code path: never outlined*/);
  IGF.Builder.CreateRetVoid();
  
  return func;
}

/// Emit the block header into a block storage slot.
void irgen::emitBlockHeader(IRGenFunction &IGF,
                            Address storage,
                            CanSILBlockStorageType blockTy,
                            llvm::Constant *invokeFunction,
                            CanSILFunctionType invokeTy,
                            ForeignFunctionInfo foreignInfo) {
  auto &storageTL
    = IGF.getTypeInfoForLowered(blockTy).as<BlockStorageTypeInfo>();

  Address headerAddr = storageTL.projectBlockHeader(IGF, storage);
  
  //
  // Initialize the ""isa"" pointer, which is _NSConcreteStackBlock.
  auto NSConcreteStackBlock =
      IGF.IGM.getModule()->getOrInsertGlobal(""_NSConcreteStackBlock"",
                                             IGF.IGM.ObjCClassStructTy);
  ApplyIRLinkage(IRLinkage::ExternalImport)
      .to(cast<llvm::GlobalVariable>(NSConcreteStackBlock));

  //
  // Set the flags.
  // - HAS_COPY_DISPOSE unless the capture type is POD
  uint32_t flags = 0;
  auto &captureTL
    = IGF.getTypeInfoForLowered(blockTy->getCaptureType());
  bool isPOD = captureTL.isPOD(ResilienceExpansion::Maximal);
  if (!isPOD)
    flags |= 1 << 25;
  
  // - HAS_STRET, if the invoke function is sret
  assert(foreignInfo.ClangInfo);
  if (foreignInfo.ClangInfo->getReturnInfo().isIndirect())
    flags |= 1 << 29;
  
  // - HAS_SIGNATURE
  flags |= 1 << 30;
  
  auto flagsVal = llvm::ConstantInt::get(IGF.IGM.Int32Ty, flags);
  
  // Collect the reserved and invoke pointer fields.
  auto reserved = llvm::ConstantInt::get(IGF.IGM.Int32Ty, 0);
  auto invokeVal = llvm::ConstantExpr::getBitCast(invokeFunction,
                                                  IGF.IGM.FunctionPtrTy);
  
  // Build the block descriptor.
  ConstantInitBuilder builder(IGF.IGM);
  auto descriptorFields = builder.beginStruct();

  const clang::ASTContext &ASTContext = IGF.IGM.getClangASTContext();
  llvm::IntegerType *UnsignedLongTy =
      llvm::IntegerType::get(IGF.IGM.LLVMContext,
                             ASTContext.getTypeSize(ASTContext.UnsignedLongTy));
  descriptorFields.addInt(UnsignedLongTy, 0);
  descriptorFields.addInt(UnsignedLongTy,
                          storageTL.getFixedSize().getValue());
  
  if (!isPOD) {
    // Define the copy and dispose helpers.
    descriptorFields.add(emitBlockCopyHelper(IGF.IGM, blockTy, storageTL));
    descriptorFields.add(emitBlockDisposeHelper(IGF.IGM, blockTy, storageTL));
  }
  
  // Build the descriptor signature.
  descriptorFields.add(getBlockTypeExtendedEncoding(IGF.IGM, invokeTy));
  
  // Create the descriptor.
  auto descriptor =
    descriptorFields.finishAndCreateGlobal(""block_descriptor"",
                                           IGF.IGM.getPointerAlignment(),
                                           /*constant*/ true);

  auto descriptorVal = llvm::ConstantExpr::getBitCast(descriptor,
                                                      IGF.IGM.Int8PtrTy);
  
  // Store the block header.
  auto layout = IGF.IGM.DataLayout.getStructLayout(IGF.IGM.ObjCBlockStructTy);
  IGF.Builder.CreateStore(NSConcreteStackBlock,
                          IGF.Builder.CreateStructGEP(headerAddr, 0, layout));
  IGF.Builder.CreateStore(flagsVal,
                          IGF.Builder.CreateStructGEP(headerAddr, 1, layout));
  IGF.Builder.CreateStore(reserved,
                          IGF.Builder.CreateStructGEP(headerAddr, 2, layout));
  IGF.Builder.CreateStore(invokeVal,
                          IGF.Builder.CreateStructGEP(headerAddr, 3, layout));
  IGF.Builder.CreateStore(descriptorVal,
                          IGF.Builder.CreateStructGEP(headerAddr, 4, layout));
}
",16178,True,2929.4525270889258,median
"/******************************************************************************
 *
 * Project:  PROJ
 * Purpose:  ISO19111:2019 implementation
 * Author:   Even Rouault <even dot rouault at spatialys dot com>
 *
 ******************************************************************************
 * Copyright (c) 2018, Even Rouault <even dot rouault at spatialys dot com>
 *
 * 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.
 ****************************************************************************/

#ifndef COORDINATEOPERATION_HH_INCLUDED
#define COORDINATEOPERATION_HH_INCLUDED

#include <memory>
#include <string>
#include <utility>
#include <vector>

#include ""common.hpp""
#include ""io.hpp""
#include ""metadata.hpp""

NS_PROJ_START

namespace crs {
class CRS;
using CRSPtr = std::shared_ptr<CRS>;
using CRSNNPtr = util::nn<CRSPtr>;

class DerivedCRS;
class ProjectedCRS;
} // namespace crs

/** osgeo.proj.operation namespace

  \\brief Coordinate operations (relationship between any two coordinate
  reference systems).

  This covers Conversion, Transformation,
  PointMotionOperation or ConcatenatedOperation.
*/
namespace operation {

// ---------------------------------------------------------------------------

/** \\brief Grid description */
struct GridDescription {
    std::string shortName;   /**< Grid short filename */
    std::string fullName;    /**< Grid full path name (if found) */
    std::string packageName; /**< Package name (or empty) */
    std::string url;         /**< Grid URL (if packageName is empty), or package
                                    URL (or empty) */
    bool directDownload;     /**< Whether url can be fetched directly. */
    /** Whether the grid is released with an open license. */
    bool openLicense;
    bool available; /**< Whether GRID is available. */

    //! @cond Doxygen_Suppress
    bool operator<(const GridDescription &other) const {
        return shortName < other.shortName;
    }

    PROJ_DLL GridDescription();
    PROJ_DLL ~GridDescription();
    PROJ_DLL GridDescription(const GridDescription &);
    PROJ_DLL GridDescription(GridDescription &&) noexcept;
    //! @endcond
};

// ---------------------------------------------------------------------------

class CoordinateOperation;
/** Shared pointer of CoordinateOperation */
using CoordinateOperationPtr = std::shared_ptr<CoordinateOperation>;
/** Non-null shared pointer of CoordinateOperation */
using CoordinateOperationNNPtr = util::nn<CoordinateOperationPtr>;

/** \\brief Abstract class for a mathematical operation on coordinates.
 *
 * A mathematical operation:
 * <ul>
 * <li>on coordinates that transforms or converts them from one coordinate
 * reference system to another coordinate reference system</li>
 * <li>or that describes the change of coordinate values within one coordinate
 * reference system due to the motion of the point between one coordinate epoch
 * and another coordinate epoch.</li>
 * </ul>
 * Many but not all coordinate operations (from CRS A to CRS B) also uniquely
 * define the inverse coordinate operation (from CRS B to CRS A). In some cases,
 * the coordinate operation method algorithm for the inverse coordinate
 * operation is the same as for the forward algorithm, but the signs of some
 * coordinate operation parameter values have to be reversed. In other cases,
 * different algorithms are required for the forward and inverse coordinate
 * operations, but the same coordinate operation parameter values are used. If
 * (some) entirely different parameter values are needed, a different coordinate
 * operation shall be defined.
 *
 * \\remark Implements CoordinateOperation from \\ref ISO_19111_2019
 */
class PROJ_GCC_DLL CoordinateOperation : public common::ObjectUsage,
                                         public io::IPROJStringExportable,
                                         public io::IJSONExportable {
  public:
    //! @cond Doxygen_Suppress
    PROJ_DLL ~CoordinateOperation() override;
    //! @endcond

    PROJ_DLL const util::optional<std::string> &operationVersion() const;
    PROJ_DLL const std::vector<metadata::PositionalAccuracyNNPtr> &
    coordinateOperationAccuracies() const;

    PROJ_DLL const crs::CRSPtr sourceCRS() const;
    PROJ_DLL const crs::CRSPtr targetCRS() const;
    PROJ_DLL const crs::CRSPtr &interpolationCRS() const;
    PROJ_DLL const util::optional<common::DataEpoch> &
    sourceCoordinateEpoch() const;
    PROJ_DLL const util::optional<common::DataEpoch> &
    targetCoordinateEpoch() const;

    // virtual void transform(...) = 0;  TODO

    /** \\brief Return the inverse of the coordinate operation.
     * @throw util::UnsupportedOperationException
     */
    PROJ_DLL virtual CoordinateOperationNNPtr inverse() const = 0;

    /** \\brief Return grids needed by an operation. */
    PROJ_DLL virtual std::set<GridDescription>
    gridsNeeded(const io::DatabaseContextPtr &databaseContext) const = 0;

    PROJ_DLL bool
    isPROJInstantiable(const io::DatabaseContextPtr &databaseContext) const;

    PROJ_DLL bool hasBallparkTransformation() const;

    PROJ_DLL static const std::string OPERATION_VERSION_KEY;

    PROJ_DLL CoordinateOperationNNPtr normalizeForVisualization() const;

    PROJ_PRIVATE :
        //! @cond Doxygen_Suppress
        PROJ_FOR_TEST CoordinateOperationNNPtr
        shallowClone() const;
    //! @endcond

  protected:
    PROJ_INTERNAL CoordinateOperation();
    PROJ_INTERNAL CoordinateOperation(const CoordinateOperation &other);

    PROJ_FRIEND(crs::DerivedCRS);
    PROJ_FRIEND(io::AuthorityFactory);
    PROJ_FRIEND(CoordinateOperationFactory);
    PROJ_FRIEND(ConcatenatedOperation);
    PROJ_INTERNAL void
    setWeakSourceTargetCRS(std::weak_ptr<crs::CRS> sourceCRSIn,
                           std::weak_ptr<crs::CRS> targetCRSIn);
    PROJ_INTERNAL void setCRSs(const crs::CRSNNPtr &sourceCRSIn,
                               const crs::CRSNNPtr &targetCRSIn,
                               const crs::CRSPtr &interpolationCRSIn);
    PROJ_INTERNAL void setCRSs(const CoordinateOperation *in,
                               bool inverseSourceTarget);
    PROJ_INTERNAL
    void setAccuracies(
        const std::vector<metadata::PositionalAccuracyNNPtr> &accuracies);
    PROJ_INTERNAL void setHasBallparkTransformation(bool b);

    PROJ_INTERNAL void
    setProperties(const util::PropertyMap
                      &properties); // throw(InvalidValueTypeException)

    PROJ_INTERNAL virtual CoordinateOperationNNPtr _shallowClone() const = 0;

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    CoordinateOperation &operator=(const CoordinateOperation &other) = delete;
};

// ---------------------------------------------------------------------------

/** \\brief Abstract class modelling a parameter value (OperationParameter)
 * or group of parameters.
 *
 * \\remark Implements GeneralOperationParameter from \\ref ISO_19111_2019
 */
class PROJ_GCC_DLL GeneralOperationParameter : public common::IdentifiedObject {
  public:
    //! @cond Doxygen_Suppress
    PROJ_DLL ~GeneralOperationParameter() override;
    //! @endcond

    //! @cond Doxygen_Suppress
    PROJ_INTERNAL bool _isEquivalentTo(
        const util::IComparable *other,
        util::IComparable::Criterion criterion =
            util::IComparable::Criterion::STRICT) const override = 0;
    //! @endcond

  protected:
    PROJ_INTERNAL GeneralOperationParameter();
    PROJ_INTERNAL
    GeneralOperationParameter(const GeneralOperationParameter &other);

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    GeneralOperationParameter &
    operator=(const GeneralOperationParameter &other) = delete;
};

/** Shared pointer of GeneralOperationParameter */
using GeneralOperationParameterPtr = std::shared_ptr<GeneralOperationParameter>;
/** Non-null shared pointer of GeneralOperationParameter */
using GeneralOperationParameterNNPtr = util::nn<GeneralOperationParameterPtr>;

// ---------------------------------------------------------------------------

class OperationParameter;
/** Shared pointer of OperationParameter */
using OperationParameterPtr = std::shared_ptr<OperationParameter>;
/** Non-null shared pointer of OperationParameter */
using OperationParameterNNPtr = util::nn<OperationParameterPtr>;

/** \\brief The definition of a parameter used by a coordinate operation method.
 *
 * Most parameter values are numeric, but other types of parameter values are
 * possible.
 *
 * \\remark Implements OperationParameter from \\ref ISO_19111_2019
 */
class PROJ_GCC_DLL OperationParameter final : public GeneralOperationParameter {
  public:
    //! @cond Doxygen_Suppress
    PROJ_DLL ~OperationParameter() override;
    //! @endcond

    //! @cond Doxygen_Suppress
    PROJ_INTERNAL bool
    _isEquivalentTo(const util::IComparable *other,
                    util::IComparable::Criterion criterion =
                        util::IComparable::Criterion::STRICT) const override;
    //! @endcond

    // non-standard
    PROJ_DLL static OperationParameterNNPtr
    create(const util::PropertyMap &properties);

    PROJ_DLL int getEPSGCode() PROJ_PURE_DECL;

    PROJ_DLL static const char *getNameForEPSGCode(int epsg_code) noexcept;

  protected:
    PROJ_INTERNAL OperationParameter();
    PROJ_INTERNAL OperationParameter(const OperationParameter &other);
    INLINED_MAKE_SHARED

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    OperationParameter &operator=(const OperationParameter &other) = delete;

    // cppcheck-suppress functionStatic
    PROJ_INTERNAL void _exportToWKT(io::WKTFormatter *formatter)
        const override; // throw(io::FormattingException)
};

// ---------------------------------------------------------------------------

//! @cond Doxygen_Suppress
struct MethodMapping;
//! @endcond

/** \\brief Abstract class modelling a parameter value (OperationParameterValue)
 * or group of parameter values.
 *
 * \\remark Implements GeneralParameterValue from \\ref ISO_19111_2019
 */
class PROJ_GCC_DLL GeneralParameterValue : public util::BaseObject,
                                           public io::IWKTExportable,
                                           public io::IJSONExportable,
                                           public util::IComparable {
  public:
    //! @cond Doxygen_Suppress
    PROJ_DLL ~GeneralParameterValue() override;

    PROJ_INTERNAL void _exportToWKT(io::WKTFormatter *formatter)
        const override = 0; // throw(io::FormattingException)

    PROJ_INTERNAL void _exportToJSON(io::JSONFormatter *formatter)
        const override = 0; // throw(FormattingException)

    PROJ_INTERNAL bool _isEquivalentTo(
        const util::IComparable *other,
        util::IComparable::Criterion criterion =
            util::IComparable::Criterion::STRICT) const override = 0;
    //! @endcond

  protected:
    //! @cond Doxygen_Suppress
    PROJ_INTERNAL GeneralParameterValue();
    PROJ_INTERNAL GeneralParameterValue(const GeneralParameterValue &other);

    friend class Conversion;
    friend class SingleOperation;
    PROJ_INTERNAL virtual void _exportToWKT(io::WKTFormatter *formatter,
                                            const MethodMapping *mapping)
        const = 0; // throw(io::FormattingException)
                   //! @endcond

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    GeneralParameterValue &
    operator=(const GeneralParameterValue &other) = delete;
};

/** Shared pointer of GeneralParameterValue */
using GeneralParameterValuePtr = std::shared_ptr<GeneralParameterValue>;
/** Non-null shared pointer of GeneralParameterValue */
using GeneralParameterValueNNPtr = util::nn<GeneralParameterValuePtr>;

// ---------------------------------------------------------------------------

class ParameterValue;
/** Shared pointer of ParameterValue */
using ParameterValuePtr = std::shared_ptr<ParameterValue>;
/** Non-null shared pointer of ParameterValue */
using ParameterValueNNPtr = util::nn<ParameterValuePtr>;

/** \\brief The value of the coordinate operation parameter.
 *
 * Most parameter values are numeric, but other types of parameter values are
 * possible.
 *
 * \\remark Implements ParameterValue from \\ref ISO_19111_2019
 */
class PROJ_GCC_DLL ParameterValue final : public util::BaseObject,
                                          public io::IWKTExportable,
                                          public util::IComparable {
  public:
    /** Type of the value. */
    enum class Type {
        /** Measure (i.e. value with a unit) */
        MEASURE,
        /** String */
        STRING,
        /** Integer */
        INTEGER,
        /** Boolean */
        BOOLEAN,
        /** Filename */
        FILENAME
    };
    //! @cond Doxygen_Suppress
    PROJ_DLL ~ParameterValue() override;

    PROJ_INTERNAL void _exportToWKT(io::WKTFormatter *formatter)
        const override; // throw(io::FormattingException)
    //! @endcond

    PROJ_DLL static ParameterValueNNPtr
    create(const common::Measure &measureIn);
    PROJ_DLL static ParameterValueNNPtr create(const char *stringValueIn);
    PROJ_DLL static ParameterValueNNPtr
    create(const std::string &stringValueIn);
    PROJ_DLL static ParameterValueNNPtr create(int integerValueIn);
    PROJ_DLL static ParameterValueNNPtr create(bool booleanValueIn);
    PROJ_DLL static ParameterValueNNPtr
    createFilename(const std::string &stringValueIn);

    PROJ_DLL const Type &type() PROJ_PURE_DECL;
    PROJ_DLL const common::Measure &value() PROJ_PURE_DECL;
    PROJ_DLL const std::string &stringValue() PROJ_PURE_DECL;
    PROJ_DLL const std::string &valueFile() PROJ_PURE_DECL;
    PROJ_DLL int integerValue() PROJ_PURE_DECL;
    PROJ_DLL bool booleanValue() PROJ_PURE_DECL;

    //! @cond Doxygen_Suppress
    PROJ_INTERNAL bool
    _isEquivalentTo(const util::IComparable *other,
                    util::IComparable::Criterion criterion =
                        util::IComparable::Criterion::STRICT) const override;
    //! @endcond

  protected:
    PROJ_INTERNAL explicit ParameterValue(const common::Measure &measureIn);
    PROJ_INTERNAL explicit ParameterValue(const std::string &stringValueIn,
                                          Type typeIn);
    PROJ_INTERNAL explicit ParameterValue(int integerValueIn);
    PROJ_INTERNAL explicit ParameterValue(bool booleanValueIn);
    INLINED_MAKE_SHARED
  private:
    PROJ_OPAQUE_PRIVATE_DATA
    ParameterValue &operator=(const ParameterValue &other) = delete;
};

// ---------------------------------------------------------------------------

class OperationParameterValue;
/** Shared pointer of OperationParameterValue */
using OperationParameterValuePtr = std::shared_ptr<OperationParameterValue>;
/** Non-null shared pointer of OperationParameterValue */
using OperationParameterValueNNPtr = util::nn<OperationParameterValuePtr>;

/** \\brief A parameter value, ordered sequence of values, or reference to a
 * file of parameter values.
 *
 * This combines a OperationParameter with the corresponding ParameterValue.
 *
 * \\remark Implements OperationParameterValue from \\ref ISO_19111_2019
 */
class PROJ_GCC_DLL OperationParameterValue final
    : public GeneralParameterValue {
  public:
    //! @cond Doxygen_Suppress
    PROJ_DLL ~OperationParameterValue() override;
    //! @endcond

    PROJ_DLL const OperationParameterNNPtr &parameter() PROJ_PURE_DECL;
    PROJ_DLL const ParameterValueNNPtr &parameterValue() PROJ_PURE_DECL;

    PROJ_DLL static OperationParameterValueNNPtr
    create(const OperationParameterNNPtr &parameterIn,
           const ParameterValueNNPtr &valueIn);

    PROJ_PRIVATE :
        //! @cond Doxygen_Suppress
        PROJ_INTERNAL static bool
        convertFromAbridged(const std::string &paramName, double &val,
                            const common::UnitOfMeasure *&unit,
                            int &paramEPSGCode);

    PROJ_INTERNAL void _exportToWKT(io::WKTFormatter *formatter)
        const override; // throw(io::FormattingException)

    PROJ_INTERNAL void _exportToJSON(io::JSONFormatter *formatter)
        const override; // throw(FormattingException)

    PROJ_INTERNAL bool
    _isEquivalentTo(const util::IComparable *other,
                    util::IComparable::Criterion criterion =
                        util::IComparable::Criterion::STRICT) const override;
    //! @endcond

  protected:
    PROJ_INTERNAL
    OperationParameterValue(const OperationParameterNNPtr &parameterIn,
                            const ParameterValueNNPtr &valueIn);
    PROJ_INTERNAL OperationParameterValue(const OperationParameterValue &other);
    INLINED_MAKE_SHARED

    PROJ_INTERNAL void _exportToWKT(io::WKTFormatter *formatter,
                                    const MethodMapping *mapping)
        const override; // throw(io::FormattingException)

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    OperationParameterValue &
    operator=(const OperationParameterValue &other) = delete;
};

// ---------------------------------------------------------------------------

class OperationMethod;
/** Shared pointer of OperationMethod */
using OperationMethodPtr = std::shared_ptr<OperationMethod>;
/** Non-null shared pointer of OperationMethod */
using OperationMethodNNPtr = util::nn<OperationMethodPtr>;

/** \\brief The method (algorithm or procedure) used to perform the
 * coordinate operation.
 *
 * For a projection method, this contains the name of the projection method
 * and the name of the projection parameters.
 *
 * \\remark Implements OperationMethod from \\ref ISO_19111_2019
 */
class PROJ_GCC_DLL OperationMethod : public common::IdentifiedObject,
                                     public io::IJSONExportable {
  public:
    //! @cond Doxygen_Suppress
    PROJ_DLL ~OperationMethod() override;
    //! @endcond

    PROJ_DLL const util::optional<std::string> &formula() PROJ_PURE_DECL;
    PROJ_DLL const util::optional<metadata::Citation> &
    formulaCitation() PROJ_PURE_DECL;
    PROJ_DLL const std::vector<GeneralOperationParameterNNPtr> &
    parameters() PROJ_PURE_DECL;

    PROJ_DLL static OperationMethodNNPtr
    create(const util::PropertyMap &properties,
           const std::vector<GeneralOperationParameterNNPtr> &parameters);

    PROJ_DLL static OperationMethodNNPtr
    create(const util::PropertyMap &properties,
           const std::vector<OperationParameterNNPtr> &parameters);

    PROJ_DLL int getEPSGCode() PROJ_PURE_DECL;

    //! @cond Doxygen_Suppress
    PROJ_INTERNAL void _exportToWKT(io::WKTFormatter *formatter)
        const override; // throw(io::FormattingException)

    PROJ_INTERNAL void _exportToJSON(io::JSONFormatter *formatter)
        const override; // throw(FormattingException)

    PROJ_INTERNAL bool
    _isEquivalentTo(const util::IComparable *other,
                    util::IComparable::Criterion criterion =
                        util::IComparable::Criterion::STRICT) const override;
    //! @endcond

  protected:
    PROJ_INTERNAL OperationMethod();
    PROJ_INTERNAL OperationMethod(const OperationMethod &other);
    INLINED_MAKE_SHARED
    friend class Conversion;

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    OperationMethod &operator=(const OperationMethod &other) = delete;
};

// ---------------------------------------------------------------------------

/** \\brief Exception that can be thrown when an invalid operation is attempted
 * to be constructed.
 */
class PROJ_GCC_DLL InvalidOperation : public util::Exception {
  public:
    //! @cond Doxygen_Suppress
    PROJ_INTERNAL explicit InvalidOperation(const char *message);
    PROJ_INTERNAL explicit InvalidOperation(const std::string &message);
    PROJ_DLL InvalidOperation(const InvalidOperation &other);
    PROJ_DLL ~InvalidOperation() override;
    //! @endcond
};

// ---------------------------------------------------------------------------

class SingleOperation;
/** Shared pointer of SingleOperation */
using SingleOperationPtr = std::shared_ptr<SingleOperation>;
/** Non-null shared pointer of SingleOperation */
using SingleOperationNNPtr = util::nn<SingleOperationPtr>;

/** \\brief A single (not concatenated) coordinate operation
 * (CoordinateOperation)
 *
 * \\remark Implements SingleOperation from \\ref ISO_19111_2019
 */
class PROJ_GCC_DLL SingleOperation : virtual public CoordinateOperation {
  public:
    //! @cond Doxygen_Suppress
    PROJ_DLL ~SingleOperation() override;
    //! @endcond

    PROJ_DLL const std::vector<GeneralParameterValueNNPtr> &
    parameterValues() PROJ_PURE_DECL;
    PROJ_DLL const OperationMethodNNPtr &method() PROJ_PURE_DECL;

    PROJ_DLL const ParameterValuePtr &
    parameterValue(const std::string &paramName, int epsg_code = 0) const
        noexcept;

    PROJ_DLL const ParameterValuePtr &parameterValue(int epsg_code) const
        noexcept;

    PROJ_DLL const common::Measure &
    parameterValueMeasure(const std::string &paramName, int epsg_code = 0) const
        noexcept;

    PROJ_DLL const common::Measure &parameterValueMeasure(int epsg_code) const
        noexcept;

    PROJ_DLL static SingleOperationNNPtr createPROJBased(
        const util::PropertyMap &properties, const std::string &PROJString,
        const crs::CRSPtr &sourceCRS, const crs::CRSPtr &targetCRS,
        const std::vector<metadata::PositionalAccuracyNNPtr> &accuracies =
            std::vector<metadata::PositionalAccuracyNNPtr>());

    PROJ_DLL std::set<GridDescription>
    gridsNeeded(const io::DatabaseContextPtr &databaseContext) const override;

    PROJ_DLL std::list<std::string> validateParameters() const;

    PROJ_PRIVATE :
        //! @cond Doxygen_Suppress

        PROJ_DLL double
        parameterValueNumeric(int epsg_code,
                              const common::UnitOfMeasure &targetUnit) const
        noexcept;

    PROJ_INTERNAL double parameterValueNumericAsSI(int epsg_code) const
        noexcept;

    PROJ_INTERNAL bool
    _isEquivalentTo(const util::IComparable *other,
                    util::IComparable::Criterion criterion =
                        util::IComparable::Criterion::STRICT) const override;
    //! @endcond

  protected:
    PROJ_INTERNAL explicit SingleOperation(
        const OperationMethodNNPtr &methodIn);
    PROJ_INTERNAL SingleOperation(const SingleOperation &other);

    PROJ_INTERNAL void
    setParameterValues(const std::vector<GeneralParameterValueNNPtr> &values);

    PROJ_INTERNAL void
    exportTransformationToWKT(io::WKTFormatter *formatter) const;

    PROJ_INTERNAL bool
    exportToPROJStringGeneric(io::PROJStringFormatter *formatter) const;

    PROJ_INTERNAL bool _isEquivalentTo(const util::IComparable *other,
                                       util::IComparable::Criterion criterion,
                                       bool inOtherDirection) const;

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    SingleOperation &operator=(const SingleOperation &other) = delete;
};

// ---------------------------------------------------------------------------

class Conversion;
/** Shared pointer of Conversion */
using ConversionPtr = std::shared_ptr<Conversion>;
/** Non-null shared pointer of Conversion */
using ConversionNNPtr = util::nn<ConversionPtr>;

/** \\brief A mathematical operation on coordinates in which the parameter
 * values are defined rather than empirically derived.
 *
 * Application of the coordinate conversion introduces no error into output
 * coordinates. The best-known example of a coordinate conversion is a map
 * projection. For coordinate conversions the output coordinates are referenced
 * to the same datum as are the input coordinates.
 *
 * Coordinate conversions forming a component of a derived CRS have a source
 * crs::CRS and a target crs::CRS that are NOT specified through the source and
 * target
 * associations, but through associations from crs::DerivedCRS to
 * crs::SingleCRS.
 *
 * \\remark Implements Conversion from \\ref ISO_19111_2019
 */

/*!

\\section projection_parameters Projection parameters

\\subsection colatitude_cone_axis Co-latitude of cone axis

The rotation applied to spherical coordinates for the oblique projection,
measured on the conformal sphere in the plane of the meridian of origin.

EPSG:1036

\\subsection center_latitude Latitude of natural origin/Center Latitude

The latitude of the point from which the values of both the geographical
coordinates on the ellipsoid and the grid coordinates on the projection are
deemed to increment or decrement for computational purposes. Alternatively it
may be considered as the latitude of the point which in the absence of
application of false coordinates has grid coordinates of (0,0).

EPSG:8801

\\subsection center_longitude Longitude of natural origin/Central Meridian

The longitude of the point from which the values of both the geographical
coordinates on the ellipsoid and the grid coordinates on the projection are
deemed to increment or decrement for computational purposes. Alternatively it
may be considered as the longitude of the point which in the absence of
application of false coordinates has grid coordinates of (0,0).  Sometimes known
as ""central meridian (CM)"".

EPSG:8802

\\subsection scale Scale Factor

The factor by which the map grid is reduced or enlarged during the projection
process, defined by its value at the natural origin.

EPSG:8805

\\subsection false_easting False Easting

Since the natural origin may be at or near the centre of the projection and
under normal coordinate circumstances would thus give rise to negative
coordinates over parts of the mapped area, this origin is usually given false
coordinates which are large enough to avoid this inconvenience. The False
Easting, FE, is the value assigned to the abscissa (east or west) axis of the
projection grid at the natural origin.

EPSG:8806

\\subsection false_northing False Northing

Since the natural origin may be at or near the centre of the projection and
under normal coordinate circumstances would thus give rise to negative
coordinates over parts of the mapped area, this origin is usually given false
coordinates which are large enough to avoid this inconvenience. The False
Northing, FN, is the value assigned to the ordinate (north or south) axis of the
projection grid at the natural origin.

EPSG:8807

\\subsection latitude_projection_centre Latitute of projection centre

For an oblique projection, this is the latitude of the point at which the
azimuth of the central line is defined.

EPSG:8811

\\subsection longitude_projection_centre Longitude of projection centre

For an oblique projection, this is the longitude of the point at which the
azimuth of the central line is defined.

EPSG:8812

\\subsection azimuth_initial_line Azimuth of initial line

The azimuthal direction (north zero, east of north being positive) of the great
circle which is the centre line of an oblique projection. The azimuth is given
at the projection centre.

EPSG:8813

\\subsection angle_from_recitfied_to_skrew_grid Angle from Rectified to Skew Grid

The angle at the natural origin of an oblique projection through which the
natural coordinate reference system is rotated to make the projection north
axis parallel with true north.

EPSG:8814

\\subsection scale_factor_initial_line Scale factor on initial line

The factor by which the map grid is reduced or enlarged during the projection
process, defined by its value at the projection center.

EPSG:8815

\\subsection easting_projection_centre Easting at projection centre

The easting value assigned to the projection centre.

EPSG:8816

\\subsection northing_projection_centre Northing at projection centre

The northing value assigned to the projection centre.

EPSG:8817

\\subsection latitude_pseudo_standard_parallel Latitude of pseudo standard
parallel

Latitude of the parallel on which the conic or cylindrical projection is based.
This latitude is not geographic, but is defined on the conformal sphere AFTER
its rotation to obtain the oblique aspect of the projection.

EPSG:8818

\\subsection scale_factor_pseudo_standard_parallel Scale factor on pseudo
standard parallel

The factor by which the map grid is reduced or enlarged during the projection
process, defined by its value at the pseudo-standard parallel.
EPSG:8819

\\subsection latitude_false_origin Latitude of false origin

The latitude of the point which is not the natural origin and at which grid
coordinate values false easting and false northing are defined.

EPSG:8821

\\subsection longitude_false_origin Longitude of false origin

The longitude of the point which is not the natural origin and at which grid
coordinate values false easting and false northing are defined.

EPSG:8822

\\subsection latitude_first_std_parallel Latitude of 1st standard parallel

For a conic projection with two standard parallels, this is the latitude of one
of the parallels of intersection of the cone with the ellipsoid. It is normally
but not necessarily that nearest to the pole. Scale is true along this parallel.

EPSG:8823

\\subsection latitude_second_std_parallel Latitude of 2nd standard parallel

For a conic projection with two standard parallels, this is the latitude of one
of the parallels at which the cone intersects with the ellipsoid. It is normally
but not necessarily that nearest to the equator. Scale is true along this
parallel.

EPSG:8824

\\subsection easting_false_origin Easting of false origin

The easting value assigned to the false origin.

EPSG:8826

\\subsection northing_false_origin Northing of false origin

The northing value assigned to the false origin.

EPSG:8827

\\subsection latitude_std_parallel Latitude of standard parallel

For polar aspect azimuthal projections, the parallel on which the scale factor
is defined to be unity.

EPSG:8832

\\subsection longitude_of_origin Longitude of origin

For polar aspect azimuthal projections, the meridian along which the
northing axis increments and also across which parallels of latitude
increment towards the north pole.

EPSG:8833

*/

class PROJ_GCC_DLL Conversion : public SingleOperation {
  public:
    //! @cond Doxygen_Suppress
    PROJ_DLL ~Conversion() override;
    //! @endcond

    PROJ_DLL CoordinateOperationNNPtr inverse() const override;

    //! @cond Doxygen_Suppress
    PROJ_INTERNAL void _exportToWKT(io::WKTFormatter *formatter)
        const override; // throw(io::FormattingException)
    //! @endcond

    PROJ_DLL bool isUTM(int &zone, bool &north) const;

    PROJ_DLL ConversionNNPtr identify() const;

    PROJ_DLL static ConversionNNPtr
    create(const util::PropertyMap &properties,
           const OperationMethodNNPtr &methodIn,
           const std::vector<GeneralParameterValueNNPtr>
               &values); // throw InvalidOperation

    PROJ_DLL static ConversionNNPtr
    create(const util::PropertyMap &propertiesConversion,
           const util::PropertyMap &propertiesOperationMethod,
           const std::vector<OperationParameterNNPtr> &parameters,
           const std::vector<ParameterValueNNPtr>
               &values); // throw InvalidOperation

    PROJ_DLL static ConversionNNPtr
    createUTM(const util::PropertyMap &properties, int zone, bool north);

    PROJ_DLL static ConversionNNPtr createTransverseMercator(
        const util::PropertyMap &properties, const common::Angle &centerLat,
        const common::Angle &centerLong, const common::Scale &scale,
        const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createGaussSchreiberTransverseMercator(
        const util::PropertyMap &properties, const common::Angle &centerLat,
        const common::Angle &centerLong, const common::Scale &scale,
        const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createTransverseMercatorSouthOriented(
        const util::PropertyMap &properties, const common::Angle &centerLat,
        const common::Angle &centerLong, const common::Scale &scale,
        const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createTwoPointEquidistant(const util::PropertyMap &properties,
                              const common::Angle &latitudeFirstPoint,
                              const common::Angle &longitudeFirstPoint,
                              const common::Angle &latitudeSecondPoint,
                              const common::Angle &longitudeSeconPoint,
                              const common::Length &falseEasting,
                              const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createTunisiaMappingGrid(
        const util::PropertyMap &properties, const common::Angle &centerLat,
        const common::Angle &centerLong, const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createAlbersEqualArea(const util::PropertyMap &properties,
                          const common::Angle &latitudeFalseOrigin,
                          const common::Angle &longitudeFalseOrigin,
                          const common::Angle &latitudeFirstParallel,
                          const common::Angle &latitudeSecondParallel,
                          const common::Length &eastingFalseOrigin,
                          const common::Length &northingFalseOrigin);

    PROJ_DLL static ConversionNNPtr createLambertConicConformal_1SP(
        const util::PropertyMap &properties, const common::Angle &centerLat,
        const common::Angle &centerLong, const common::Scale &scale,
        const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createLambertConicConformal_2SP(const util::PropertyMap &properties,
                                    const common::Angle &latitudeFalseOrigin,
                                    const common::Angle &longitudeFalseOrigin,
                                    const common::Angle &latitudeFirstParallel,
                                    const common::Angle &latitudeSecondParallel,
                                    const common::Length &eastingFalseOrigin,
                                    const common::Length &northingFalseOrigin);

    PROJ_DLL static ConversionNNPtr createLambertConicConformal_2SP_Michigan(
        const util::PropertyMap &properties,
        const common::Angle &latitudeFalseOrigin,
        const common::Angle &longitudeFalseOrigin,
        const common::Angle &latitudeFirstParallel,
        const common::Angle &latitudeSecondParallel,
        const common::Length &eastingFalseOrigin,
        const common::Length &northingFalseOrigin,
        const common::Scale &ellipsoidScalingFactor);

    PROJ_DLL static ConversionNNPtr createLambertConicConformal_2SP_Belgium(
        const util::PropertyMap &properties,
        const common::Angle &latitudeFalseOrigin,
        const common::Angle &longitudeFalseOrigin,
        const common::Angle &latitudeFirstParallel,
        const common::Angle &latitudeSecondParallel,
        const common::Length &eastingFalseOrigin,
        const common::Length &northingFalseOrigin);

    PROJ_DLL static ConversionNNPtr
    createAzimuthalEquidistant(const util::PropertyMap &properties,
                               const common::Angle &latitudeNatOrigin,
                               const common::Angle &longitudeNatOrigin,
                               const common::Length &falseEasting,
                               const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createGuamProjection(const util::PropertyMap &properties,
                         const common::Angle &latitudeNatOrigin,
                         const common::Angle &longitudeNatOrigin,
                         const common::Length &falseEasting,
                         const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createBonne(const util::PropertyMap &properties,
                const common::Angle &latitudeNatOrigin,
                const common::Angle &longitudeNatOrigin,
                const common::Length &falseEasting,
                const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createLambertCylindricalEqualAreaSpherical(
        const util::PropertyMap &properties,
        const common::Angle &latitudeFirstParallel,
        const common::Angle &longitudeNatOrigin,
        const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createLambertCylindricalEqualArea(
        const util::PropertyMap &properties,
        const common::Angle &latitudeFirstParallel,
        const common::Angle &longitudeNatOrigin,
        const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createCassiniSoldner(
        const util::PropertyMap &properties, const common::Angle &centerLat,
        const common::Angle &centerLong, const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createEquidistantConic(const util::PropertyMap &properties,
                           const common::Angle &centerLat,
                           const common::Angle &centerLong,
                           const common::Angle &latitudeFirstParallel,
                           const common::Angle &latitudeSecondParallel,
                           const common::Length &falseEasting,
                           const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createEckertI(const util::PropertyMap &properties,
                  const common::Angle &centerLong,
                  const common::Length &falseEasting,
                  const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createEckertII(const util::PropertyMap &properties,
                   const common::Angle &centerLong,
                   const common::Length &falseEasting,
                   const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createEckertIII(const util::PropertyMap &properties,
                    const common::Angle &centerLong,
                    const common::Length &falseEasting,
                    const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createEckertIV(const util::PropertyMap &properties,
                   const common::Angle &centerLong,
                   const common::Length &falseEasting,
                   const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createEckertV(const util::PropertyMap &properties,
                  const common::Angle &centerLong,
                  const common::Length &falseEasting,
                  const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createEckertVI(const util::PropertyMap &properties,
                   const common::Angle &centerLong,
                   const common::Length &falseEasting,
                   const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createEquidistantCylindrical(const util::PropertyMap &properties,
                                 const common::Angle &latitudeFirstParallel,
                                 const common::Angle &longitudeNatOrigin,
                                 const common::Length &falseEasting,
                                 const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createEquidistantCylindricalSpherical(
        const util::PropertyMap &properties,
        const common::Angle &latitudeFirstParallel,
        const common::Angle &longitudeNatOrigin,
        const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createGall(const util::PropertyMap &properties,
               const common::Angle &centerLong,
               const common::Length &falseEasting,
               const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createGoodeHomolosine(const util::PropertyMap &properties,
                          const common::Angle &centerLong,
                          const common::Length &falseEasting,
                          const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createInterruptedGoodeHomolosine(const util::PropertyMap &properties,
                                     const common::Angle &centerLong,
                                     const common::Length &falseEasting,
                                     const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createGeostationarySatelliteSweepX(
        const util::PropertyMap &properties, const common::Angle &centerLong,
        const common::Length &height, const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createGeostationarySatelliteSweepY(
        const util::PropertyMap &properties, const common::Angle &centerLong,
        const common::Length &height, const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createGnomonic(
        const util::PropertyMap &properties, const common::Angle &centerLat,
        const common::Angle &centerLong, const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createHotineObliqueMercatorVariantA(
        const util::PropertyMap &properties,
        const common::Angle &latitudeProjectionCentre,
        const common::Angle &longitudeProjectionCentre,
        const common::Angle &azimuthInitialLine,
        const common::Angle &angleFromRectifiedToSkrewGrid,
        const common::Scale &scale, const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createHotineObliqueMercatorVariantB(
        const util::PropertyMap &properties,
        const common::Angle &latitudeProjectionCentre,
        const common::Angle &longitudeProjectionCentre,
        const common::Angle &azimuthInitialLine,
        const common::Angle &angleFromRectifiedToSkrewGrid,
        const common::Scale &scale,
        const common::Length &eastingProjectionCentre,
        const common::Length &northingProjectionCentre);

    PROJ_DLL static ConversionNNPtr
    createHotineObliqueMercatorTwoPointNaturalOrigin(
        const util::PropertyMap &properties,
        const common::Angle &latitudeProjectionCentre,
        const common::Angle &latitudePoint1,
        const common::Angle &longitudePoint1,
        const common::Angle &latitudePoint2,
        const common::Angle &longitudePoint2, const common::Scale &scale,
        const common::Length &eastingProjectionCentre,
        const common::Length &northingProjectionCentre);

    PROJ_DLL static ConversionNNPtr
    createLabordeObliqueMercator(const util::PropertyMap &properties,
                                 const common::Angle &latitudeProjectionCentre,
                                 const common::Angle &longitudeProjectionCentre,
                                 const common::Angle &azimuthInitialLine,
                                 const common::Scale &scale,
                                 const common::Length &falseEasting,
                                 const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createInternationalMapWorldPolyconic(
        const util::PropertyMap &properties, const common::Angle &centerLong,
        const common::Angle &latitudeFirstParallel,
        const common::Angle &latitudeSecondParallel,
        const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createKrovakNorthOriented(
        const util::PropertyMap &properties,
        const common::Angle &latitudeProjectionCentre,
        const common::Angle &longitudeOfOrigin,
        const common::Angle &colatitudeConeAxis,
        const common::Angle &latitudePseudoStandardParallel,
        const common::Scale &scaleFactorPseudoStandardParallel,
        const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createKrovak(const util::PropertyMap &properties,
                 const common::Angle &latitudeProjectionCentre,
                 const common::Angle &longitudeOfOrigin,
                 const common::Angle &colatitudeConeAxis,
                 const common::Angle &latitudePseudoStandardParallel,
                 const common::Scale &scaleFactorPseudoStandardParallel,
                 const common::Length &falseEasting,
                 const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createLambertAzimuthalEqualArea(const util::PropertyMap &properties,
                                    const common::Angle &latitudeNatOrigin,
                                    const common::Angle &longitudeNatOrigin,
                                    const common::Length &falseEasting,
                                    const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createMillerCylindrical(const util::PropertyMap &properties,
                            const common::Angle &centerLong,
                            const common::Length &falseEasting,
                            const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createMercatorVariantA(
        const util::PropertyMap &properties, const common::Angle &centerLat,
        const common::Angle &centerLong, const common::Scale &scale,
        const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createMercatorVariantB(const util::PropertyMap &properties,
                           const common::Angle &latitudeFirstParallel,
                           const common::Angle &centerLong,
                           const common::Length &falseEasting,
                           const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createPopularVisualisationPseudoMercator(
        const util::PropertyMap &properties, const common::Angle &centerLat,
        const common::Angle &centerLong, const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createMollweide(const util::PropertyMap &properties,
                    const common::Angle &centerLong,
                    const common::Length &falseEasting,
                    const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createNewZealandMappingGrid(
        const util::PropertyMap &properties, const common::Angle &centerLat,
        const common::Angle &centerLong, const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createObliqueStereographic(
        const util::PropertyMap &properties, const common::Angle &centerLat,
        const common::Angle &centerLong, const common::Scale &scale,
        const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createOrthographic(
        const util::PropertyMap &properties, const common::Angle &centerLat,
        const common::Angle &centerLong, const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createAmericanPolyconic(
        const util::PropertyMap &properties, const common::Angle &centerLat,
        const common::Angle &centerLong, const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createPolarStereographicVariantA(
        const util::PropertyMap &properties, const common::Angle &centerLat,
        const common::Angle &centerLong, const common::Scale &scale,
        const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createPolarStereographicVariantB(
        const util::PropertyMap &properties,
        const common::Angle &latitudeStandardParallel,
        const common::Angle &longitudeOfOrigin,
        const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createRobinson(const util::PropertyMap &properties,
                   const common::Angle &centerLong,
                   const common::Length &falseEasting,
                   const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createSinusoidal(const util::PropertyMap &properties,
                     const common::Angle &centerLong,
                     const common::Length &falseEasting,
                     const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createStereographic(
        const util::PropertyMap &properties, const common::Angle &centerLat,
        const common::Angle &centerLong, const common::Scale &scale,
        const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createVanDerGrinten(const util::PropertyMap &properties,
                        const common::Angle &centerLong,
                        const common::Length &falseEasting,
                        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createWagnerI(const util::PropertyMap &properties,
                  const common::Angle &centerLong,
                  const common::Length &falseEasting,
                  const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createWagnerII(const util::PropertyMap &properties,
                   const common::Angle &centerLong,
                   const common::Length &falseEasting,
                   const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createWagnerIII(const util::PropertyMap &properties,
                    const common::Angle &latitudeTrueScale,
                    const common::Angle &centerLong,
                    const common::Length &falseEasting,
                    const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createWagnerIV(const util::PropertyMap &properties,
                   const common::Angle &centerLong,
                   const common::Length &falseEasting,
                   const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createWagnerV(const util::PropertyMap &properties,
                  const common::Angle &centerLong,
                  const common::Length &falseEasting,
                  const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createWagnerVI(const util::PropertyMap &properties,
                   const common::Angle &centerLong,
                   const common::Length &falseEasting,
                   const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createWagnerVII(const util::PropertyMap &properties,
                    const common::Angle &centerLong,
                    const common::Length &falseEasting,
                    const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createQuadrilateralizedSphericalCube(
        const util::PropertyMap &properties, const common::Angle &centerLat,
        const common::Angle &centerLong, const common::Length &falseEasting,
        const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr createSphericalCrossTrackHeight(
        const util::PropertyMap &properties, const common::Angle &pegPointLat,
        const common::Angle &pegPointLong, const common::Angle &pegPointHeading,
        const common::Length &pegPointHeight);

    PROJ_DLL static ConversionNNPtr
    createEqualEarth(const util::PropertyMap &properties,
                     const common::Angle &centerLong,
                     const common::Length &falseEasting,
                     const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createVerticalPerspective(const util::PropertyMap &properties,
                              const common::Angle &topoOriginLat,
                              const common::Angle &topoOriginLong,
                              const common::Length &topoOriginHeight,
                              const common::Length &viewPointHeight,
                              const common::Length &falseEasting,
                              const common::Length &falseNorthing);

    PROJ_DLL static ConversionNNPtr
    createChangeVerticalUnit(const util::PropertyMap &properties,
                             const common::Scale &factor);

    PROJ_DLL static ConversionNNPtr
    createHeightDepthReversal(const util::PropertyMap &properties);

    PROJ_DLL static ConversionNNPtr createAxisOrderReversal(bool is3D);

    PROJ_DLL static ConversionNNPtr
    createGeographicGeocentric(const util::PropertyMap &properties);

    PROJ_DLL ConversionPtr convertToOtherMethod(int targetEPSGCode) const;

    PROJ_PRIVATE :
        //! @cond Doxygen_Suppress
        PROJ_INTERNAL void
        _exportToPROJString(io::PROJStringFormatter *formatter)
            const override; // throw(FormattingException)

    PROJ_INTERNAL void _exportToJSON(io::JSONFormatter *formatter)
        const override; // throw(FormattingException)

    PROJ_INTERNAL const char *getESRIMethodName() const;

    PROJ_INTERNAL const char *getWKT1GDALMethodName() const;

    PROJ_INTERNAL ConversionNNPtr shallowClone() const;

    PROJ_INTERNAL ConversionNNPtr alterParametersLinearUnit(
        const common::UnitOfMeasure &unit, bool convertToNewUnit) const;

    PROJ_INTERNAL static ConversionNNPtr
    createGeographicGeocentric(const crs::CRSNNPtr &sourceCRS,
                               const crs::CRSNNPtr &targetCRS);

    //! @endcond

  protected:
    PROJ_INTERNAL
    Conversion(const OperationMethodNNPtr &methodIn,
               const std::vector<GeneralParameterValueNNPtr> &values);
    PROJ_INTERNAL Conversion(const Conversion &other);
    INLINED_MAKE_SHARED

    PROJ_FRIEND(crs::ProjectedCRS);
    PROJ_INTERNAL bool addWKTExtensionNode(io::WKTFormatter *formatter) const;

    PROJ_INTERNAL CoordinateOperationNNPtr _shallowClone() const override;

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    Conversion &operator=(const Conversion &other) = delete;

    PROJ_INTERNAL static ConversionNNPtr
    create(const util::PropertyMap &properties, int method_epsg_code,
           const std::vector<ParameterValueNNPtr> &values);

    PROJ_INTERNAL static ConversionNNPtr
    create(const util::PropertyMap &properties, const char *method_wkt2_name,
           const std::vector<ParameterValueNNPtr> &values);
};

// ---------------------------------------------------------------------------

class Transformation;
/** Shared pointer of Transformation */
using TransformationPtr = std::shared_ptr<Transformation>;
/** Non-null shared pointer of Transformation */
using TransformationNNPtr = util::nn<TransformationPtr>;

/** \\brief A mathematical operation on coordinates in which parameters are
 * empirically derived from data containing the coordinates of a series of
 * points in both coordinate reference systems.
 *
 * This computational process is usually ""over-determined"", allowing derivation
 * of error (or accuracy) estimates for the coordinate transformation. Also,
 * the stochastic nature of the parameters may result in multiple (different)
 * versions of the same coordinate transformations between the same source and
 * target CRSs. Any single coordinate operation in which the input and output
 * coordinates are referenced to different datums (reference frames) will be a
 * coordinate transformation.
 *
 * \\remark Implements Transformation from \\ref ISO_19111_2019
 */
class PROJ_GCC_DLL Transformation : public SingleOperation {
  public:
    //! @cond Doxygen_Suppress
    PROJ_DLL ~Transformation() override;
    //! @endcond

    PROJ_DLL const crs::CRSNNPtr &sourceCRS() PROJ_PURE_DECL;
    PROJ_DLL const crs::CRSNNPtr &targetCRS() PROJ_PURE_DECL;

    PROJ_DLL CoordinateOperationNNPtr inverse() const override;

    PROJ_DLL static TransformationNNPtr
    create(const util::PropertyMap &properties,
           const crs::CRSNNPtr &sourceCRSIn, const crs::CRSNNPtr &targetCRSIn,
           const crs::CRSPtr &interpolationCRSIn,
           const OperationMethodNNPtr &methodIn,
           const std::vector<GeneralParameterValueNNPtr> &values,
           const std::vector<metadata::PositionalAccuracyNNPtr>
               &accuracies); // throw InvalidOperation

    PROJ_DLL static TransformationNNPtr
    create(const util::PropertyMap &propertiesTransformation,
           const crs::CRSNNPtr &sourceCRSIn, const crs::CRSNNPtr &targetCRSIn,
           const crs::CRSPtr &interpolationCRSIn,
           const util::PropertyMap &propertiesOperationMethod,
           const std::vector<OperationParameterNNPtr> &parameters,
           const std::vector<ParameterValueNNPtr> &values,
           const std::vector<metadata::PositionalAccuracyNNPtr>
               &accuracies); // throw InvalidOperation

    PROJ_DLL static TransformationNNPtr createGeocentricTranslations(
        const util::PropertyMap &properties, const crs::CRSNNPtr &sourceCRSIn,
        const crs::CRSNNPtr &targetCRSIn, double translationXMetre,
        double translationYMetre, double translationZMetre,
        const std::vector<metadata::PositionalAccuracyNNPtr> &accuracies);

    PROJ_DLL static TransformationNNPtr createPositionVector(
        const util::PropertyMap &properties, const crs::CRSNNPtr &sourceCRSIn,
        const crs::CRSNNPtr &targetCRSIn, double translationXMetre,
        double translationYMetre, double translationZMetre,
        double rotationXArcSecond, double rotationYArcSecond,
        double rotationZArcSecond, double scaleDifferencePPM,
        const std::vector<metadata::PositionalAccuracyNNPtr> &accuracies);

    PROJ_DLL static TransformationNNPtr createCoordinateFrameRotation(
        const util::PropertyMap &properties, const crs::CRSNNPtr &sourceCRSIn,
        const crs::CRSNNPtr &targetCRSIn, double translationXMetre,
        double translationYMetre, double translationZMetre,
        double rotationXArcSecond, double rotationYArcSecond,
        double rotationZArcSecond, double scaleDifferencePPM,
        const std::vector<metadata::PositionalAccuracyNNPtr> &accuracies);

    PROJ_DLL static TransformationNNPtr createTimeDependentPositionVector(
        const util::PropertyMap &properties, const crs::CRSNNPtr &sourceCRSIn,
        const crs::CRSNNPtr &targetCRSIn, double translationXMetre,
        double translationYMetre, double translationZMetre,
        double rotationXArcSecond, double rotationYArcSecond,
        double rotationZArcSecond, double scaleDifferencePPM,
        double rateTranslationX, double rateTranslationY,
        double rateTranslationZ, double rateRotationX, double rateRotationY,
        double rateRotationZ, double rateScaleDifference,
        double referenceEpochYear,
        const std::vector<metadata::PositionalAccuracyNNPtr> &accuracies);

    PROJ_DLL static TransformationNNPtr
    createTimeDependentCoordinateFrameRotation(
        const util::PropertyMap &properties, const crs::CRSNNPtr &sourceCRSIn,
        const crs::CRSNNPtr &targetCRSIn, double translationXMetre,
        double translationYMetre, double translationZMetre,
        double rotationXArcSecond, double rotationYArcSecond,
        double rotationZArcSecond, double scaleDifferencePPM,
        double rateTranslationX, double rateTranslationY,
        double rateTranslationZ, double rateRotationX, double rateRotationY,
        double rateRotationZ, double rateScaleDifference,
        double referenceEpochYear,
        const std::vector<metadata::PositionalAccuracyNNPtr> &accuracies);

    PROJ_DLL static TransformationNNPtr createTOWGS84(
        const crs::CRSNNPtr &sourceCRSIn,
        const std::vector<double> &TOWGS84Parameters); // throw InvalidOperation

    PROJ_DLL static TransformationNNPtr createNTv2(
        const util::PropertyMap &properties, const crs::CRSNNPtr &sourceCRSIn,
        const crs::CRSNNPtr &targetCRSIn, const std::string &filename,
        const std::vector<metadata::PositionalAccuracyNNPtr> &accuracies);

    PROJ_DLL static TransformationNNPtr createMolodensky(
        const util::PropertyMap &properties, const crs::CRSNNPtr &sourceCRSIn,
        const crs::CRSNNPtr &targetCRSIn, double translationXMetre,
        double translationYMetre, double translationZMetre,
        double semiMajorAxisDifferenceMetre, double flattingDifference,
        const std::vector<metadata::PositionalAccuracyNNPtr> &accuracies);

    PROJ_DLL static TransformationNNPtr createAbridgedMolodensky(
        const util::PropertyMap &properties, const crs::CRSNNPtr &sourceCRSIn,
        const crs::CRSNNPtr &targetCRSIn, double translationXMetre,
        double translationYMetre, double translationZMetre,
        double semiMajorAxisDifferenceMetre, double flattingDifference,
        const std::vector<metadata::PositionalAccuracyNNPtr> &accuracies);

    PROJ_DLL static TransformationNNPtr
    createGravityRelatedHeightToGeographic3D(
        const util::PropertyMap &properties, const crs::CRSNNPtr &sourceCRSIn,
        const crs::CRSNNPtr &targetCRSIn, const crs::CRSPtr &interpolationCRSIn,
        const std::string &filename,
        const std::vector<metadata::PositionalAccuracyNNPtr> &accuracies);

    PROJ_DLL static TransformationNNPtr createVERTCON(
        const util::PropertyMap &properties, const crs::CRSNNPtr &sourceCRSIn,
        const crs::CRSNNPtr &targetCRSIn, const std::string &filename,
        const std::vector<metadata::PositionalAccuracyNNPtr> &accuracies);

    PROJ_DLL static TransformationNNPtr createLongitudeRotation(
        const util::PropertyMap &properties, const crs::CRSNNPtr &sourceCRSIn,
        const crs::CRSNNPtr &targetCRSIn, const common::Angle &offset);

    PROJ_DLL static TransformationNNPtr createGeographic2DOffsets(
        const util::PropertyMap &properties, const crs::CRSNNPtr &sourceCRSIn,
        const crs::CRSNNPtr &targetCRSIn, const common::Angle &offsetLat,
        const common::Angle &offsetLon,
        const std::vector<metadata::PositionalAccuracyNNPtr> &accuracies);

    PROJ_DLL static TransformationNNPtr createGeographic3DOffsets(
        const util::PropertyMap &properties, const crs::CRSNNPtr &sourceCRSIn,
        const crs::CRSNNPtr &targetCRSIn, const common::Angle &offsetLat,
        const common::Angle &offsetLon, const common::Length &offsetHeight,
        const std::vector<metadata::PositionalAccuracyNNPtr> &accuracies);

    PROJ_DLL static TransformationNNPtr createGeographic2DWithHeightOffsets(
        const util::PropertyMap &properties, const crs::CRSNNPtr &sourceCRSIn,
        const crs::CRSNNPtr &targetCRSIn, const common::Angle &offsetLat,
        const common::Angle &offsetLon, const common::Length &offsetHeight,
        const std::vector<metadata::PositionalAccuracyNNPtr> &accuracies);

    PROJ_DLL static TransformationNNPtr createVerticalOffset(
        const util::PropertyMap &properties, const crs::CRSNNPtr &sourceCRSIn,
        const crs::CRSNNPtr &targetCRSIn, const common::Length &offsetHeight,
        const std::vector<metadata::PositionalAccuracyNNPtr> &accuracies);

    PROJ_DLL TransformationNNPtr substitutePROJAlternativeGridNames(
        io::DatabaseContextNNPtr databaseContext) const;

    PROJ_DLL static TransformationNNPtr createChangeVerticalUnit(
        const util::PropertyMap &properties, const crs::CRSNNPtr &sourceCRSIn,
        const crs::CRSNNPtr &targetCRSIn, const common::Scale &factor,
        const std::vector<metadata::PositionalAccuracyNNPtr> &accuracies);

    PROJ_PRIVATE :
        //! @cond Doxygen_Suppress
        PROJ_INTERNAL const std::string &
        getNTv2Filename() const;

    PROJ_FOR_TEST std::vector<double>
    getTOWGS84Parameters() const; // throw(io::FormattingException)

    PROJ_INTERNAL const std::string &getHeightToGeographic3DFilename() const;

    PROJ_INTERNAL bool isLongitudeRotation() const;

    PROJ_INTERNAL void _exportToWKT(io::WKTFormatter *formatter)
        const override; // throw(io::FormattingException)

    PROJ_INTERNAL void _exportToJSON(io::JSONFormatter *formatter)
        const override; // throw(FormattingException)

    PROJ_INTERNAL TransformationNNPtr shallowClone() const;

    //! @endcond

  protected:
    PROJ_INTERNAL Transformation(
        const crs::CRSNNPtr &sourceCRSIn, const crs::CRSNNPtr &targetCRSIn,
        const crs::CRSPtr &interpolationCRSIn,
        const OperationMethodNNPtr &methodIn,
        const std::vector<GeneralParameterValueNNPtr> &values,
        const std::vector<metadata::PositionalAccuracyNNPtr> &accuracies);
    PROJ_INTERNAL Transformation(const Transformation &other);
    INLINED_MAKE_SHARED

    PROJ_INTERNAL void _exportToPROJString(io::PROJStringFormatter *formatter)
        const override; // throw(FormattingException)

    PROJ_INTERNAL TransformationNNPtr inverseAsTransformation() const;

    PROJ_INTERNAL CoordinateOperationNNPtr _shallowClone() const override;

  private:
    PROJ_OPAQUE_PRIVATE_DATA
};

// ---------------------------------------------------------------------------

class PointMotionOperation;
/** Shared pointer of PointMotionOperation */
using PointMotionOperationPtr = std::shared_ptr<PointMotionOperation>;
/** Non-null shared pointer of PointMotionOperation */
using PointMotionOperationNNPtr = util::nn<PointMotionOperationPtr>;

/** \\brief A mathematical operation that describes the change of coordinate
 * values within one coordinate reference system due to the motion of the
 * point between one coordinate epoch and another coordinate epoch.
 *
 * The motion is due to tectonic plate movement or deformation.
 *
 * \\remark Implements PointMotionOperation from \\ref ISO_19111_2019
 */
class PROJ_GCC_DLL PointMotionOperation : public SingleOperation {
  public:
    // TODO
    //! @cond Doxygen_Suppress
    PROJ_DLL ~PointMotionOperation() override;
    //! @endcond

  private:
    PointMotionOperation(const PointMotionOperation &) = delete;
};

// ---------------------------------------------------------------------------

class ConcatenatedOperation;
/** Shared pointer of ConcatenatedOperation */
using ConcatenatedOperationPtr = std::shared_ptr<ConcatenatedOperation>;
/** Non-null shared pointer of ConcatenatedOperation */
using ConcatenatedOperationNNPtr = util::nn<ConcatenatedOperationPtr>;

/** \\brief An ordered sequence of two or more single coordinate operations
 * (SingleOperation).
 *
 * The sequence of coordinate operations is constrained by the requirement
 * that
 * the source coordinate reference system of step n+1 shall be the same as
 * the target coordinate reference system of step n.
 *
 * \\remark Implements ConcatenatedOperation from \\ref ISO_19111_2019
 */
class PROJ_GCC_DLL ConcatenatedOperation final : public CoordinateOperation {
  public:
    //! @cond Doxygen_Suppress
    PROJ_DLL ~ConcatenatedOperation() override;
    //! @endcond

    PROJ_DLL const std::vector<CoordinateOperationNNPtr> &operations() const;

    PROJ_DLL CoordinateOperationNNPtr inverse() const override;

    PROJ_DLL static ConcatenatedOperationNNPtr
    create(const util::PropertyMap &properties,
           const std::vector<CoordinateOperationNNPtr> &operationsIn,
           const std::vector<metadata::PositionalAccuracyNNPtr>
               &accuracies); // throw InvalidOperation

    PROJ_DLL static CoordinateOperationNNPtr createComputeMetadata(
        const std::vector<CoordinateOperationNNPtr> &operationsIn,
        bool checkExtent); // throw InvalidOperation

    PROJ_DLL std::set<GridDescription>
    gridsNeeded(const io::DatabaseContextPtr &databaseContext) const override;

    PROJ_PRIVATE :

        //! @cond Doxygen_Suppress
        PROJ_INTERNAL void
        _exportToWKT(io::WKTFormatter *formatter)
            const override; // throw(io::FormattingException)

    PROJ_INTERNAL bool
    _isEquivalentTo(const util::IComparable *other,
                    util::IComparable::Criterion criterion =
                        util::IComparable::Criterion::STRICT) const override;

    PROJ_INTERNAL void _exportToJSON(io::JSONFormatter *formatter)
        const override; // throw(FormattingException)

    PROJ_INTERNAL static void
    fixStepsDirection(const crs::CRSNNPtr &concatOpSourceCRS,
                      const crs::CRSNNPtr &concatOpTargetCRS,
                      std::vector<CoordinateOperationNNPtr> &operationsInOut);
    //! @endcond

  protected:
    PROJ_INTERNAL ConcatenatedOperation(const ConcatenatedOperation &other);
    PROJ_INTERNAL explicit ConcatenatedOperation(
        const std::vector<CoordinateOperationNNPtr> &operationsIn);

    PROJ_INTERNAL void _exportToPROJString(io::PROJStringFormatter *formatter)
        const override; // throw(FormattingException)

    PROJ_INTERNAL CoordinateOperationNNPtr _shallowClone() const override;

    INLINED_MAKE_SHARED

  private:
    PROJ_OPAQUE_PRIVATE_DATA
    ConcatenatedOperation &
    operator=(const ConcatenatedOperation &other) = delete;
};

// ---------------------------------------------------------------------------

class CoordinateOperationContext;
/** Unique pointer of CoordinateOperationContext */
using CoordinateOperationContextPtr =
    std::unique_ptr<CoordinateOperationContext>;
/** Non-null unique pointer of CoordinateOperationContext */
using CoordinateOperationContextNNPtr = util::nn<CoordinateOperationContextPtr>;

/** \\brief Context in which a coordinate operation is to be used.
 *
 * \\remark Implements [CoordinateOperationFactory
 * https://sis.apache.org/apidocs/org/apache/sis/referencing/operation/CoordinateOperationContext.html]
 * from
 * Apache SIS
 */

class PROJ_GCC_DLL CoordinateOperationContext {
  public:
    //! @cond Doxygen_Suppress
    PROJ_DLL virtual ~CoordinateOperationContext();
    //! @endcond

    PROJ_DLL const io::AuthorityFactoryPtr &getAuthorityFactory() const;

    PROJ_DLL const metadata::ExtentPtr &getAreaOfInterest() const;

    PROJ_DLL void setAreaOfInterest(const metadata::ExtentPtr &extent);

    PROJ_DLL double getDesiredAccuracy() const;

    PROJ_DLL void setDesiredAccuracy(double accuracy);

    /** Specify how source and target CRS extent should be used to restrict
     * candidate operations (only taken into account if no explicit area of
     * interest is specified. */
    enum class SourceTargetCRSExtentUse {
        /** Ignore CRS extent */
        NONE,
        /** Test coordinate operation extent against both CRS extent. */
        BOTH,
        /** Test coordinate operation extent against the intersection of both
           CRS extent. */
        INTERSECTION,
        /** Test coordinate operation against the smallest of both CRS extent.
         */
        SMALLEST,
    };

    PROJ_DLL void setSourceAndTargetCRSExtentUse(SourceTargetCRSExtentUse use);

    PROJ_DLL SourceTargetCRSExtentUse getSourceAndTargetCRSExtentUse() const;

    /** Spatial criterion to restrict candidate operations. */
    enum class SpatialCriterion {
        /** The area of validity of transforms should strictly contain the
         * are of interest. */
        STRICT_CONTAINMENT,

        /** The area of validity of transforms should at least intersect the
         * area of interest. */
        PARTIAL_INTERSECTION
    };

    PROJ_DLL void setSpatialCriterion(SpatialCriterion criterion);

    PROJ_DLL SpatialCriterion getSpatialCriterion() const;

    PROJ_DLL void setUsePROJAlternativeGridNames(bool usePROJNames);

    PROJ_DLL bool getUsePROJAlternativeGridNames() const;

    PROJ_DLL void setDiscardSuperseded(bool discard);

    PROJ_DLL bool getDiscardSuperseded() const;

    /** Describe how grid availability is used. */
    enum class GridAvailabilityUse {
        /** Grid availability is only used for sorting results. Operations
         * where some grids are missing will be sorted last. */
        USE_FOR_SORTING,

        /** Completely discard an operation if a required grid is missing. */
        DISCARD_OPERATION_IF_MISSING_GRID,

        /** Ignore grid availability at all. Results will be presented as if
         * all grids were available. */
        IGNORE_GRID_AVAILABILITY,
    };

    PROJ_DLL void setGridAvailabilityUse(GridAvailabilityUse use);

    PROJ_DLL GridAvailabilityUse getGridAvailabilityUse() const;

    /** Describe if and how intermediate CRS should be used */
    enum class IntermediateCRSUse {
        /** Always search for intermediate CRS. */
        ALWAYS,

        /** Only attempt looking for intermediate CRS if there is no direct
         * transformation available. */
        IF_NO_DIRECT_TRANSFORMATION,

        /* Do not attempt looking for intermediate CRS. */
        NEVER,
    };

    PROJ_DLL void setAllowUseIntermediateCRS(IntermediateCRSUse use);

    PROJ_DLL IntermediateCRSUse getAllowUseIntermediateCRS() const;

    PROJ_DLL void
    setIntermediateCRS(const std::vector<std::pair<std::string, std::string>>
                           &intermediateCRSAuthCodes);

    PROJ_DLL const std::vector<std::pair<std::string, std::string>> &
    getIntermediateCRS() const;

    PROJ_DLL static CoordinateOperationContextNNPtr
    create(const io::AuthorityFactoryPtr &authorityFactory,
           const metadata::ExtentPtr &extent, double accuracy);

  protected:
    PROJ_INTERNAL CoordinateOperationContext();
    INLINED_MAKE_UNIQUE

  private:
    PROJ_OPAQUE_PRIVATE_DATA
};

// ---------------------------------------------------------------------------

class CoordinateOperationFactory;
/** Unique pointer of CoordinateOperationFactory */
using CoordinateOperationFactoryPtr =
    std::unique_ptr<CoordinateOperationFactory>;
/** Non-null unique pointer of CoordinateOperationFactory */
using CoordinateOperationFactoryNNPtr = util::nn<CoordinateOperationFactoryPtr>;

/** \\brief Creates coordinate operations. This factory is capable to find
 * coordinate transformations or conversions between two coordinate
 * reference
 * systems.
 *
 * \\remark Implements (partially) CoordinateOperationFactory from \\ref
 * GeoAPI
 */
class PROJ_GCC_DLL CoordinateOperationFactory {
  public:
    //! @cond Doxygen_Suppress
    PROJ_DLL virtual ~CoordinateOperationFactory();
    //! @endcond

    PROJ_DLL CoordinateOperationPtr createOperation(
        const crs::CRSNNPtr &sourceCRS, const crs::CRSNNPtr &targetCRS) const;

    PROJ_DLL std::vector<CoordinateOperationNNPtr>
    createOperations(const crs::CRSNNPtr &sourceCRS,
                     const crs::CRSNNPtr &targetCRS,
                     const CoordinateOperationContextNNPtr &context) const;

    PROJ_DLL static CoordinateOperationFactoryNNPtr create();

  protected:
    PROJ_INTERNAL CoordinateOperationFactory();
    INLINED_MAKE_UNIQUE

  private:
    PROJ_OPAQUE_PRIVATE_DATA
};

} // namespace operation

NS_PROJ_END

#endif //  COORDINATEOPERATION_HH_INCLUDED
",16322,True,3522.0272527666434,median
"[[debezium-mysql-component]]
= Debezium MySQL Connector Component
//THIS FILE IS COPIED: EDIT THE SOURCE FILE:
:page-source: components/camel-debezium-mysql/src/main/docs/debezium-mysql-component.adoc
: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: 'c' for inserts/create; '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 (80 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
| *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: 'c' for inserts/create; '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[]
",12145,True,2991.096278943308,median
"// Copyright 2020-2021 CesiumGS, Inc. and Contributors

#include ""CesiumGltfComponent.h""
#include ""Async/Async.h""
#include ""Cesium3DTiles/Gltf.h""
#include ""CesiumGltf/AccessorView.h""
#include ""Engine/CollisionProfile.h""
#include ""Engine/StaticMesh.h""
#include ""HttpModule.h""
#include ""Interfaces/IHttpResponse.h""
#include ""Materials/Material.h""
#include ""Materials/MaterialInstanceDynamic.h""
#include ""MeshTypes.h""
#include ""PhysicsEngine/BodySetup.h""
#include ""StaticMeshResources.h""
#include ""UObject/ConstructorHelpers.h""
#include <iostream>
#if PHYSICS_INTERFACE_PHYSX
#include ""IPhysXCooking.h""
#else
#include ""Chaos/CollisionConvexMesh.h""
#include ""Chaos/TriangleMeshImplicitObject.h""
#include ""ChaosDerivedDataUtil.h""
#endif
#include ""Cesium3DTiles/RasterOverlayTile.h""
#include ""CesiumGeometry/Axis.h""
#include ""CesiumGeometry/AxisTransforms.h""
#include ""CesiumGeometry/Rectangle.h""
#include ""CesiumGltf/GltfReader.h""
#include ""CesiumGltf/TextureInfo.h""
#include ""CesiumGltfPrimitiveComponent.h""
#include ""CesiumRuntime.h""
#include ""CesiumTransforms.h""
#include ""CesiumUtility/Tracing.h""
#include ""CesiumUtility/joinToString.h""
#include ""PixelFormat.h""
#include ""StaticMeshOperations.h""
#include ""mikktspace.h""
#include <glm/ext/matrix_transform.hpp>
#include <glm/gtc/quaternion.hpp>
#include <glm/mat3x3.hpp>

#define STB_IMAGE_RESIZE_IMPLEMENTATION
#include <cstddef>
#include <stb_image_resize.h>

using namespace CesiumGltf;

static uint32_t nextMaterialId = 0;

struct LoadTextureResult {
  FTexturePlatformData* pTextureData;
  TextureAddress addressX;
  TextureAddress addressY;
  TextureFilter filter;
};

struct LoadModelResult {
  FStaticMeshRenderData* RenderData;
  const CesiumGltf::Model* pModel;
  const CesiumGltf::Material* pMaterial;
  glm::dmat4x4 transform;
#if PHYSICS_INTERFACE_PHYSX
  PxTriangleMesh* pCollisionMesh;
#else
  TSharedPtr<Chaos::FTriangleMeshImplicitObject, ESPMode::ThreadSafe>
      pCollisionMesh;
#endif
  std::string name;

  std::optional<LoadTextureResult> baseColorTexture;
  std::optional<LoadTextureResult> metallicRoughnessTexture;
  std::optional<LoadTextureResult> normalTexture;
  std::optional<LoadTextureResult> emissiveTexture;
  std::optional<LoadTextureResult> occlusionTexture;
  std::optional<LoadTextureResult> waterMaskTexture;
  std::unordered_map<std::string, uint32_t> textureCoordinateParameters;

  bool onlyLand;
  bool onlyWater;

  double waterMaskTranslationX;
  double waterMaskTranslationY;
  double waterMaskScale;
};

static const std::string rasterOverlay0 = ""_CESIUMOVERLAY_0"";
static const std::string rasterOverlay1 = ""_CESIUMOVERLAY_1"";

template <class... T> struct IsAccessorView;

template <class T> struct IsAccessorView<T> : std::false_type {};

template <class T>
struct IsAccessorView<CesiumGltf::AccessorView<T>> : std::true_type {};

template <class T>
static uint32_t updateTextureCoordinates(
    const CesiumGltf::Model& model,
    const CesiumGltf::MeshPrimitive& primitive,
    TArray<FStaticMeshBuildVertex>& vertices,
    const TArray<uint32>& indices,
    const std::optional<T>& texture,
    std::unordered_map<uint32_t, uint32_t>& textureCoordinateMap) {
  if (!texture) {
    return 0;
  }

  return updateTextureCoordinates(
      model,
      primitive,
      vertices,
      indices,
      ""TEXCOORD_"" + std::to_string(texture.value().texCoord),
      textureCoordinateMap);
}

uint32_t updateTextureCoordinates(
    const CesiumGltf::Model& model,
    const CesiumGltf::MeshPrimitive& primitive,
    TArray<FStaticMeshBuildVertex>& vertices,
    const TArray<uint32>& indices,
    const std::string& attributeName,
    std::unordered_map<uint32_t, uint32_t>& textureCoordinateMap) {
  auto uvAccessorIt = primitive.attributes.find(attributeName);
  if (uvAccessorIt == primitive.attributes.end()) {
    // Texture not used, texture coordinates don't matter.
    return 0;
  }

  int uvAccessorID = uvAccessorIt->second;
  auto mapIt = textureCoordinateMap.find(uvAccessorID);
  if (mapIt != textureCoordinateMap.end()) {
    // Texture coordinates for this accessor are already populated.
    return mapIt->second;
  }

  size_t textureCoordinateIndex = textureCoordinateMap.size();
  textureCoordinateMap[uvAccessorID] = textureCoordinateIndex;

  CesiumGltf::AccessorView<FVector2D> uvAccessor(model, uvAccessorID);
  if (uvAccessor.status() != CesiumGltf::AccessorViewStatus::Valid) {
    return 0;
  }

  for (int64_t i = 0; i < indices.Num(); ++i) {
    FStaticMeshBuildVertex& vertex = vertices[i];
    uint32 vertexIndex = indices[i];
    if (vertexIndex >= 0 && vertexIndex < uvAccessor.size()) {
      vertex.UVs[textureCoordinateIndex] = uvAccessor[vertexIndex];
    } else {
      vertex.UVs[textureCoordinateIndex] = FVector2D(0.0f, 0.0f);
    }
  }

  return textureCoordinateIndex;
}

static int mikkGetNumFaces(const SMikkTSpaceContext* Context) {
  TArray<FStaticMeshBuildVertex>& vertices =
      *reinterpret_cast<TArray<FStaticMeshBuildVertex>*>(Context->m_pUserData);
  return vertices.Num() / 3;
}

static int
mikkGetNumVertsOfFace(const SMikkTSpaceContext* Context, const int FaceIdx) {
  TArray<FStaticMeshBuildVertex>& vertices =
      *reinterpret_cast<TArray<FStaticMeshBuildVertex>*>(Context->m_pUserData);
  return FaceIdx < (vertices.Num() / 3) ? 3 : 0;
}

static void mikkGetPosition(
    const SMikkTSpaceContext* Context,
    float Position[3],
    const int FaceIdx,
    const int VertIdx) {
  TArray<FStaticMeshBuildVertex>& vertices =
      *reinterpret_cast<TArray<FStaticMeshBuildVertex>*>(Context->m_pUserData);
  FVector& position = vertices[FaceIdx * 3 + VertIdx].Position;
  Position[0] = position.X;
  Position[1] = position.Y;
  Position[2] = position.Z;
}

static void mikkGetNormal(
    const SMikkTSpaceContext* Context,
    float Normal[3],
    const int FaceIdx,
    const int VertIdx) {
  TArray<FStaticMeshBuildVertex>& vertices =
      *reinterpret_cast<TArray<FStaticMeshBuildVertex>*>(Context->m_pUserData);
  FVector& normal = vertices[FaceIdx * 3 + VertIdx].TangentZ;
  Normal[0] = normal.X;
  Normal[1] = normal.Y;
  Normal[2] = normal.Z;
}

static void mikkGetTexCoord(
    const SMikkTSpaceContext* Context,
    float UV[2],
    const int FaceIdx,
    const int VertIdx) {
  TArray<FStaticMeshBuildVertex>& vertices =
      *reinterpret_cast<TArray<FStaticMeshBuildVertex>*>(Context->m_pUserData);
  FVector2D& uv = vertices[FaceIdx * 3 + VertIdx].UVs[0];
  UV[0] = uv.X;
  UV[1] = uv.Y;
}

static void mikkSetTSpaceBasic(
    const SMikkTSpaceContext* Context,
    const float Tangent[3],
    const float BitangentSign,
    const int FaceIdx,
    const int VertIdx) {
  TArray<FStaticMeshBuildVertex>& vertices =
      *reinterpret_cast<TArray<FStaticMeshBuildVertex>*>(Context->m_pUserData);
  FStaticMeshBuildVertex& vertex = vertices[FaceIdx * 3 + VertIdx];
  vertex.TangentX = FVector(Tangent[0], Tangent[1], Tangent[2]);
  vertex.TangentY =
      BitangentSign * FVector::CrossProduct(vertex.TangentZ, vertex.TangentX);
}

static void computeTangentSpace(TArray<FStaticMeshBuildVertex>& vertices) {
  SMikkTSpaceInterface MikkTInterface{};
  MikkTInterface.m_getNormal = mikkGetNormal;
  MikkTInterface.m_getNumFaces = mikkGetNumFaces;
  MikkTInterface.m_getNumVerticesOfFace = mikkGetNumVertsOfFace;
  MikkTInterface.m_getPosition = mikkGetPosition;
  MikkTInterface.m_getTexCoord = mikkGetTexCoord;
  MikkTInterface.m_setTSpaceBasic = mikkSetTSpaceBasic;
  MikkTInterface.m_setTSpace = nullptr;

  SMikkTSpaceContext MikkTContext{};
  MikkTContext.m_pInterface = &MikkTInterface;
  MikkTContext.m_pUserData = (void*)(&vertices);
  // MikkTContext.m_bIgnoreDegenerates = false;
  genTangSpaceDefault(&MikkTContext);
}

static void computeFlatNormals(
    const TArray<uint32_t>& indices,
    TArray<FStaticMeshBuildVertex>& vertices) {
  // Compute flat normals
  for (int64_t i = 0; i < indices.Num(); i += 3) {
    FStaticMeshBuildVertex& v0 = vertices[i];
    FStaticMeshBuildVertex& v1 = vertices[i + 1];
    FStaticMeshBuildVertex& v2 = vertices[i + 2];

    FVector v01 = v1.Position - v0.Position;
    FVector v02 = v2.Position - v0.Position;
    FVector normal = FVector::CrossProduct(v01, v02);

    v0.TangentX = v1.TangentX = v2.TangentX = FVector(0.0f);
    v0.TangentY = v1.TangentY = v2.TangentY = FVector(0.0f);
    v0.TangentZ = v1.TangentZ = v2.TangentZ = normal.GetSafeNormal();
  }
}

#if !PHYSICS_INTERFACE_PHYSX
static TSharedPtr<Chaos::FTriangleMeshImplicitObject, ESPMode::ThreadSafe>
BuildChaosTriangleMeshes(
    const TArray<FStaticMeshBuildVertex>& vertices,
    const TArray<uint32>& indices);
#endif

static const CesiumGltf::Material defaultMaterial;
static const CesiumGltf::MaterialPBRMetallicRoughness
    defaultPbrMetallicRoughness;

struct ColorVisitor {
  TArray<FStaticMeshBuildVertex>& StaticMeshBuildVertices;
  const TArray<uint32>& indices;

  bool operator()(AccessorView<nullptr_t>&& invalidView) { return false; }

  template <typename TColorView> bool operator()(TColorView&& colorView) {
    if (colorView.status() != CesiumGltf::AccessorViewStatus::Valid) {
      return false;
    }

    bool success = true;
    for (int64_t i = 0; success && i < this->indices.Num(); ++i) {
      FStaticMeshBuildVertex& vertex = this->StaticMeshBuildVertices[i];
      uint32 vertexIndex = this->indices[i];
      if (vertexIndex >= colorView.size()) {
        success = false;
      } else {
        success =
            ColorVisitor::convertColor(colorView[vertexIndex], vertex.Color);
      }
    }

    return success;
  }

  template <typename TElement>
  static bool
  convertColor(const AccessorTypes::VEC3<TElement>& color, FColor& out) {
    out.A = 255;
    return convertElement(color.value[0], out.R) &&
           convertElement(color.value[1], out.G) &&
           convertElement(color.value[2], out.B);
  }

  template <typename TElement>
  static bool
  convertColor(const AccessorTypes::VEC4<TElement>& color, FColor& out) {
    return convertElement(color.value[0], out.R) &&
           convertElement(color.value[1], out.G) &&
           convertElement(color.value[2], out.B) &&
           convertElement(color.value[3], out.A);
  }

  static bool convertElement(float value, uint8_t& out) {
    out = uint8_t(value * 255.0f);
    return true;
  }

  static bool convertElement(uint8_t value, uint8_t& out) {
    out = value;
    return true;
  }

  static bool convertElement(uint16_t value, uint8_t& out) {
    out = uint8_t(value / 256);
    return true;
  }

  template <typename T> static bool convertColor(const T& color, FColor& out) {
    return false;
  }

  template <typename T>
  static bool convertElement(const T& color, uint8_t& out) {
    return false;
  }
};

static FTexturePlatformData*
createTexturePlatformData(int32 sizeX, int32 sizeY, EPixelFormat format) {
  if (sizeX > 0 && sizeY > 0 &&
      (sizeX % GPixelFormats[format].BlockSizeX) == 0 &&
      (sizeY % GPixelFormats[format].BlockSizeY) == 0) {
    FTexturePlatformData* pTexturePlatformData = new FTexturePlatformData();
    pTexturePlatformData->SizeX = sizeX;
    pTexturePlatformData->SizeY = sizeY;
    pTexturePlatformData->PixelFormat = format;

    // Allocate first mipmap.
    int32 NumBlocksX = sizeX / GPixelFormats[format].BlockSizeX;
    int32 NumBlocksY = sizeY / GPixelFormats[format].BlockSizeY;
    FTexture2DMipMap* Mip = new FTexture2DMipMap();
    pTexturePlatformData->Mips.Add(Mip);
    Mip->SizeX = sizeX;
    Mip->SizeY = sizeY;
    Mip->BulkData.Lock(LOCK_READ_WRITE);
    Mip->BulkData.Realloc(
        NumBlocksX * NumBlocksY * GPixelFormats[format].BlockBytes);
    Mip->BulkData.Unlock();

    return pTexturePlatformData;
  } else {
    return nullptr;
  }
}

template <class T>
static std::optional<LoadTextureResult> loadTexture(
    const CesiumGltf::Model& model,
    const std::optional<T>& gltfTexture) {
  if (!gltfTexture || gltfTexture.value().index < 0 ||
      gltfTexture.value().index >= model.textures.size()) {
    if (gltfTexture && gltfTexture.value().index >= 0) {
      UE_LOG(
          LogCesium,
          Warning,
          TEXT(""Texture index must be less than %d, but is %d""),
          model.textures.size(),
          gltfTexture.value().index);
    }
    return std::nullopt;
  }

  const CesiumGltf::Texture& texture =
      model.textures[gltfTexture.value().index];
  if (texture.source < 0 || texture.source >= model.images.size()) {
    UE_LOG(
        LogCesium,
        Warning,
        TEXT(
            ""Texture source index must be non-negative and less than %d, but is %d""),
        model.images.size(),
        texture.source);
    return std::nullopt;
  }

  const CesiumGltf::Image& image = model.images[texture.source];

  // TODO: Use correct bytesPerChannel? Does gltf support unnormalized pixel
  // formats?
  EPixelFormat pixelFormat;
  switch (image.cesium.channels) {
  case 1:
    pixelFormat = PF_R8;
    break;
  case 2:
    pixelFormat = PF_R8G8;
    break;
  case 3:
  case 4:
  default:
    pixelFormat = PF_R8G8B8A8;
  };

  LoadTextureResult result{};
  result.pTextureData = createTexturePlatformData(
      image.cesium.width,
      image.cesium.height,
      pixelFormat);
  if (!result.pTextureData) {
    return std::nullopt;
  }

  const CesiumGltf::Sampler* pSampler =
      CesiumGltf::Model::getSafe(&model.samplers, texture.sampler);
  if (pSampler) {
    switch (pSampler->wrapS) {
    case CesiumGltf::Sampler::WrapS::CLAMP_TO_EDGE:
      result.addressX = TextureAddress::TA_Clamp;
      break;
    case CesiumGltf::Sampler::WrapS::MIRRORED_REPEAT:
      result.addressX = TextureAddress::TA_Mirror;
      break;
    case CesiumGltf::Sampler::WrapS::REPEAT:
      result.addressX = TextureAddress::TA_Wrap;
      break;
    }

    switch (pSampler->wrapT) {
    case CesiumGltf::Sampler::WrapT::CLAMP_TO_EDGE:
      result.addressY = TextureAddress::TA_Clamp;
      break;
    case CesiumGltf::Sampler::WrapT::MIRRORED_REPEAT:
      result.addressY = TextureAddress::TA_Mirror;
      break;
    case CesiumGltf::Sampler::WrapT::REPEAT:
      result.addressY = TextureAddress::TA_Wrap;
      break;
    }

    // Unreal Engine's available filtering modes are only nearest, bilinear, and
    // trilinear, and are not specified separately for minification and
    // magnification. So we get as close as we can.
    if (!pSampler->minFilter && !pSampler->magFilter) {
      result.filter = TextureFilter::TF_Default;
    } else if (
        (!pSampler->minFilter ||
         pSampler->minFilter == CesiumGltf::Sampler::MinFilter::NEAREST) &&
        (!pSampler->magFilter ||
         pSampler->magFilter == CesiumGltf::Sampler::MagFilter::NEAREST)) {
      result.filter = TextureFilter::TF_Nearest;
    } else if (pSampler->minFilter) {
      switch (pSampler->minFilter.value()) {
      case CesiumGltf::Sampler::MinFilter::LINEAR_MIPMAP_LINEAR:
      case CesiumGltf::Sampler::MinFilter::LINEAR_MIPMAP_NEAREST:
      case CesiumGltf::Sampler::MinFilter::NEAREST_MIPMAP_LINEAR:
      case CesiumGltf::Sampler::MinFilter::NEAREST_MIPMAP_NEAREST:
        result.filter = TextureFilter::TF_Trilinear;
        break;
      default:
        result.filter = TextureFilter::TF_Bilinear;
        break;
      }
    } else if (pSampler->magFilter) {
      result.filter =
          pSampler->magFilter.value() == CesiumGltf::Sampler::MagFilter::LINEAR
              ? TextureFilter::TF_Bilinear
              : TextureFilter::TF_Nearest;
    }
  } else {
    // glTF spec: ""When undefined, a sampler with repeat wrapping and auto
    // filtering should be used.""
    result.addressX = TextureAddress::TA_Wrap;
    result.addressY = TextureAddress::TA_Wrap;
    result.filter = TextureFilter::TF_Default;
  }

  void* pTextureData = static_cast<unsigned char*>(
      result.pTextureData->Mips[0].BulkData.Lock(LOCK_READ_WRITE));
  FMemory::Memcpy(
      pTextureData,
      image.cesium.pixelData.data(),
      image.cesium.pixelData.size());

  if (result.filter == TextureFilter::TF_Trilinear) {
    // Generate mip levels.
    // TODO: do this on the GPU?
    int32_t width = image.cesium.width;
    int32_t height = image.cesium.height;
    int32_t channels = image.cesium.channels;

    while (width > 1 || height > 1) {
      FTexture2DMipMap* pLevel = new FTexture2DMipMap();
      result.pTextureData->Mips.Add(pLevel);

      pLevel->SizeX = width >> 1;
      if (pLevel->SizeX < 1)
        pLevel->SizeX = 1;
      pLevel->SizeY = height >> 1;
      if (pLevel->SizeY < 1)
        pLevel->SizeY = 1;

      pLevel->BulkData.Lock(LOCK_READ_WRITE);

      void* pMipData =
          pLevel->BulkData.Realloc(pLevel->SizeX * pLevel->SizeY * channels);

      // TODO: Premultiplied alpha? Cases with more than one byte per channel?
      // Non-normalzied pixel formats?
      if (!stbir_resize_uint8(
              static_cast<const unsigned char*>(pTextureData),
              width,
              height,
              0,
              static_cast<unsigned char*>(pMipData),
              pLevel->SizeX,
              pLevel->SizeY,
              0,
              channels)) {
        // Failed to generate mip level, use bilinear filtering instead.
        result.filter = TextureFilter::TF_Bilinear;
        for (int32_t i = 1; i < result.pTextureData->Mips.Num(); ++i) {
          result.pTextureData->Mips[i].BulkData.Unlock();
        }
        result.pTextureData->Mips.RemoveAt(
            1,
            result.pTextureData->Mips.Num() - 1);
        break;
      }

      width = pLevel->SizeX;
      height = pLevel->SizeY;
      pTextureData = pMipData;
    }
  }

  // Unlock all levels
  for (int32_t i = 0; i < result.pTextureData->Mips.Num(); ++i) {
    result.pTextureData->Mips[i].BulkData.Unlock();
  }

  return result;
}

template <class TIndexAccessor>
static void loadPrimitive(
    std::vector<LoadModelResult>& result,
    const CesiumGltf::Model& model,
    const CesiumGltf::Mesh& mesh,
    const CesiumGltf::MeshPrimitive& primitive,
    const glm::dmat4x4& transform,
    const CreateModelOptions& options,
    const CesiumGltf::Accessor& positionAccessor,
    const CesiumGltf::AccessorView<FVector>& positionView,
    const TIndexAccessor& indicesView) {

  CESIUM_TRACE(""loadPrimitive<T>"");

  if (primitive.mode != CesiumGltf::MeshPrimitive::Mode::TRIANGLES &&
      primitive.mode != CesiumGltf::MeshPrimitive::Mode::TRIANGLE_STRIP) {
    // TODO: add support for primitive types other than triangles.
    UE_LOG(
        LogCesium,
        Warning,
        TEXT(""Primitive mode %d is not supported""),
        primitive.mode);
    return;
  }

  LoadModelResult primitiveResult;

  std::string name = ""glTF"";

  auto urlIt = model.extras.find(""Cesium3DTiles_TileUrl"");
  if (urlIt != model.extras.end()) {
    name = urlIt->second.getStringOrDefault(""glTF"");
  }

  auto meshIt = std::find_if(
      model.meshes.begin(),
      model.meshes.end(),
      [&mesh](const CesiumGltf::Mesh& candidate) {
        return &candidate == &mesh;
      });
  if (meshIt != model.meshes.end()) {
    int64_t meshIndex = meshIt - model.meshes.begin();
    name += "" mesh "" + std::to_string(meshIndex);
  }

  auto primitiveIt = std::find_if(
      mesh.primitives.begin(),
      mesh.primitives.end(),
      [&primitive](const CesiumGltf::MeshPrimitive& candidate) {
        return &candidate == &primitive;
      });
  if (primitiveIt != mesh.primitives.end()) {
    int64_t primitiveIndex = primitiveIt - mesh.primitives.begin();
    name += "" primitive "" + std::to_string(primitiveIndex);
  }

  primitiveResult.name = name;

  if (positionView.status() != CesiumGltf::AccessorViewStatus::Valid) {
    UE_LOG(
        LogCesium,
        Warning,
        TEXT(""%s: Invalid position buffer""),
        UTF8_TO_TCHAR(name.c_str()));
    return;
  }

  if constexpr (IsAccessorView<TIndexAccessor>::value) {
    if (indicesView.status() != CesiumGltf::AccessorViewStatus::Valid) {
      UE_LOG(
          LogCesium,
          Warning,
          TEXT(""%s: Invalid indices buffer""),
          UTF8_TO_TCHAR(name.c_str()));
      return;
    }
  }

  FStaticMeshRenderData* RenderData = new FStaticMeshRenderData();
  RenderData->AllocateLODResources(1);

  FStaticMeshLODResources& LODResources = RenderData->LODResources[0];

  {
    CESIUM_TRACE(""compute AA bounding box"");

    const std::vector<double>& min = positionAccessor.min;
    const std::vector<double>& max = positionAccessor.max;
    glm::dvec3 minPosition{std::numeric_limits<double>::max()};
    glm::dvec3 maxPosition{std::numeric_limits<double>::lowest()};
    if (min.size() != 3 || max.size() != 3) {
      for (int32_t i = 0; i < positionView.size(); ++i) {
        minPosition.x = glm::min<double>(minPosition.x, positionView[i].X);
        minPosition.y = glm::min<double>(minPosition.y, positionView[i].Y);
        minPosition.z = glm::min<double>(minPosition.z, positionView[i].Z);

        maxPosition.x = glm::max<double>(maxPosition.x, positionView[i].X);
        maxPosition.y = glm::max<double>(maxPosition.y, positionView[i].Y);
        maxPosition.z = glm::max<double>(maxPosition.z, positionView[i].Z);
      }
    } else {
      minPosition = glm::dvec3(min[0], min[1], min[2]);
      maxPosition = glm::dvec3(max[0], max[1], max[2]);
    }

    FBox aaBox(
        FVector(minPosition.x, minPosition.y, minPosition.z),
        FVector(maxPosition.x, maxPosition.y, maxPosition.z));

    aaBox.GetCenterAndExtents(
        RenderData->Bounds.Origin,
        RenderData->Bounds.BoxExtent);
    RenderData->Bounds.SphereRadius = 0.0f;
  }

  TArray<uint32> indices;
  if (primitive.mode == CesiumGltf::MeshPrimitive::Mode::TRIANGLES) {
    CESIUM_TRACE(""copy TRIANGLE indices"");
    indices.SetNum(static_cast<TArray<uint32>::SizeType>(indicesView.size()));

    for (int32 i = 0; i < indicesView.size(); ++i) {
      indices[i] = indicesView[i];
    }
  } else {
    // assume TRIANGLE_STRIP because all others are rejected earlier.
    CESIUM_TRACE(""copy TRIANGLE_STRIP indices"");
    for (int32 i = 0; i < indicesView.size() - 2; ++i) {
      if (i % 2) {
        indices.Add(indicesView[i]);
        indices.Add(indicesView[i + 2]);
        indices.Add(indicesView[i + 1]);
      } else {
        indices.Add(indicesView[i]);
        indices.Add(indicesView[i + 1]);
        indices.Add(indicesView[i + 2]);
      }
    }
  }

  TArray<FStaticMeshBuildVertex> StaticMeshBuildVertices;
  StaticMeshBuildVertices.SetNum(indices.Num());

  // The static mesh we construct will _not_ be indexed, even if the incoming
  // glTF is. This allows us to compute flat normals if the glTF doesn't include
  // them already, and it allows us to compute a correct tangent space basis
  // according to the MikkTSpace algorithm when tangents are not included in the
  // glTF.

  {
    CESIUM_TRACE(""copy positions"");
    for (int64_t i = 0; i < indices.Num(); ++i) {
      FStaticMeshBuildVertex& vertex = StaticMeshBuildVertices[i];
      uint32 vertexIndex = indices[i];
      vertex.Position = positionView[vertexIndex];
      vertex.UVs[0] = FVector2D(0.0f, 0.0f);
      vertex.UVs[2] = FVector2D(0.0f, 0.0f);
      RenderData->Bounds.SphereRadius = FMath::Max(
          (vertex.Position - RenderData->Bounds.Origin).Size(),
          RenderData->Bounds.SphereRadius);
    }
  }

  // TangentX: Tangent
  // TangentY: Bi-tangent
  // TangentZ: Normal

  auto normalAccessorIt = primitive.attributes.find(""NORMAL"");
  if (normalAccessorIt != primitive.attributes.end()) {
    int normalAccessorID = normalAccessorIt->second;
    CesiumGltf::AccessorView<FVector> normalAccessor(model, normalAccessorID);
    if (normalAccessor.status() == CesiumGltf::AccessorViewStatus::Valid) {
      CESIUM_TRACE(""copy normals"");
      for (int64_t i = 0; i < indices.Num(); ++i) {
        FStaticMeshBuildVertex& vertex = StaticMeshBuildVertices[i];
        uint32 vertexIndex = indices[i];
        vertex.TangentX = FVector(0.0f, 0.0f, 0.0f);
        vertex.TangentY = FVector(0.0f, 0.0f, 0.0f);
        vertex.TangentZ = normalAccessor[vertexIndex];
      }
    } else {
      CESIUM_TRACE(""compute flat normals"");
      UE_LOG(
          LogCesium,
          Warning,
          TEXT(
              ""%s: Invalid normal buffer. Flat normal will be auto-generated instead""),
          UTF8_TO_TCHAR(name.c_str()));
      computeFlatNormals(indices, StaticMeshBuildVertices);
    }
  } else {
    CESIUM_TRACE(""compute flat normals"");
    computeFlatNormals(indices, StaticMeshBuildVertices);
  }

  int materialID = primitive.material;
  const CesiumGltf::Material& material =
      materialID >= 0 && materialID < model.materials.size()
          ? model.materials[materialID]
          : defaultMaterial;
  const CesiumGltf::MaterialPBRMetallicRoughness& pbrMetallicRoughness =
      material.pbrMetallicRoughness ? material.pbrMetallicRoughness.value()
                                    : defaultPbrMetallicRoughness;

  bool hasNormalMap = material.normalTexture.has_value();
  if (hasNormalMap) {
    const CesiumGltf::Texture* pTexture =
        Model::getSafe(&model.textures, material.normalTexture->index);
    hasNormalMap = pTexture != nullptr &&
                   Model::getSafe(&model.images, pTexture->source) != nullptr;
  }

  bool needsTangents = hasNormalMap || options.alwaysIncludeTangents;

  bool hasTangents = false;

  auto tangentAccessorIt = primitive.attributes.find(""TANGENT"");
  if (tangentAccessorIt != primitive.attributes.end()) {
    int tangentAccessorID = tangentAccessorIt->second;
    CesiumGltf::AccessorView<FVector4> tangentAccessor(
        model,
        tangentAccessorID);

    if (tangentAccessor.status() == CesiumGltf::AccessorViewStatus::Valid) {
      CESIUM_TRACE(""copy tangents"");
      for (int64_t i = 0; i < indices.Num(); ++i) {
        FStaticMeshBuildVertex& vertex = StaticMeshBuildVertices[i];
        uint32 vertexIndex = indices[i];
        const FVector4& tangent = tangentAccessor[vertexIndex];
        vertex.TangentX = tangent;
        vertex.TangentY =
            FVector::CrossProduct(vertex.TangentZ, vertex.TangentX) * tangent.W;
      }

      hasTangents = true;
    } else {
      UE_LOG(
          LogCesium,
          Warning,
          TEXT(""%s: Invalid tangent buffer.""),
          UTF8_TO_TCHAR(name.c_str()));
    }
  }

  // Initialize water mask if needed.
  auto onlyWaterIt = primitive.extras.find(""OnlyWater"");
  auto onlyLandIt = primitive.extras.find(""OnlyLand"");
  if (onlyWaterIt != primitive.extras.end() && onlyWaterIt->second.isBool() &&
      onlyLandIt != primitive.extras.end() && onlyLandIt->second.isBool()) {
    CESIUM_TRACE(""water mask"");
    bool onlyWater = onlyWaterIt->second.getBoolOrDefault(false);
    bool onlyLand = onlyLandIt->second.getBoolOrDefault(true);
    primitiveResult.onlyWater = onlyWater;
    primitiveResult.onlyLand = onlyLand;
    if (!onlyWater && !onlyLand) {
      // We have to use the water mask
      auto waterMaskTextureIdIt = primitive.extras.find(""WaterMaskTex"");
      if (waterMaskTextureIdIt != primitive.extras.end() &&
          waterMaskTextureIdIt->second.isInt64()) {
        int32_t waterMaskTextureId = static_cast<int32_t>(
            waterMaskTextureIdIt->second.getInt64OrDefault(-1));
        CesiumGltf::TextureInfo waterMaskInfo;
        waterMaskInfo.index = waterMaskTextureId;
        if (waterMaskTextureId >= 0 &&
            waterMaskTextureId < model.textures.size()) {
          primitiveResult.waterMaskTexture =
              loadTexture(model, std::make_optional(waterMaskInfo));
        }
      }
    }
  } else {
    primitiveResult.onlyWater = false;
    primitiveResult.onlyLand = true;
  }

  // The water effect works by animating the normal, and the normal is
  // expressed in tangent space. So if we have water, we need tangents.
  if (primitiveResult.onlyWater || primitiveResult.waterMaskTexture) {
    needsTangents = true;
  }

  if (needsTangents && !hasTangents) {
    // Use mikktspace to calculate the tangents
    CESIUM_TRACE(""compute tangents"");
    computeTangentSpace(StaticMeshBuildVertices);
  }

  bool hasVertexColors = false;

  auto colorAccessorIt = primitive.attributes.find(""COLOR_0"");
  if (colorAccessorIt != primitive.attributes.end()) {
    CESIUM_TRACE(""copy colors"");
    int colorAccessorID = colorAccessorIt->second;
    hasVertexColors = CesiumGltf::createAccessorView(
        model,
        colorAccessorID,
        ColorVisitor{StaticMeshBuildVertices, indices});
  }

  LODResources.bHasColorVertexData = hasVertexColors;

  // We need to copy the texture coordinates associated with each texture (if
  // any) into the the appropriate UVs slot in FStaticMeshBuildVertex.

  std::unordered_map<uint32_t, uint32_t> textureCoordinateMap;

  {
    CESIUM_TRACE(""loadTextures"");
    primitiveResult.baseColorTexture =
        loadTexture(model, pbrMetallicRoughness.baseColorTexture);
    primitiveResult.metallicRoughnessTexture =
        loadTexture(model, pbrMetallicRoughness.metallicRoughnessTexture);
    primitiveResult.normalTexture = loadTexture(model, material.normalTexture);
    primitiveResult.occlusionTexture =
        loadTexture(model, material.occlusionTexture);
    primitiveResult.emissiveTexture =
        loadTexture(model, material.emissiveTexture);
  }

  {
    CESIUM_TRACE(""updateTextureCoordinates"");
    primitiveResult
        .textureCoordinateParameters[""baseColorTextureCoordinateIndex""] =
        updateTextureCoordinates(
            model,
            primitive,
            StaticMeshBuildVertices,
            indices,
            pbrMetallicRoughness.baseColorTexture,
            textureCoordinateMap);
    primitiveResult.textureCoordinateParameters
        [""metallicRoughnessTextureCoordinateIndex""] = updateTextureCoordinates(
        model,
        primitive,
        StaticMeshBuildVertices,
        indices,
        pbrMetallicRoughness.metallicRoughnessTexture,
        textureCoordinateMap);
    primitiveResult
        .textureCoordinateParameters[""normalTextureCoordinateIndex""] =
        updateTextureCoordinates(
            model,
            primitive,
            StaticMeshBuildVertices,
            indices,
            material.normalTexture,
            textureCoordinateMap);
    primitiveResult
        .textureCoordinateParameters[""occlusionTextureCoordinateIndex""] =
        updateTextureCoordinates(
            model,
            primitive,
            StaticMeshBuildVertices,
            indices,
            material.occlusionTexture,
            textureCoordinateMap);
    primitiveResult
        .textureCoordinateParameters[""emissiveTextureCoordinateIndex""] =
        updateTextureCoordinates(
            model,
            primitive,
            StaticMeshBuildVertices,
            indices,
            material.emissiveTexture,
            textureCoordinateMap);

    // Currently only one set of raster overlay texture coordinates is
    // supported.
    // TODO: Support more texture coordinate sets (e.g. web mercator and
    // geographic)
    primitiveResult
        .textureCoordinateParameters[""webMercatorTextureCoordinateIndex""] =
        updateTextureCoordinates(
            model,
            primitive,
            StaticMeshBuildVertices,
            indices,
            rasterOverlay0,
            textureCoordinateMap);

    primitiveResult
        .textureCoordinateParameters[""geographicTextureCoordinateIndex""] =
        updateTextureCoordinates(
            model,
            primitive,
            StaticMeshBuildVertices,
            indices,
            rasterOverlay1,
            textureCoordinateMap);
  }

  auto waterMaskTranslationXIt = primitive.extras.find(""WaterMaskTranslationX"");
  auto waterMaskTranslationYIt = primitive.extras.find(""WaterMaskTranslationY"");
  auto waterMaskScaleIt = primitive.extras.find(""WaterMaskScale"");

  if (waterMaskTranslationXIt != primitive.extras.end() &&
      waterMaskTranslationXIt->second.isDouble() &&
      waterMaskTranslationYIt != primitive.extras.end() &&
      waterMaskTranslationYIt->second.isDouble() &&
      waterMaskScaleIt != primitive.extras.end() &&
      waterMaskScaleIt->second.isDouble()) {
    primitiveResult.waterMaskTranslationX =
        waterMaskTranslationXIt->second.getDoubleOrDefault(0.0);
    primitiveResult.waterMaskTranslationY =
        waterMaskTranslationYIt->second.getDoubleOrDefault(0.0);
    primitiveResult.waterMaskScale =
        waterMaskScaleIt->second.getDoubleOrDefault(1.0);
  }

  {
    CESIUM_TRACE(""init buffers"");
    LODResources.VertexBuffers.PositionVertexBuffer.Init(
        StaticMeshBuildVertices);

    FColorVertexBuffer& ColorVertexBuffer =
        LODResources.VertexBuffers.ColorVertexBuffer;
    if (hasVertexColors) {
      ColorVertexBuffer.Init(StaticMeshBuildVertices);
    }

    LODResources.VertexBuffers.StaticMeshVertexBuffer.Init(
        StaticMeshBuildVertices,
        textureCoordinateMap.size() == 0 ? 1 : textureCoordinateMap.size());
  }

  FStaticMeshLODResources::FStaticMeshSectionArray& Sections =
      LODResources.Sections;
  FStaticMeshSection& section = Sections.AddDefaulted_GetRef();
  section.bEnableCollision = true;

  section.NumTriangles = StaticMeshBuildVertices.Num() / 3;
  section.FirstIndex = 0;
  section.MinVertexIndex = 0;
  section.MaxVertexIndex = StaticMeshBuildVertices.Num() - 1;
  section.bEnableCollision = true;
  section.bCastShadow = true;

  // Note that we're reversing the order of the indices, because the change
  // from the glTF right-handed to the Unreal left-handed coordinate system
  // reverses the winding order.
  {
    CESIUM_TRACE(""reverse winding order"");
    for (int32 i = 0; i < indices.Num(); ++i) {
      indices[i] = indices.Num() - i - 1;
    }
  }

  {
    CESIUM_TRACE(""SetIndices"");
    LODResources.IndexBuffer.SetIndices(
        indices,
        indices.Num() > std::numeric_limits<uint16>::max()
            ? EIndexBufferStride::Type::Force32Bit
            : EIndexBufferStride::Type::Force16Bit);
  }

  LODResources.bHasDepthOnlyIndices = false;
  LODResources.bHasReversedIndices = false;
  LODResources.bHasReversedDepthOnlyIndices = false;
  LODResources.bHasAdjacencyInfo = false;

  primitiveResult.pModel = &model;
  primitiveResult.RenderData = RenderData;
  primitiveResult.transform = transform;
  primitiveResult.pMaterial = &material;

  section.MaterialIndex = 0;

  primitiveResult.pCollisionMesh = nullptr;

#if PHYSICS_INTERFACE_PHYSX
  if (options.pPhysXCooking) {
    CESIUM_TRACE(""PhysX cook"");
    // TODO: use PhysX interface directly so we don't need to copy the
    // vertices (it takes a stride parameter).
    TArray<FVector> vertices;
    vertices.SetNum(StaticMeshBuildVertices.Num());

    for (size_t i = 0; i < StaticMeshBuildVertices.Num(); ++i) {
      vertices[i] = StaticMeshBuildVertices[i].Position;
    }

    TArray<FTriIndices> physicsIndices;
    physicsIndices.SetNum(StaticMeshBuildVertices.Num() / 3);

    // Reversing triangle winding order here, too.
    for (size_t i = 0; i < StaticMeshBuildVertices.Num() / 3; ++i) {
      physicsIndices[i].v0 = i * 3 + 2;
      physicsIndices[i].v1 = i * 3 + 1;
      physicsIndices[i].v2 = i * 3;
    }

    options.pPhysXCooking->CreateTriMesh(
        ""PhysXGeneric"",
        EPhysXMeshCookFlags::Default,
        vertices,
        physicsIndices,
        TArray<uint16>(),
        true,
        primitiveResult.pCollisionMesh);
  }
#else
  if (StaticMeshBuildVertices.Num() != 0 && indices.Num() != 0) {
    CESIUM_TRACE(""Chaos cook"");
    primitiveResult.pCollisionMesh =
        BuildChaosTriangleMeshes(StaticMeshBuildVertices, indices);
  }
#endif

  result.push_back(std::move(primitiveResult));
}

static void loadIndexedPrimitive(
    std::vector<LoadModelResult>& result,
    const CesiumGltf::Model& model,
    const CesiumGltf::Mesh& mesh,
    const CesiumGltf::MeshPrimitive& primitive,
    const glm::dmat4x4& transform,
    const CreateModelOptions& options,
    const CesiumGltf::Accessor& positionAccessor,
    const CesiumGltf::AccessorView<FVector>& positionView) {
  const CesiumGltf::Accessor& indexAccessorGltf =
      model.accessors[primitive.indices];
  if (indexAccessorGltf.componentType ==
      CesiumGltf::Accessor::ComponentType::BYTE) {
    CesiumGltf::AccessorView<int8_t> indexAccessor(model, primitive.indices);
    loadPrimitive(
        result,
        model,
        mesh,
        primitive,
        transform,
        options,
        positionAccessor,
        positionView,
        indexAccessor);
  } else if (
      indexAccessorGltf.componentType ==
      CesiumGltf::Accessor::ComponentType::UNSIGNED_BYTE) {
    CesiumGltf::AccessorView<uint8_t> indexAccessor(model, primitive.indices);
    loadPrimitive(
        result,
        model,
        mesh,
        primitive,
        transform,
        options,
        positionAccessor,
        positionView,
        indexAccessor);
  } else if (
      indexAccessorGltf.componentType ==
      CesiumGltf::Accessor::ComponentType::SHORT) {
    CesiumGltf::AccessorView<int16_t> indexAccessor(model, primitive.indices);
    loadPrimitive(
        result,
        model,
        mesh,
        primitive,
        transform,
        options,
        positionAccessor,
        positionView,
        indexAccessor);
  } else if (
      indexAccessorGltf.componentType ==
      CesiumGltf::Accessor::ComponentType::UNSIGNED_SHORT) {
    CesiumGltf::AccessorView<uint16_t> indexAccessor(model, primitive.indices);
    loadPrimitive(
        result,
        model,
        mesh,
        primitive,
        transform,
        options,
        positionAccessor,
        positionView,
        indexAccessor);
  } else if (
      indexAccessorGltf.componentType ==
      CesiumGltf::Accessor::ComponentType::UNSIGNED_INT) {
    CesiumGltf::AccessorView<uint32_t> indexAccessor(model, primitive.indices);
    loadPrimitive(
        result,
        model,
        mesh,
        primitive,
        transform,
        options,
        positionAccessor,
        positionView,
        indexAccessor);
  }
}

static void loadPrimitive(
    std::vector<LoadModelResult>& result,
    const CesiumGltf::Model& model,
    const CesiumGltf::Mesh& mesh,
    const CesiumGltf::MeshPrimitive& primitive,
    const glm::dmat4x4& transform,
    const CreateModelOptions& options) {
  CESIUM_TRACE(""loadPrimitive"");

  auto positionAccessorIt = primitive.attributes.find(""POSITION"");
  if (positionAccessorIt == primitive.attributes.end()) {
    // This primitive doesn't have a POSITION semantic, ignore it.
    return;
  }

  int positionAccessorID = positionAccessorIt->second;
  const CesiumGltf::Accessor* pPositionAccessor =
      CesiumGltf::Model::getSafe(&model.accessors, positionAccessorID);
  if (!pPositionAccessor) {
    // Position accessor does not exist, so ignore this primitive.
    return;
  }

  CesiumGltf::AccessorView<FVector> positionView(model, *pPositionAccessor);

  if (primitive.indices < 0 || primitive.indices >= model.accessors.size()) {
    std::vector<uint32_t> syntheticIndexBuffer(positionView.size());
    syntheticIndexBuffer.resize(positionView.size());
    for (uint32_t i = 0; i < positionView.size(); ++i) {
      syntheticIndexBuffer[i] = i;
    }
    loadPrimitive(
        result,
        model,
        mesh,
        primitive,
        transform,
        options,
        *pPositionAccessor,
        positionView,
        syntheticIndexBuffer);
  } else {
    loadIndexedPrimitive(
        result,
        model,
        mesh,
        primitive,
        transform,
        options,
        *pPositionAccessor,
        positionView);
  }
}

static void loadMesh(
    std::vector<LoadModelResult>& result,
    const CesiumGltf::Model& model,
    const CesiumGltf::Mesh& mesh,
    const glm::dmat4x4& transform,
    const CreateModelOptions& options) {

  CESIUM_TRACE(""loadMesh"");

  for (const CesiumGltf::MeshPrimitive& primitive : mesh.primitives) {
    loadPrimitive(result, model, mesh, primitive, transform, options);
  }
}

static void loadNode(
    std::vector<LoadModelResult>& result,
    const CesiumGltf::Model& model,
    const CesiumGltf::Node& node,
    const glm::dmat4x4& transform,
    const CreateModelOptions& options) {
  static constexpr std::array<double, 16> identityMatrix = {
      1.0,
      0.0,
      0.0,
      0.0,
      0.0,
      1.0,
      0.0,
      0.0,
      0.0,
      0.0,
      1.0,
      0.0,
      0.0,
      0.0,
      0.0,
      1.0};

  CESIUM_TRACE(""loadNode"");

  glm::dmat4x4 nodeTransform = transform;

  const std::vector<double>& matrix = node.matrix;
  bool isIdentityMatrix = false;
  if (matrix.size() == 16) {
    isIdentityMatrix =
        std::equal(matrix.begin(), matrix.end(), identityMatrix.begin());
  }

  if (matrix.size() == 16 && !isIdentityMatrix) {
    glm::dmat4x4 nodeTransformGltf(
        glm::dvec4(matrix[0], matrix[1], matrix[2], matrix[3]),
        glm::dvec4(matrix[4], matrix[5], matrix[6], matrix[7]),
        glm::dvec4(matrix[8], matrix[9], matrix[10], matrix[11]),
        glm::dvec4(matrix[12], matrix[13], matrix[14], matrix[15]));

    nodeTransform = nodeTransform * nodeTransformGltf;
  } else {
    glm::dmat4 translation(1.0);
    if (node.translation.size() == 3) {
      translation[3] = glm::dvec4(
          node.translation[0],
          node.translation[1],
          node.translation[2],
          1.0);
    }

    glm::dquat rotationQuat(1.0, 0.0, 0.0, 0.0);
    if (node.rotation.size() == 4) {
      rotationQuat[0] = node.rotation[0];
      rotationQuat[1] = node.rotation[1];
      rotationQuat[2] = node.rotation[2];
      rotationQuat[3] = node.rotation[3];
    }

    glm::dmat4 scale(1.0);
    if (node.scale.size() == 3) {
      scale[0].x = node.scale[0];
      scale[1].y = node.scale[1];
      scale[2].z = node.scale[2];
    }

    nodeTransform =
        nodeTransform * translation * glm::dmat4(rotationQuat) * scale;
  }

  int meshId = node.mesh;
  if (meshId >= 0 && meshId < model.meshes.size()) {
    const CesiumGltf::Mesh& mesh = model.meshes[meshId];
    loadMesh(result, model, mesh, nodeTransform, options);
  }

  for (int childNodeId : node.children) {
    if (childNodeId >= 0 && childNodeId < model.nodes.size()) {
      loadNode(result, model, model.nodes[childNodeId], nodeTransform, options);
    }
  }
}

namespace {
/**
 * @brief Apply the transform for the `RTC_CENTER`
 *
 * If the B3DM that contained the given model had an `RTC_CENTER` in its
 * Feature Table, then it was stored in the `extras` property of the glTF
 * model, as a 3-element array under the name `RTC_CENTER`.
 *
 * This function will multiply the given matrix with the (translation) matrix
 * that was created from this `RTC_CENTER` property in the `extras` of the
 * given model. If the given model does not have this property, then nothing
 * will be done.
 *
 * @param model The glTF model
 * @param rootTransform The matrix that will be multiplied with the transform
 */
void applyRtcCenter(
    const CesiumGltf::Model& model,
    glm::dmat4x4& rootTransform) {
  auto rtcCenterIt = model.extras.find(""RTC_CENTER"");
  if (rtcCenterIt == model.extras.end()) {
    return;
  }
  const CesiumUtility::JsonValue& rtcCenter = rtcCenterIt->second;
  const std::vector<CesiumUtility::JsonValue>* pArray =
      std::get_if<CesiumUtility::JsonValue::Array>(&rtcCenter.value);
  if (!pArray) {
    return;
  }
  if (pArray->size() != 3) {
    UE_LOG(
        LogCesium,
        Warning,
        TEXT(""The RTC_CENTER must have a size of 3, but has {}""),
        pArray->size());
    return;
  }
  const double x = (*pArray)[0].getSafeNumberOrDefault(0.0);
  const double y = (*pArray)[1].getSafeNumberOrDefault(0.0);
  const double z = (*pArray)[2].getSafeNumberOrDefault(0.0);
  const glm::dmat4x4 rtcTransform(
      glm::dvec4(1.0, 0.0, 0.0, 0.0),
      glm::dvec4(0.0, 1.0, 0.0, 0.0),
      glm::dvec4(0.0, 0.0, 1.0, 0.0),
      glm::dvec4(x, y, z, 1.0));
  rootTransform *= rtcTransform;
}

/**
 * @brief Apply the transform so that the up-axis of the given model is the
 * Z-axis.
 *
 * By default, the up-axis of a glTF model will the the Y-axis.
 *
 * If the tileset that contained the model had the `asset.gltfUpAxis` string
 * property, then the information about the up-axis has been stored in as a
 * number property called `gltfUpAxis` in the `extras` of the given model.
 *
 * Depending on whether this value is CesiumGeometry::Axis::X, Y, or Z,
 * the given matrix will be multiplied with a matrix that converts the
 * respective axis to be the Z-axis, as required by the 3D Tiles standard.
 *
 * @param model The glTF model
 * @param rootTransform The matrix that will be multiplied with the transform
 */
void applyGltfUpAxisTransform(
    const CesiumGltf::Model& model,
    glm::dmat4x4& rootTransform) {

  auto gltfUpAxisIt = model.extras.find(""gltfUpAxis"");
  if (gltfUpAxisIt == model.extras.end()) {
    // The default up-axis of glTF is the Y-axis, and no other
    // up-axis was specified. Transform the Y-axis to the Z-axis,
    // to match the 3D Tiles specification
    rootTransform *= CesiumGeometry::AxisTransforms::Y_UP_TO_Z_UP;
    return;
  }
  const CesiumUtility::JsonValue& gltfUpAxis = gltfUpAxisIt->second;
  int gltfUpAxisValue = static_cast<int>(gltfUpAxis.getSafeNumberOrDefault(1));
  if (gltfUpAxisValue == static_cast<int>(CesiumGeometry::Axis::X)) {
    rootTransform *= CesiumGeometry::AxisTransforms::X_UP_TO_Z_UP;
  } else if (gltfUpAxisValue == static_cast<int>(CesiumGeometry::Axis::Y)) {
    rootTransform *= CesiumGeometry::AxisTransforms::Y_UP_TO_Z_UP;
  } else if (gltfUpAxisValue == static_cast<int>(CesiumGeometry::Axis::Z)) {
    // No transform required
  } else {
    UE_LOG(
        LogCesium,
        VeryVerbose,
        TEXT(""Unknown gltfUpAxis value: {}""),
        gltfUpAxisValue);
  }
}

} // namespace

static std::vector<LoadModelResult> loadModelAnyThreadPart(
    const CesiumGltf::Model& model,
    const glm::dmat4x4& transform,
    const CreateModelOptions& options) {
  CESIUM_TRACE(""loadModelAnyThreadPart"");

  std::vector<LoadModelResult> result;

  glm::dmat4x4 rootTransform = transform;

  {
    CESIUM_TRACE(""Apply transforms"");
    applyRtcCenter(model, rootTransform);
    applyGltfUpAxisTransform(model, rootTransform);
  }

  if (model.scene >= 0 && model.scene < model.scenes.size()) {
    // Show the default scene
    const CesiumGltf::Scene& defaultScene = model.scenes[model.scene];
    for (int nodeId : defaultScene.nodes) {
      loadNode(result, model, model.nodes[nodeId], rootTransform, options);
    }
  } else if (model.scenes.size() > 0) {
    // There's no default, so show the first scene
    const CesiumGltf::Scene& defaultScene = model.scenes[0];
    for (int nodeId : defaultScene.nodes) {
      loadNode(result, model, model.nodes[nodeId], rootTransform, options);
    }
  } else if (model.nodes.size() > 0) {
    // No scenes at all, use the first node as the root node.
    loadNode(result, model, model.nodes[0], rootTransform, options);
  } else if (model.meshes.size() > 0) {
    // No nodes either, show all the meshes.
    for (const CesiumGltf::Mesh& mesh : model.meshes) {
      loadMesh(result, model, mesh, rootTransform, options);
    }
  }

  return result;
}

bool applyTexture(
    UMaterialInstanceDynamic* pMaterial,
    FName parameterName,
    const std::optional<LoadTextureResult>& loadedTexture) {
  if (!loadedTexture) {
    return false;
  }

  UTexture2D* pTexture =
      NewObject<UTexture2D>(GetTransientPackage(), NAME_None, RF_Transient);

  pTexture->PlatformData = loadedTexture->pTextureData;
  pTexture->AddressX = loadedTexture->addressX;
  pTexture->AddressY = loadedTexture->addressY;
  pTexture->Filter = loadedTexture->filter;
  pTexture->UpdateResource();
  pMaterial->SetTextureParameterValue(parameterName, pTexture);
  return true;
}

static void loadModelGameThreadPart(
    UCesiumGltfComponent* pGltf,
    LoadModelResult& loadResult,
    const glm::dmat4x4& cesiumToUnrealTransform) {
  UCesiumGltfPrimitiveComponent* pMesh =
      NewObject<UCesiumGltfPrimitiveComponent>(
          pGltf,
          FName(loadResult.name.c_str()));
  pMesh->HighPrecisionNodeTransform = loadResult.transform;
  pMesh->UpdateTransformFromCesium(cesiumToUnrealTransform);

  pMesh->bUseDefaultCollision = false;
  pMesh->SetCollisionObjectType(ECollisionChannel::ECC_WorldStatic);
  pMesh->SetFlags(RF_Transient);

  UStaticMesh* pStaticMesh =
      NewObject<UStaticMesh>(pMesh, FName(loadResult.name.c_str()));
  pMesh->SetStaticMesh(pStaticMesh);

  pStaticMesh->bIsBuiltAtRuntime = true;
  pStaticMesh->NeverStream = true;
  pStaticMesh->RenderData =
      TUniquePtr<FStaticMeshRenderData>(loadResult.RenderData);

  const CesiumGltf::Model& model = *loadResult.pModel;
  const CesiumGltf::Material& material =
      loadResult.pMaterial ? *loadResult.pMaterial : defaultMaterial;

  const CesiumGltf::MaterialPBRMetallicRoughness& pbr =
      material.pbrMetallicRoughness ? material.pbrMetallicRoughness.value()
                                    : defaultPbrMetallicRoughness;

  const FName ImportedSlotName(
      *(TEXT(""CesiumMaterial"") + FString::FromInt(nextMaterialId++)));
  UMaterialInstanceDynamic* pMaterial;

  switch (material.alphaMode) {
  case CesiumGltf::Material::AlphaMode::BLEND:
    // TODO
    pMaterial = UMaterialInstanceDynamic::Create(
        pGltf->OpacityMaskMaterial,
        nullptr,
        ImportedSlotName);
    break;
  case CesiumGltf::Material::AlphaMode::MASK:
    pMaterial = UMaterialInstanceDynamic::Create(
        pGltf->OpacityMaskMaterial,
        nullptr,
        ImportedSlotName);
    break;
  case CesiumGltf::Material::AlphaMode::OPAQUE:
  default:
    pMaterial = UMaterialInstanceDynamic::Create(
// TODO: figure out why water material crashes mac
#if PLATFORM_MAC
        pGltf->BaseMaterial,
#else
        (loadResult.onlyWater || !loadResult.onlyLand)
            ? pGltf->BaseMaterialWithWater
            : pGltf->BaseMaterial,
#endif
        nullptr,
        ImportedSlotName);
    break;
  }

  pMaterial->OpacityMaskClipValue = material.alphaCutoff;

  for (auto& textureCoordinateSet : loadResult.textureCoordinateParameters) {
    pMaterial->SetScalarParameterValue(
        textureCoordinateSet.first.c_str(),
        textureCoordinateSet.second);
  }

  if (pbr.baseColorFactor.size() >= 3) {
    pMaterial->SetVectorParameterValue(
        ""baseColorFactor"",
        FVector(
            pbr.baseColorFactor[0],
            pbr.baseColorFactor[1],
            pbr.baseColorFactor[2]));
  }
  pMaterial->SetScalarParameterValue(""metallicFactor"", pbr.metallicFactor);
  pMaterial->SetScalarParameterValue(""roughnessFactor"", pbr.roughnessFactor);
  pMaterial->SetScalarParameterValue(""opacityMask"", 1.0);

  applyTexture(pMaterial, ""baseColorTexture"", loadResult.baseColorTexture);
  applyTexture(
      pMaterial,
      ""metallicRoughnessTexture"",
      loadResult.metallicRoughnessTexture);
  applyTexture(pMaterial, ""normalTexture"", loadResult.normalTexture);
  bool hasEmissiveTexture =
      applyTexture(pMaterial, ""emissiveTexture"", loadResult.emissiveTexture);
  applyTexture(pMaterial, ""occlusionTexture"", loadResult.occlusionTexture);

  if (material.emissiveFactor.size() >= 3) {
    pMaterial->SetVectorParameterValue(
        ""emissiveFactor"",
        FVector(
            material.emissiveFactor[0],
            material.emissiveFactor[1],
            material.emissiveFactor[2]));
  } else if (hasEmissiveTexture) {
    // When we have an emissive texture but not a factor, we need to use a
    // factor of vec3(1.0). The default, vec3(0.0), would disable the emission
    // from the texture.
    pMaterial->SetVectorParameterValue(
        ""emissiveFactor"",
        FVector(1.0f, 1.0f, 1.0f));
  }

  pMaterial->SetScalarParameterValue(
      ""OnlyLand"",
      static_cast<float>(loadResult.onlyLand));
  pMaterial->SetScalarParameterValue(
      ""OnlyWater"",
      static_cast<float>(loadResult.onlyWater));

  if (!loadResult.onlyLand && !loadResult.onlyWater) {
    applyTexture(pMaterial, ""WaterMask"", loadResult.waterMaskTexture);
  }

  pMaterial->SetVectorParameterValue(
      ""WaterMaskTranslationScale"",
      FLinearColor(
          loadResult.waterMaskTranslationX,
          loadResult.waterMaskTranslationY,
          loadResult.waterMaskScale));

  pMaterial->TwoSided = true;

  pStaticMesh->AddMaterial(pMaterial);

  pStaticMesh->InitResources();

  // Set up RenderData bounds and LOD data
  pStaticMesh->CalculateExtendedBounds();

  pStaticMesh->RenderData->ScreenSize[0].Default = 1.0f;
  pStaticMesh->CreateBodySetup();

  // pMesh->UpdateCollisionFromStaticMesh();
  pMesh->GetBodySetup()->CollisionTraceFlag =
      ECollisionTraceFlag::CTF_UseComplexAsSimple;

  if (loadResult.pCollisionMesh) {
#if PHYSICS_INTERFACE_PHYSX
    pMesh->GetBodySetup()->TriMeshes.Add(loadResult.pCollisionMesh);
#else
    pMesh->GetBodySetup()->ChaosTriMeshes.Add(loadResult.pCollisionMesh);
#endif
  }

  // Mark physics meshes created, no matter if we actually have a collision mesh
  // or not. We don't want the editor creating collision meshes itself in the
  // game thread, because that would be slow.
  pMesh->GetBodySetup()->bCreatedPhysicsMeshes = true;

  pMesh->SetMobility(EComponentMobility::Movable);

  // pMesh->bDrawMeshCollisionIfComplex = true;
  // pMesh->bDrawMeshCollisionIfSimple = true;
  pMesh->SetupAttachment(pGltf);
  pMesh->RegisterComponent();
}

namespace {
class HalfConstructedReal : public UCesiumGltfComponent::HalfConstructed {
public:
  virtual ~HalfConstructedReal() {}
  std::vector<LoadModelResult> loadModelResult;
};
} // namespace

/*static*/ std::unique_ptr<UCesiumGltfComponent::HalfConstructed>
UCesiumGltfComponent::CreateOffGameThread(
    const CesiumGltf::Model& Model,
    const glm::dmat4x4& Transform,
    const CreateModelOptions& Options) {
  auto pResult = std::make_unique<HalfConstructedReal>();
  pResult->loadModelResult = loadModelAnyThreadPart(Model, Transform, Options);
  return pResult;
}

/*static*/ UCesiumGltfComponent* UCesiumGltfComponent::CreateOnGameThread(
    AActor* pParentActor,
    std::unique_ptr<HalfConstructed> pHalfConstructed,
    const glm::dmat4x4& cesiumToUnrealTransform,
    UMaterialInterface* pBaseMaterial,
    UMaterialInterface* pBaseWaterMaterial,
    UMaterialInterface* pBaseOpacityMaterial) {
  HalfConstructedReal* pReal =
      static_cast<HalfConstructedReal*>(pHalfConstructed.get());
  std::vector<LoadModelResult>& result = pReal->loadModelResult;
  if (result.size() == 0) {
    return nullptr;
  }

  UCesiumGltfComponent* Gltf = NewObject<UCesiumGltfComponent>(pParentActor);
  Gltf->SetUsingAbsoluteLocation(true);
  Gltf->SetFlags(RF_Transient);

  if (pBaseMaterial) {
    Gltf->BaseMaterial = pBaseMaterial;
  }

  if (pBaseWaterMaterial) {
    Gltf->BaseMaterialWithWater = pBaseWaterMaterial;
  }

  if (pBaseOpacityMaterial) {
    Gltf->OpacityMaskMaterial = pBaseOpacityMaterial;
  }

  for (LoadModelResult& model : result) {
    loadModelGameThreadPart(Gltf, model, cesiumToUnrealTransform);
  }
  Gltf->SetVisibility(false, true);
  Gltf->SetCollisionEnabled(ECollisionEnabled::NoCollision);
  return Gltf;
}

UCesiumGltfComponent::UCesiumGltfComponent() : USceneComponent() {
  // Structure to hold one-time initialization
  struct FConstructorStatics {
    ConstructorHelpers::FObjectFinder<UMaterial> BaseMaterial;
    ConstructorHelpers::FObjectFinder<UMaterial> BaseMaterialWithWater;
    ConstructorHelpers::FObjectFinder<UMaterial> OpacityMaskMaterial;
    FConstructorStatics()
        : BaseMaterial(TEXT(
              ""/CesiumForUnreal/Materials/M_CesiumOverlay.M_CesiumOverlay"")),
          BaseMaterialWithWater(TEXT(
              ""/CesiumForUnreal/Materials/M_CesiumOverlayWater.M_CesiumOverlayWater"")),
          OpacityMaskMaterial(TEXT(
              ""/CesiumForUnreal/Materials/M_CesiumDefaultMasked.M_CesiumDefaultMasked"")) {
    }
  };
  static FConstructorStatics ConstructorStatics;

  this->BaseMaterial = ConstructorStatics.BaseMaterial.Object;
  this->BaseMaterialWithWater = ConstructorStatics.BaseMaterialWithWater.Object;
  this->OpacityMaskMaterial = ConstructorStatics.OpacityMaskMaterial.Object;

  PrimaryComponentTick.bCanEverTick = false;
}

UCesiumGltfComponent::~UCesiumGltfComponent() {
  UE_LOG(LogCesium, VeryVerbose, TEXT(""~UCesiumGltfComponent""));
}

void UCesiumGltfComponent::UpdateTransformFromCesium(
    const glm::dmat4& cesiumToUnrealTransform) {
  for (USceneComponent* pSceneComponent : this->GetAttachChildren()) {
    UCesiumGltfPrimitiveComponent* pPrimitive =
        Cast<UCesiumGltfPrimitiveComponent>(pSceneComponent);
    if (pPrimitive) {
      pPrimitive->UpdateTransformFromCesium(cesiumToUnrealTransform);
    }
  }
}

void UCesiumGltfComponent::AttachRasterTile(
    const Cesium3DTiles::Tile& tile,
    const Cesium3DTiles::RasterOverlayTile& rasterTile,
    UTexture2D* pTexture,
    const CesiumGeometry::Rectangle& textureCoordinateRectangle,
    const glm::dvec2& translation,
    const glm::dvec2& scale) {
  if (this->OverlayTiles.Num() == 0) {
    // First overlay tile, generate texture coordinates
    // TODO
  }

  this->OverlayTiles.Add(FRasterOverlayTile{
      pTexture,
      FLinearColor(
          textureCoordinateRectangle.minimumX,
          textureCoordinateRectangle.minimumY,
          textureCoordinateRectangle.maximumX,
          textureCoordinateRectangle.maximumY),
      FLinearColor(translation.x, translation.y, scale.x, scale.y)});

  if (this->OverlayTiles.Num() > 3) {
    UE_LOG(LogCesium, Warning, TEXT(""Too many raster overlays""));
  }

  this->UpdateRasterOverlays();
}

void UCesiumGltfComponent::DetachRasterTile(
    const Cesium3DTiles::Tile& tile,
    const Cesium3DTiles::RasterOverlayTile& rasterTile,
    UTexture2D* pTexture,
    const CesiumGeometry::Rectangle& textureCoordinateRectangle) {
  size_t numBefore = this->OverlayTiles.Num();
  this->OverlayTiles.RemoveAll(
      [pTexture, &textureCoordinateRectangle](const FRasterOverlayTile& tile) {
        return tile.Texture == pTexture &&
               tile.TextureCoordinateRectangle.Equals(FLinearColor(
                   textureCoordinateRectangle.minimumX,
                   textureCoordinateRectangle.minimumY,
                   textureCoordinateRectangle.maximumX,
                   textureCoordinateRectangle.maximumY));
      });
  size_t numAfter = this->OverlayTiles.Num();

  if (numBefore - 1 != numAfter) {
    UE_LOG(
        LogCesium,
        VeryVerbose,
        TEXT(
            ""Raster tiles detached: %d, pTexture: %d, minX: %f, minY: %f, maxX: %f, maxY: %f""),
        numBefore - numAfter,
        pTexture,
        textureCoordinateRectangle.minimumX,
        textureCoordinateRectangle.minimumY,
        textureCoordinateRectangle.maximumX,
        textureCoordinateRectangle.maximumY);
  }

  this->UpdateRasterOverlays();
}

void UCesiumGltfComponent::SetCollisionEnabled(
    ECollisionEnabled::Type NewType) {
  for (USceneComponent* pSceneComponent : this->GetAttachChildren()) {
    UCesiumGltfPrimitiveComponent* pPrimitive =
        Cast<UCesiumGltfPrimitiveComponent>(pSceneComponent);
    if (pPrimitive) {
      pPrimitive->SetCollisionEnabled(NewType);
    }
  }
}

void UCesiumGltfComponent::FinishDestroy() {
  UE_LOG(LogCesium, VeryVerbose, TEXT(""UCesiumGltfComponent::FinishDestroy""));
  Super::FinishDestroy();
}

void UCesiumGltfComponent::UpdateRasterOverlays() {
  for (USceneComponent* pSceneComponent : this->GetAttachChildren()) {
    UCesiumGltfPrimitiveComponent* pPrimitive =
        Cast<UCesiumGltfPrimitiveComponent>(pSceneComponent);
    if (pPrimitive) {
      UMaterialInstanceDynamic* pMaterial =
          Cast<UMaterialInstanceDynamic>(pPrimitive->GetMaterial(0));

      if (pMaterial->IsPendingKillOrUnreachable()) {
        // Don't try to update the material while it's in the process of being
        // destroyed. This can lead to the render thread freaking out when
        // it's asked to update a parameter for a material that has been
        // marked for garbage collection.
        continue;
      }

      for (size_t i = 0; i < this->OverlayTiles.Num(); ++i) {
        FRasterOverlayTile& overlayTile = this->OverlayTiles[i];
        std::string is = std::to_string(i + 1);
        pMaterial->SetTextureParameterValue(
            (""OverlayTexture"" + is).c_str(),
            overlayTile.Texture);

        if (!overlayTile.Texture) {
          // The texture is null so don't use it.
          pMaterial->SetVectorParameterValue(
              (""OverlayRect"" + is).c_str(),
              FLinearColor(0.0f, 0.0f, 0.0f, 0.0f));
        } else {
          pMaterial->SetVectorParameterValue(
              (""OverlayRect"" + is).c_str(),
              overlayTile.TextureCoordinateRectangle);
        }

        pMaterial->SetVectorParameterValue(
            (""OverlayTranslationScale"" + is).c_str(),
            overlayTile.TranslationAndScale);
      }

      for (size_t i = this->OverlayTiles.Num(); i < 3; ++i) {
        std::string is = std::to_string(i + 1);
        pMaterial->SetTextureParameterValue(
            (""OverlayTexture"" + is).c_str(),
            nullptr);
        pMaterial->SetVectorParameterValue(
            (""OverlayRect"" + is).c_str(),
            FLinearColor(0.0f, 0.0f, 0.0f, 0.0f));
        pMaterial->SetVectorParameterValue(
            (""OverlayTranslationScale"" + is).c_str(),
            FLinearColor(0.0f, 0.0f, 0.0f, 0.0f));
      }

      pMaterial->SetScalarParameterValue(
          ""opacityMask"",
          this->OverlayTiles.Num() > 0 ? 0.0 : 1.0);
    }
  }
}

#if !PHYSICS_INTERFACE_PHYSX
// This is copied from FChaosDerivedDataCooker::BuildTriangleMeshes in
// C:\\Program Files\\Epic
// Games\\UE_4.26\\Engine\\Source\\Runtime\\Engine\\Private\\PhysicsEngine\\Experimental\\ChaosDerivedData.cpp.
// We can't use that method directly because it is private. Since we've copied
// it anyway, we've also modified it to be more efficient for our particular
// input data.
static TSharedPtr<Chaos::FTriangleMeshImplicitObject, ESPMode::ThreadSafe>
BuildChaosTriangleMeshes(
    const TArray<FStaticMeshBuildVertex>& vertices,
    const TArray<uint32>& indices) {
  UE_LOG(
      LogCesium,
      Warning,
      TEXT(
          ""The Chaos physics engine is not currently supported by Cesium for Unreal because functionality required to cook meshes at runtime is not available.""));
  return nullptr;
}
#endif
",16221,True,2825.2452925246516,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 Java 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.80291325295,median
"== Getting Started

Quarkus comes with a Maven archetype to scaffold a very simple starting project.

[source, bash, subs=attributes+]
----
mvn io.quarkus:quarkus-maven-plugin:{version}:create \\
    -DprojectGroupId=org.acme \\
    -DprojectArtifactId=getting-started \\
    -DclassName=""org.acme.quickstart.GreetingResource"" \\
    -Dpath=""/hello""
----

This creates a simple JAX-RS resource called `GreetingResource`.

[source, java]
----
@Path(""/hello"")
public class GreetingResource {

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        return ""hello"";
    }
}
----

== Gradle

// tag::update_10_8[]
There is no way to scaffold a project in Gradle but you only need to do:

[source, groovy]
----
plugins {
    id 'java'
    id 'io.quarkus' version '0.26.1' 
}

repositories {
    mavenCentral()
}

dependencies { 
    implementation enforcedPlatform('io.quarkus:quarkus-bom:0.26.1')
    implementation 'io.quarkus:quarkus-resteasy'
}
----

Or in Kotlin:

[source, kotlin]
----
plugins {
    java
}
apply(plugin = ""io.quarkus"")

repositories {
    mavenCentral()
}

dependencies {
    implementation(enforcedPlatform(""io.quarkus:quarkus-bom:0.26.1""))
    implementation(""io.quarkus:quarkus-resteasy"")
}
----
// end::update_10_8[]

== Packaging

// tag::update_16_26[]
[source, bash-shell]
----
mvn clean package
----

You need to distribute the `-runner.jar` file together with `quarkus-app` directory.

If `quarkus.package.uber-jar` property is set to true, then a uber-jar is created with all dependencies bundled inside the JAR.

By default, Quarkus uses fast jar packaging, if `quarkus.package.type` property is set to `legacy-jar` then Quarkus creates the old standard jar file.

[source, properties]
.application.properties
----
quarkus.package.uber-jar=true
quarkus.package.type=legacy-jar
----

To compile to native, you need to set `GRAALVM_HOME` environment variable and run the `native` profile.

[source, bash-shell]
----
mvn clean package -Pnative

./gradlew build -Dquarkus.package.type=native
----
// end::update_16_26[]

// tag::update_17_5[]
Possible `quarkus.package.type` are: `jar`, `legacy-jar`, `uber-jar` and `native`.
// end::update_17_5[]

*AppCDS*

// tag::update_17_11[]
Automatically generate AppCDS as part of the build process set the next property: `quarkus.package.create-appcds=true`.

To make use of it, just run `java -jar -XX:SharedArchiveFile=app-cds.jsa myapp.jar`.
// end::update_17_11[]

== Command mode

// tag::update_15_16[]
You can define the `main` CLI method to start Quarkus.
There are two ways, implementing `io.quarkus.runtime.QuarkusApplication` interface or use the Java main method to launch Quarkus.

[source, java]
----
@io.quarkus.runtime.annotations.QuarkusMain
public class HelloWorldMain implements QuarkusApplication {
  @Override
  public int run(String... args) throws Exception {
    System.out.println(""Hello World"");
    return 10;
 }
}
----

`run` method called when Quarkus starts, and stops when it finishes.

As Java `main`:

[source, java]
----
@QuarkusMain
public class JavaMain {
    public static void main(String... args) {
        Quarkus.run(HelloWorldMain.class, args);
    }
}
----

IMPORTANT: Use `@QuarkusMain` in only one place.

Use `Quarkus.waitForExit()` from the main thread if you want to run some logic on startup, and then run like a normal application (i.e. not exit).

You can inject command line arguments by using `@CommandLineArguments` annotation:

[source, java]
----
@CommandLineArguments
String[] args;
----
// end::update_15_16[]

*Testing*

Command Mode applications can be tested using the `@QuarkusMainTest` and `@QuarkusMainIntegrationTest` annotations.

[source, java]
----
import io.quarkus.test.junit.main.Launch;
import io.quarkus.test.junit.main.LaunchResult;
import io.quarkus.test.junit.main.QuarkusMainLauncher;
import io.quarkus.test.junit.main.QuarkusMainTest;

@QuarkusMainTest
public class HelloTest {
    @Test
    @Launch(""World"")
    public void testLaunchCommand(LaunchResult result) {
        Assertions.assertEquals(""Hello World"", result.getOutput());
    }
    @Test
    @Launch(value = {}, exitCode = 1)
    public void testLaunchCommandFailed() {
    }
    @Test
    public void testManualLaunch(QuarkusMainLauncher launcher) {
        LaunchResult result = launcher.launch(""Everyone"");
        Assertions.assertEquals(0, result.exitCode());
        Assertions.assertEquals(""Hello Everyone"", result.getOutput());
    }
}
----

// tag::update_16_15[]
*Picocli*

You can use Picocli to implement CLI applications:

[source, bash]
----
./mvnw quarkus:add-extension 
  -Dextensions=""picocli""
----

[source, java]
----
@CommandLine.Command
public class HelloCommand implements Runnable {
    
    @CommandLine.Option(names = {""-n"", ""--name""}, description = ""Who will we greet?"", defaultValue = ""World"")
    String name;
    
    private final GreetingService greetingService;
    
    public HelloCommand(GreetingService greetingService) {
        this.greetingService = greetingService;
    }
    
    @Override
    public void run() {
        greetingService.sayHello(name);
    }
}
----

All classes annotated with `picocli.CommandLine.Command` are registered as CDI beans.

If only one class annotated with `picocli.CommandLine.Command` it will be used as entry point. 
If you want to provide your own `@QuarkusMain`:

[source, java]
----
@QuarkusMain
@CommandLine.Command(name = ""demo"", mixinStandardHelpOptions = true)
public class ExampleApp implements Runnable, QuarkusApplication {
    
    @Inject
    CommandLine.IFactory factory;
    
    @Override
    public void run() {
    }

    @Override
    public int run(String... args) throws Exception {
        return new CommandLine(this, factory).execute(args);
    }
}
----

Use `quarkus.picocli.native-image.processing.enable` to `false` to use the `picocli-codegen` annotation processor instead of build steps.
// end::update_16_15[]

// tag::update_17_1[]
You can also configure CDI beans with PicoCLI arguments:

[source, java]
----
@CommandLine.Command
public class EntryCommand implements Runnable {
    @CommandLine.Option(names = ""-c"", description = ""JDBC connection string"")
    String connectionString;
    
    @Inject
    DataSource dataSource;
}

@ApplicationScoped
class DatasourceConfiguration {
    
    @Produces
    @ApplicationScoped
    DataSource dataSource(CommandLine.ParseResult parseResult) {
        System.out.println(parseResult.matchedOption(""c"").getValue().toString());
    }
}
----
// end::update_17_1[]

== Extensions

Quarkus comes with extensions to integrate with some libraries such as JSON-B, Camel or MicroProfile spec.
To list all available extensions just run:

[source, bash]
----
./mvnw quarkus:list-extensions
----

// tag::update_2_4[]
TIP: You can use `-DsearchPattern=panache` to filter out all extensions except the ones matching the expression.
// end::update_2_4[]

And to register the extensions into build tool:

[source, bash]
----
./mvnw quarkus:add-extension -Dextensions=""""

./mvnw quarkus:remove-extension -Dextensions=""""
----

TIP: `extensions` property supports CSV format to register more than one extension at once.

== Application Lifecycle
// tag::update_1_3[]
You can be notified when the application starts/stops by observing `StartupEvent` and `ShutdownEvent` events.

[source, java]
----
@ApplicationScoped
public class ApplicationLifecycle {
    void onStart(@Observes StartupEvent event) {}
    void onStop(@Observes ShutdownEvent event) {}
}
----
// end::update_1_3[]

// tag::update_14_31[]
Quarkus supports graceful shutdown.
By default there is no timeout but can be set by using the `quarkus.shutdown.timeout` config property.
// end::update_14_31[]

== Dev Mode

// tag::update_17_14[]
[source, bash]
----
./mvnw compile quarkus:dev

./gradlew quarkusDev
----

Endpoints are registered automatically to provide some basic debug info in dev mode:

* `HTTP GET /quarkus/arc/beans`
** Query Parameters: `scope`, `beanClass`, `kind`.
* `HTTP GET /quarkus/arc/observers`
// end::update_17_14[]

== Dev Services

Quarkus supports the automatic provisioning of unconfigured services in development and test mode. 

General configuration properties:

`quarkus.devservices.enabled`::
If you want to disable all Dev Services. (default: `true`)

`quarkus.devservices.timeout`::
Startup timeout. (default: `60S`)

Set `DOCKER_HOST` env var to a remote Docker Host to use it instead the local one.

== Dev UI

// tag::update_22_11[]
Quarkus adds a Dev UI console to expose extension features.

The Dev UI is available in dev mode only and accessible at the `/q/dev` endpoint by default.
// end::update_22_11[]

== Continuous Testing

Quarkus supports continuous testing, where tests run immediately after code changes have been saved. This allows you to get instant feedback on your code changes. Quarkus detects which tests cover which code, and uses this information to only run the relevant tests when code is changed.

Start Quarkus in Dev Mode to run it.

Also, you can start continuous testing and not dev mode by running `mvn quarkus:test`.

`quarkus.test.exclude-pattern`:: 
Tests that should be excluded with continuous testing default: `.*\\.IT[^.]+|.*IT|.*ITCase`

== Adding Configuration Parameters

To add configuration to your application, Quarkus relies on https://github.com/eclipse/microprofile-config[MicroProfile Config, window=""_blank""] spec.

[source, java]
----
@ConfigProperty(name = ""greetings.message"")
String message;

@ConfigProperty(name = ""greetings.message"",
                defaultValue = ""Hello"")
String messageWithDefault;

@ConfigProperty(name = ""greetings.message"")
Optional<String> optionalMessage;
----

// tag::update_14_6[]
Properties can be set (in decreasing priority) as:

* System properties (`-Dgreetings.message`).
* Environment variables (`GREETINGS_MESSAGE`).
* Environment file named `.env` placed in the current working directory (`GREETING_MESSAGE=`).
* External config directory under the current working directory: `config/application.properties`.
* Resources `src/main/resources/application.properties`.
// end::update_14_6[]

[source, properties]
----
greetings.message = Hello World
----

// tag::update_2_7[]
TIP: `Array`, `List` and `Set` are supported. The delimiter is comma (`,`) char and `\\` is the escape char.
// end::update_2_7[]

// tag::update_2_9[]
*Configuration Profiles*

Quarkus allow you to have multiple configuration in the same file (`application.properties`).

The syntax for this is `%{profile}.config.key=value`.

[source, properties]
----
quarkus.http.port=9090
%dev.quarkus.http.port=8181
----

HTTP port will be 9090, unless the 'dev' profile is active.

Default profiles are:

* `dev`: Activated when in development mode (`quarkus:dev`).
* `test`: Activated when running tests.
* `prod`: The default profile when not running in development or test mode

You can create custom profile names by enabling the profile either setting `quarkus.profile` system property or `QUARKUS_PROFILE` environment variable.

[source, properties]
----
quarkus.http.port=9090
%staging.quarkus.http.port=9999
----

And enable it `quarkus.profile=staging`.
// end::update_2_9[]

// tag::update_13_5[]
NOTE: To get the active profile programmatically use `io.quarkus.runtime.configuration.ProfileManager.getActiveProfile()`.
// end::update_13_5[]

// tag::update_6_7[]
You can also set it in the build tool:

[source, xml]
----
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
<version>${surefire-plugin.version}</version>
<configuration>
    <systemPropertyVariables>
        <quarkus.test.profile>foo</quarkus.test.profile>
        <buildDirectory>${project.build.directory}
        </buildDirectory>
    </systemPropertyVariables>
</configuration>
----

TIP: Same for `maven-failsafe-plugin`.

[source, groovy]
----
test {
    useJUnitPlatform()
    systemProperty ""quarkus.test.profile"", ""foo""
}
----
// end::update_6_7[]

// tag::update_13_7[]
Special properties are set in *prod* mode: `quarkus.application.version` and `quarkus.application.name` to get them available at runtime.

[source, java]
----
@ConfigProperty(name = ""quarkus.application.name"")
String applicationName;
----
// end::update_13_7[]

*Additional locations*

// tag::update_22_5[]
You can use `smallrye.config.locations` property to set additional configuration files.

[source, properties]
----
smallrye.config.locations=config.properties
----

or 

[source, bash]
----
java -jar -Dsmallrye.config.locations=config.properties
----
// end::update_22_5[]

You can embed configuration files inside a dependency by adding `META-INF/microprofile.properties` inside the JAR.
When dependency is added to the application, configuration properties are merged with current configuration.

// tag::update_9_1[]
*@ConfigProperties*

As an alternative to injecting multiple related configuration values, you can also use the `@io.quarkus.arc.config.ConfigProperties` annotation to group properties.

[source, java]
----
@ConfigProperties(prefix = ""greeting"", namingStrategy=NamingStrategy.KEBAB_CASE)
public class GreetingConfiguration {
    private String message;
    // getter/setter
}
----

This class maps `greeting.message` property defined in `application.properties`.

You can inject this class by using CDI `@Inject GreetingConfiguration greeting;`.

`@IfBuildProfile`, `@UnlessBuildProfile`, `@IfBuildProperty` and `@UnlessBuildProperty` annotations are used to define when configuration properties are valid.

[source, java]
----
@UnlessBuildProfile(""test"")
@ConfigProperties
public class ServiceConfiguration {
    public String user;
    public String password;
}
----

Also you can use an interface approach:

[source, java]
----
@ConfigProperties(prefix = ""greeting"", namingStrategy=NamingStrategy.KEBAB_CASE)
public interface GreetingConfiguration {

    @ConfigProperty(name = ""message"")
    String message();
    String getSuffix();
----

If property does not follow getter/setter naming convention you need to use `org.eclipse.microprofile.config.inject.ConfigProperty` to set it.

Nested objects are also supporte:

[source, java]
----
@ConfigProperties(prefix = ""greeting"", namingStrategy=NamingStrategy.KEBAB_CASE)
public class GreetingConfiguration {
    public String message;
    public HiddenConfig hidden;

    public static class HiddenConfig {
        public List<String> recipients;
    }
}
----

And an `application.properties` mapping previous class:

[source, properties]
----
greeting.message = hello
greeting.hidden.recipients=Jane,John
----

Bean Validation is also supported so properties are validated at startup time, for example `@Size(min = 20) public String message;`.

TIP: `prefix` attribute is not mandatory. If not provided, attribute is determined by class name (ie `GreeetingConfiguration` is translated to `greeting` or `GreetingExtraConfiguration` to `greeting-extra`). The suffix of the class is always removed.
// end::update_9_1[]

// tag::update_13_11[]
Naming strategy can be changed with property `namingStrategy`. `KEBAB_CASE` (whatever.foo-bar) or `VERBATIM` (whatever.fooBar).
// end::update_13_11[]

// tag::update_17_2[]
`@io.quarkus.arc.config.ConfigIgnore` annotation can be used to ignore the injection of configuration elements.

[source, java]
----
@ConfigIgnore
public Integer ignored;
----
// end::update_17_2[]

*YAML Config*
// tag::update_12_12[]

YAML configuration is also supported.
The configuration file is called `application.yaml` and you need to register a dependency to enable its support:

[source, xml]
.pom.xml
----
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-config-yaml</artifactId>
</dependency>
----

[source, yaml]
----
quarkus:
  datasource:
    url: jdbc:postgresql://localhost:5432/some-database
    driver: org.postgresql.Driver
----

Or with profiles:

[source, yaml]
----
""%dev"":
  quarkus:
    datasource:
      url: jdbc:postgresql://localhost:5432/some-database
      driver: org.postgresql.Driver
----

In case of subkeys `~` is used to refer to the unprefixed part.

[source, yaml]
----
quarkus:
  http:
    cors:
      ~: true
      methods: GET,PUT,POST
----

Is equivalent to:

[source, properties]
----
quarkus.http.cors=true
quarkus.http.cors.methods=GET,PUT,POST
----
// end::update_12_12[]

// tag::update_2_6[]

*Custom Loader*

You can implement your own `ConfigSource` to load configuration from different places than the default ones provided by Quarkus.
For example, database, custom XML, REST Endpoints, ...

You need to create a new class and implement `ConfigSource` interface:

[source, java]
----
package com.acme.config;
public class InMemoryConfig implements ConfigSource {

    private Map<String, String> prop = new HashMap<>();

    public InMemoryConfig() {
        // Init properties
    }

    @Override
    public int getOrdinal() {
        // The highest ordinal takes precedence
        return 900;
    }

    @Override
    public Map<String, String> getProperties() {
        return prop;
    }

    @Override
    public String getValue(String propertyName) {
        return prop.get(propertyName);
    }

    @Override
    public String getName() {
        return ""MemoryConfigSource"";
    }
}
----

Then you need to register the `ConfigSource` as Java service.
Create a file with the following content:

./META-INF/services/org.eclipse.microprofile.config.spi.ConfigSource
[source]
----
com.acme.config.InMemoryConfig
----
// end::update_2_6[]

// tag::update_2_8[]
*Custom Converters*

You can implement your own conversion types from String.
Implement `org.eclipse.microprofile.config.spi.Converter` interface:

[source, java]
----
@Priority(DEFAULT_QUARKUS_CONVERTER_PRIORITY + 100)
public class CustomInstantConverter
    implements Converter<Instant> {

    @Override
    public Instant convert(String value) {
        if (""now"".equals(value.trim())) {
            return Instant.now();
        }
        return Instant.parse(value);
    }
}
----

`@Priority` annotation is used to override the default `InstantConverter`.

Then you need to register the `Converter` as Java service.
Create a file with the following content:

./META-INF/services/org.eclipse.microprofile.config.spi.Converter
[source]
----
com.acme.config.CustomInstantConverter
----
// end::update_2_8[]

== Undertow Properties

// tag::update_15_1[]
Possible parameters with prefix `quarkus.servlet`:

`context-path`::
The context path to serve all Servlet context from. (default: `/`)

`default-charset`::
The default charset to use for reading and writing requests. (default: `UTF-8`)
// end::update_15_1[]

== Injection

Quarkus is based on CDI 2.0 to implement injection of code.
It is not fully supported and only a subset of the https://quarkus.io/guides/cdi-reference[specification is implemented, window=""_blank""].

[source, java]
----
@ApplicationScoped
public class GreetingService {

    public String message(String message) {
        return message.toUpperCase();
    }
}
----

Scope annotation is mandatory to make the bean discoverable.

[source, java]
----
@Inject
GreetingService greetingService;
----

IMPORTANT: Quarkus is designed with Substrate VM in mind. For this reason, we encourage you to use _package-private_ scope instead of _private_.

*Produces*

// tag::update_5_4[]
You can also create a factory of an object by using `@javax.enterprise.inject.Produces` annotation.

[source, java]
----
@Produces
@ApplicationScoped
Message message() {
    Message m = new Message();
    m.setMsn(""Hello"");
    return m;
}

@Inject
Message msg;
----

*Qualifiers*

You can use qualifiers to return different implementations of the same interface or to customize the configuration of the bean.

[source, java]
----
@Qualifier
@Retention(RUNTIME)
@Target({TYPE, METHOD, FIELD, PARAMETER})
public @interface Quote {
    @Nonbinding String value();
}

@Produces
@Quote("""")
Message message(InjectionPoint msg) {
    Message m = new Message();
    m.setMsn(
        msg.getAnnotated()
        .getAnnotation(Quote.class)
        .value()
    );

    return m;
}

@Inject
@Quote(""Aloha Beach"")
Message message;
----
// end::update_5_4[]

// tag::update_7_1[]
TIP: Quarkus breaks the CDI spec by allowing you to inject qualified beans without using `@Inject` annotation.

[source, java]
----
@Quote(""Aloha Beach"")
Message message;
----
// end::update_7_1[]

// tag::update_15_10[]
TIP: Quarkus breaks the CDI spec by skipping the `@Produces` annotation completely if the producer method is annotated with a scope annotation, a stereotype or a qualifier. 

[source,java]
----
@Quote("""")
Message message(InjectionPoint msg) {
}

@Quote(""Aloha Beach"")
Message message;
----
// end::update_15_10[]

`@LookupIfProperty` indicates that a bean should only be obtained if a runtime configuration property matches the provided value.
`@LookupUnlessProperty`, on the other hand, indicates that a bean should only be obtained if a runtime configuration property does not match the provided value.

[source, java]
----
@LookupIfProperty(name = ""service.foo.enabled"", stringValue = ""true"")
@ApplicationScoped
class ServiceFoo implements Service {
 
    public String name() {
       return ""foo"";
    }
}
----

*Alternatives*

// tag::update_15_11[]
It is also possible to select alternatives for an application using `application.properties`.

[source, properties]
----
quarkus.arc.selected-alternatives=org.acme.Foo,org.acme.*,Bar
----
// end::update_15_11[] 

*Beans by Quarkus Profile*

// tag::update_15_15[]
Using `@io.quarkus.arc.profile.IfBuildProfile` and `@io.quarkus.arc.profile.UnlessBuildProfile` annotations, you can conditionally enable a bean.

[source,java]
----
@Dependent
public class TracerConfiguration {
    @Produces
    @IfBuildProfile(""prod"")
    public Tracer realTracer(Reporter reporter, Configuration configuration) {
        return new RealTracer(reporter, configuration);
    }
    @Produces
    @DefaultBean
    public Tracer noopTracer() {
        return new NoopTracer();
    }
}
----
// end::update_15_15[]

// tag::update_16_1[]
Using `@io.quarkus.arc.profile.IfBuildProperty` annotation, you can conditionally enable a bean.
`@io.quarkus.arc.DefaultBean` sets the default bean.

[source, java]
----
@Dependent
public class TracerConfiguration {
    @Produces
    @IfBuildProperty(name = ""some.tracer.enabled"", stringValue = ""true"")
    public Tracer realTracer(Reporter reporter, Configuration configuration) {}
    
    @Produces
    @DefaultBean
    public Tracer noopTracer() {}
}
----

NOTE: Properties set at runtime have absolutely no effect on the bean resolution using `@IfBuildProperty`.

// end::update_16_1[]

// tag::update_18_8[]
*Container-managed Concurrency*

Quarkus provides `@io.quarkus.arc.Lock` and a built-in interceptor for concurrency control.

[source, java]
----
@Lock
@ApplicationScoped
class SharedService {
  
    void addAmount(BigDecimal amout) {
    }
  
    @Lock(value = Lock.Type.READ, time = 1, unit = TimeUnit.SECONDS)
    BigDecimal getAmount() {
    }
}
----

By default the class is in write mode (so no concurrent calls allowed) except when lock type is `READ` where the method can be called concurrently if no write operation in process.
// end::update_18_8[]

== JSON Marshalling/Unmarshalling

To work with `JSON-B` you need to add a dependency:

[source, bash]
----
./mvnw quarkus:add-extension
  -Dextensions=""io.quarkus:quarkus-resteasy-jsonb""
----

Any POJO is marshaled/unmarshalled automatically.

[source, java]
----
public class Sauce {
    private String name;
    private long scovilleHeatUnits;

    // getter/setters
}
----

JSON equivalent:

[source, json]
----
{
	""name"":""Blair's Ultra Death"",
	""scovilleHeatUnits"": 1100000
}
----

In a `POST` endpoint example:

[source, java]
----
@POST
@Consumes(MediaType.APPLICATION_JSON)
public Response create(Sauce sauce) {
    // Create Sauce
    return Response.created(URI.create(sauce.getId()))
            .build();
}
----

// tag::update_24_5[]
To provide custom  JsonBConfig object:

[source, java]
----
@Dependent
JsonbConfig jsonConfig(Instance<JsonbConfigCustomizer> customizers) {
    JsonbConfig config = myJsonbConfig(); // Custom `JsonbConfig`
    for (JsonbConfigCustomizer customizer : customizers) {
        customizer.customize(config);
    }

    return config;
}
----
// end::update_24_5[]

// tag::update_6_1[]
To work with `Jackson` you need to add:

[source, bash]
----
./mvnw quarkus:add-extension
  -Dextensions=""quarkus-resteasy-jackson""
----

If you don't want to use the default `ObjectMapper` you can customize it by:

[source, java]
----
@ApplicationScoped
public class CustomObjectMapperConfig {
    @Singleton
    @Produces
    public ObjectMapper objectMapper(Instance<ObjectMapperCustomizer> customizers) {
        ObjectMapper objectMapper = new ObjectMapper();
        // perform configuration

        for (ObjectMapperCustomizer customizer : customizers) {
            customizer.customize(mapper);
        }
        return objectMapper;
    }
}
----
// end::update_6_1[]

// tag::update_21_8[]

IMPORTANT: Default media type in Quarkus RestEasy is JSON.

// end::update_21_8[]

== XML Marshalling/Unmarshalling

// tag::update_9_8[]
To work with `JAX-B` you need to add a dependency:

[source, bash]
----
./mvnw quarkus:add-extension
  -Dextensions=""quarkus-resteasy-jaxb""
----

Then annotated POJOs are converted to XML.

[source, java]
----
@XmlRootElement
public class Message {
}

@GET
@Produces(MediaType.APPLICATION_XML)
public Message hello() {
    return message;
}
----
// end::update_9_8[]

== JAXP

// tag::update_20_1[]
To work with `JAX-P` you need to add a dependency:

[source, bash]
----
./mvnw quarkus:add-extension
  -Dextensions=""jaxp""
----

[source, java]
----
final DocumentBuilder dBuilder = DocumentBuilderFactory.newInstance().newDocumentBuilder();
final Document doc = dBuilder.parse(in);
return doc.getDocumentElement().getTextContent();
----
// end::update_20_1[]

== Validator

Quarkus uses https://hibernate.org/validator/[Hibernate Validator, window=""_blank""] to validate input/output of REST services and business services using Bean validation spec.

[source, bash]
----
./mvnw quarkus:add-extension
  -Dextensions=""io.quarkus:quarkus-hibernate-validator""
----

Annotate POJO objects with validator annotations such as: `@NotNull`, `@Digits`, `@NotBlank`, `@Min`, `@Max`, ...

[source, java]
----
public class Sauce {

    @NotBlank(message = ""Name may not be blank"")
    private String name;
    @Min(0)
    private long scovilleHeatUnits;

    // getter/setters
}
----

To validate an object use `@Valid` annotation:

[source, java]
----
public Response create(@Valid Sauce sauce) {}
----

TIP: If a validation error is triggered, a violation report is generated and serialized as JSON. If you want to manipulate the output, you need to catch in the code the `ConstraintViolationException` exception.

*Create Your Custom Constraints*

First you need to create the custom annotation:

[source, java]
----
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR,
            PARAMETER, TYPE_USE })
@Retention(RUNTIME)
@Documented
@Constraint(validatedBy = { NotExpiredValidator.class})
public @interface NotExpired {

    String message() default ""Sauce must not be expired"";
    Class<?>[] groups() default { };
    Class<? extends Payload>[] payload() default { };

}
----

You need to implement the validator logic in a class that implements `ConstraintValidator`.

[source, java]
----
public class NotExpiredValidator
    implements ConstraintValidator<NotExpired, LocalDate>
    {

    @Override
    public boolean isValid(LocalDate value,
                        ConstraintValidatorContext ctx) {
        if ( value == null ) return true;
        LocalDate today = LocalDate.now();
        return ChronoUnit.YEARS.between(today, value) > 0;
    }
}
----

And use it normally:

[source, java]
----
@NotExpired
@JsonbDateFormat(value = ""yyyy-MM-dd"")
private LocalDate expired;
----

*Manual Validation*

You can call the validation process manually instead of relaying to `@Valid` by injecting `Validator` class.

[source, java]
----
@Inject
Validator validator;
----

And use it:

[source, java]
----
Set<ConstraintViolation<Sauce>> violations =
            validator.validate(sauce);
----

*Localization*

// tag::update_13_13[]
You can configure the based locale for validation messages.

[source, properties]
----
quarkus.default-locale=ca-ES
# Supported locales resolved by Accept-Language
quarkus.locales=en-US,es-ES,fr-FR, ca_ES
----

[source, properties]
.ValidationMessages_ca_ES.properties
----
pattern.message=No conforme al patro
----

[source, java]
----
@Pattern(regexp = ""A.*"", message = ""{pattern.message}"")
private String name;
----
// end::update_13_13[]

// tag::update_15_24[]
Bean Validation can be configured .
The prefix is: `quarkus.hibernate-validator`.

`fail-fast`::
When fail fast is enabled the validation will stop on the first constraint violation detected. (default: `false`)

`method-validation.allow-overriding-parameter-constraints`::
Define whether overriding methods that override constraints should throw an exception. (default: `false`).

`method-validation.allow-parameter-constraints-on-parallel-methods`::
Define whether parallel methods that define constraints should throw an exception. (default: `false`).

`method-validation.allow-multiple-cascaded-validation-on-return-values`::
Define whether more than one constraint on a return value may be marked for cascading validation are allowed. (default: `false`).
// end::update_15_24[]

== Logging

You can configure how Quarkus logs:

[source, properties]
----
quarkus.log.console.enable=true
quarkus.log.console.level=DEBUG
quarkus.log.console.color=false
quarkus.log.category.""com.lordofthejars"".level=DEBUG
----

Prefix is `quarkus.log`.

`category.""<category-name>"".level`::
Minimum level category (default: `INFO`)

`level`::
Default minimum level (default: `INFO`)

`console.enabled`::
Console logging enabled (default: `true`)

`console.format`::
Format pattern to use for logging. Default value: +
`%d{yyyy-MM-dd HH:mm:ss,SSS} %-5p [%c{3.}] (%t) %s%e%n`

`console.level`::
Minimum log level (default: `INFO`)

`console.color`::
Allow color rendering (default: `true`)

`console.stderr`::
If console logging should go to System#err instead of System#out (default: `false`)

`file.enable`::
File logging enabled (default: `false`)

`file.format`::
Format pattern to use for logging. Default value: +
`%d{yyyy-MM-dd HH:mm:ss,SSS} %h %N[%i] %-5p [%c{3.}] (%t) %s%e%n`

`file.level`::
Minimum log level (default: `ALL`)

`file.path`::
The path to log file (default: `quarkus.log`)

`file.rotation.max-file-size`::
The maximum file size of the log file

`file.rotation.max-backup-index`::
The maximum number of backups to keep (default: `1`)

`file.rotation.file-suffix`::
Rotating log file suffix.

`file.rotation.rotate-on-boot`::
Indicates rotate logs at bootup (default: `true`)

`file.async`::
Log asynchronously (default: `false`)

`file.async.queue-length`::
The queue length to use before flushing writing (default: `512`)

`file.async.overflow`::
Action when queue is full (default: `BLOCK`)

`syslog.enable`::
syslog logging is enabled (default: `false`)

`syslog.format`::
The format pattern to use for logging to syslog. Default value: +
`%d{yyyy-MM-dd HH:mm:ss,SSS} %h %N[%i] %-5p [%c{3.}] (%t) %s%e%n`

`syslog.level`::
The minimum log level to write to syslog (default: `ALL`)

`syslog.endpoint`::
The IP address and port of the syslog server (default: `localhost:514`)

`syslog.app-name`::
The app name used when formatting the message in RFC5424 format (default: current process name)

`syslog.hostname`::
The name of the host the messages are being sent from (default: current hostname)

`syslog.facility`::
Priority of the message as defined by RFC-5424 and RFC-3164 (default: `USER_LEVEL`)

`syslog.syslog-type`::
The syslog type of format message (default: `RFC5424`)

`syslog.protocol`::
Protocol used (default: `TCP`)

`syslog.use-counting-framing`::
Message prefixed with the size of the message (default `false`)

`syslog.truncate`::
Message should be truncated (default: `true`)

`syslog.block-on-reconnect`::
Block when attempting to reconnect (default: `true`)

`syslog.async`::
Log asynchronously (default: `false`)

`syslog.async.queue-length`::
The queue length to use before flushing writing (default: `512`)

`syslog.async.overflow`::
Action when queue is full (default: `BLOCK`)

// tag::update_22_4[]
You can inject logger instance:

[source, java]
----
import org.jboss.logging.Logger;
import io.quarkus.arc.log.LoggerName;

@Inject
Logger log;

@LoggerName(""foo"")
Logger fooLog;

public void ping() {
    log.info(""Simple!"");
}
----
// end::update_22_4[]

*Gelf ouput*
// tag::update_13_4[]

You can configure the output to be in _GELF_ format instead of plain text.

[source, shell-session]
----
./mvnw quarkus:add-extension
  -Dextensions=""quarkus-logging-gelf""
----

`handler.gelf.enabled`::
Enable GELF logging handler (default: `false`)

`handler.gelf.host`::
Hostname/IP of Logstash/Graylof. Prepend `tcp:` for using TCP protocol. (default: `udp:localhost`)

`handler.gelf.port`::
The port. (default: `12201`)

`handler.gelf.version`::
GELF version. (default: `1.1`)

`handler.gelf.extract-stack-trace`::
Post Stack-Trace to StackTrace field. (default: `true`)

`handler.gelf.stack-trace-throwable-reference`::
Gets the cause level to stack trace. `0` is fulls tack trace. (default: `0`)

`handler.gelf.filter-stack-trace`::
Stack-Trace filtering. (default: `false`)

`handler.gelf.timestamp-pattern`::
Java Date pattern. (default: `yyyy-MM-dd HH:mm:ss,SSS`)

`handler.gelf.level`::
Log level `java.util.logging.Level`. (default: `ALL`)

`handler.gelf.facility`::
Name of the facility. (default: `jboss-logmanage`)

`handler.gelf.additional-field.<field>.<subfield>`::
Post additional fields. `quarkus.log.handler.gelf.additional-field.field1.type=String`

`handler.gelf.include-full-mdc`::
Include all fields from the MDC.

`handler.gelf.maximum-message-size`::
Maximum message size (in bytes). (default: `8192`)

`handler.gelf.include-log-message-parameters`::
Include message parameters from the log event. (default: `true`)

`handler.gelf.include-location`::
Include source code location. (default: `true`)
// end::update_13_4[]

*JSON output*
// tag::update_12_9[]

You can configure the output to be in _JSON_ format instead of plain text.

[source, shell-session]
----
./mvnw quarkus:add-extension
  -Dextensions=""quarkus-logging-json""
----

And the configuration values are prefix with `quarkus.log`:

`json`::
JSON logging is enabled (default: true).

`json.pretty-print`::
JSON output is ""pretty-printed"" (default: false)

`json.date-format`::
Specify the date format to use (default: the default format)

`json.record-delimiter`::
Record delimiter to add (default: no delimiter)

`json.zone-id`::
The time zone ID

`json.exception-output-type`::
The exception output type: `detailed`, `formatted`, `detailed-and-formatted` (default: `detailed`)

`json.print-details`::
Detailed caller information should be logged (default: false)
// end::update_12_9[]

== Rest Client

Quarkus implements https://github.com/eclipse/microprofile-rest-client[MicroProfile Rest Client, window=""_blank""] spec:

[source, bash]
----
./mvnw quarkus:add-extension
  -Dextensions=""quarkus-rest-client""
----

To get content from http://worldclockapi.com/api/json/cet/now you need to create a service interface:

[source, java]
----
@Path(""/api"")
@RegisterRestClient
public interface WorldClockService {

    @GET @Path(""/json/cet/now"")
    @Produces(MediaType.APPLICATION_JSON)
    WorldClock getNow();

    @GET
    @Path(""/json/{where}/now"")
    @Produces(MediaType.APPLICATION_JSON)
    WorldClock getSauce(@BeanParam
                    WorldClockOptions worldClockOptions);

}
----

[source, java]
----
public class WorldClockOptions {
    @HeaderParam(""Authorization"")
    String auth;

    @PathParam(""where"")
    String where;
}
----

And configure the hostname at `application.properties`:

[source, properties]
----
org.acme.quickstart.WorldClockService/mp-rest/url=
        http://worldclockapi.com
----

Injecting the client:

[source, java]
----
@RestClient
WorldClockService worldClockService;
----

// tag::update_1_1[]
If invokation happens within JAX-RS, you can propagate headers from incoming to outgoing by using next property.

[source, properties]
----
org.eclipse.microprofile.rest.client.propagateHeaders=
            Authorization,MyCustomHeader
----
// end::update_1_1[]

TIP: You can still use the JAX-RS client without any problem `ClientBuilder.newClient().target(...)`

*Adding headers*

You can customize the headers passed by implementing MicroProfile `ClientHeadersFactory` annotation:

[source, java]
----
@RegisterForReflection
public class BaggageHeadersFactory
                implements ClientHeadersFactory {
    @Override
    public MultivaluedMap<String, String> update(
        MultivaluedMap<String, String> incomingHeaders,
        MultivaluedMap<String, String> outgoingHeaders) {}
}
----

And registering it in the client using `RegisterClientHeaders` annotation.

[source, java]
----
@RegisterClientHeaders(BaggageHeadersFactory.class)
@RegisterRestClient
public interface WorldClockService {}
----

Or statically set:

[source, java]
----
@GET
@ClientHeaderParam(name=""X-Log-Level"", value=""ERROR"")
Response getNow();
----

*Asynchronous*

A method on client interface can return a `CompletionStage` class to be executed asynchronously.

[source, java]
----
@GET @Path(""/json/cet/now"")
@Produces(MediaType.APPLICATION_JSON)
CompletionStage<WorldClock> getNow();
----

*Reactive*

// tag::update_14_15[]
Rest Client also integrates with reactive library named Mutiny.
To start using it you need to add the `quarkus-rest-client-mutiny`.

After that, a methodon a client interface can return a `io.smallrye.mutiny.Uni` instance.

[source, java]
----
@GET @Path(""/json/cet/now"")
@Produces(MediaType.APPLICATION_JSON)
Uni<WorldClock> getNow();
----
// end::update_14_15[]

// tag::update_24_8[]
A RESTEasy Reactive-based REST Client extension.
You only need to replace the `quarkus-rest-client` to  `quarkus-rest-client-reactive`.
// end::update_24_8[]

*Multipart*

// tag::update_10_10[]
It is really easy to send multipart form-data with Rest Client.

[source, xml]
----
<dependency>
    <groupId>org.jboss.resteasy</groupId>
    <artifactId>resteasy-multipart-provider</artifactId>
</dependency>
----

The model object:

[source, java]
----
import java.io.InputStream;

import javax.ws.rs.FormParam;
import javax.ws.rs.core.MediaType;

import 
    org.jboss.resteasy.annotations.providers.multipart.PartType;

public class MultipartBody {

    @FormParam(""file"")
    @PartType(MediaType.APPLICATION_OCTET_STREAM)
    private InputStream file;

    @FormParam(""fileName"")
    @PartType(MediaType.TEXT_PLAIN)
    private String name;

    // getter/setters
}
----

And the Rest client interface:

[source, java]
----
import 
    org.jboss.resteasy.annotations.providers.multipart.MultipartForm;

@Path(""/echo"")
@RegisterRestClient
public interface MultipartService {

    @POST
    @Consumes(MediaType.MULTIPART_FORM_DATA)
    @Produces(MediaType.TEXT_PLAIN)
    String sendMultipartData(@MultipartForm 
                        MultipartBody data);

}
----
// end::update_10_10[]

// tag::update_11_4[]
*SSL*

You can configure Rest Client key stores.

[source, properties]
----
org.acme.quickstart.WorldClockService/mp-rest/trustStore=
    classpath:/store.jks
org.acme.quickstart.WorldClockService/mp-rest/trustStorePassword=
    supersecret
----

Possible configuration properties:

`%s/mp-rest/trustStore`::
Trust store location defined with `classpath:` or `file:` prefix.

`%s/mp-rest/trustStorePassword`::
Trust store password.

`%s/mp-rest/trustStoreType`::
Trust store type (default: `JKS`)

`%s/mp-rest/hostnameVerifier`::
Custom hostname verifier class name. To disable SSL verification you can use `io.quarkus.restclient.NoopHostnameVerifier`.

`%s/mp-rest/keyStore`::
Key store location defined with `classpath:` or `file:` prefix.

`%s/mp-rest/keyStorePassword`::
Key store password.

`%s/mp-rest/keyStoreType`::
Key store type (default: `JKS`)
// end::update_11_4[]

// tag::update_11_5[]
*Timeout* 

You can define the timeout of the Rest Client:

[source, properties]
----
org.acme.quickstart.WorldClockService/mp-rest/connectTimeout=
    1000
org.acme.quickstart.WorldClockService/mp-rest/readTimeout=
    2000
----
// end::update_11_5[]

*Instantiate client programmatically*

// tag::update_20_4[]
[source, java]
----
MovieReviewService reviewSvc = RestClientBuilder.newBuilder()
            .baseUri(apiUri)
            .build(WorldClockService.class);
----
// end::update_20_4[]

== Testing

Quarkus archetype adds test dependencies with JUnit 5 and Rest-Assured library to test REST endpoints.

[source, java]
----
@QuarkusTest
public class GreetingResourceTest {

    @Test
    public void testHelloEndpoint() {
        given()
          .when().get(""/hello"")
          .then()
             .statusCode(200)
             .body(is(""hello""));
    }
}
----

Test port can be set in `quarkus.http.test-port` property.
Timeout can be set in `quarkus.http.test-timeout` property.

You can also inject the URL where Quarkus is started:

[source, java]
----
@TestHTTPResource(""index.html"")
URL url;
----

// tag::update_18_9[]
[source, java]
----
@TestHTTPEndpoint(GreetingResource.class)
@TestHTTPResource
URL url;
----

[source, java]
----
@QuarkusTest
@TestHTTPEndpoint(GreetingResource.class)
public class GreetingResourceTest {
    @Test
    public void testHelloEndpoint() {
        given()
          .when().get()
          .then()
             .statusCode(200)
             .body(is(""hello""));
    }
}
----

Root path is calculated automatically, not necessary to explicitly set.
// end::update_18_9[]

// tag::update_20_3[]
If you want any changes made to be rolled back at the end ofthe test you can use the `io.quarkus.test.TestTransaction` annotation.
// end::update_20_3[]

*QuarkusTestProfile*

// tag::update_18_5[]
You can define for each Test class a different configuration options.

IMPORTANT: This implies that the Quarkus service is restarted.

[source, java]
----
public class MyProfile implements io.quarkus.test.junit.QuarkusTestProfile {
    
    @Override
    public Map<String, String> getConfigOverrides() {
        return Map.of(""greetings.message"", ""This is a Test"");
    }

    @Override
    public String getConfigProfile() {
        return ""my-test-profile"";
    }

    @Override
    public Set<String> tags() {
        return Collections.singleton(""test1"");
    }
}

@QuarkusTest
@TestProfile(MyProfile.class)
public class MyTestClass {
}
----
// end::update_18_5[]

// tag::update_23_4[]
`quarkus.test.profile.tags` property can be set to limit test execution of test profiles.
If not set all tests are executed.

[source, properties]
----
quarkus.test.profile.tags=test1
----
// end::update_23_4[]

*Quarkus Test Resource*

// tag::update_4_2[]
You can execute some logic before the first test run (`start`) and execute some logic at the end of the test suite (`stop`).

You need to create a class implementing `QuarkusTestResourceLifecycleManager` interface and register it in the test via `@QuarkusTestResource` annotation.

[source, java]
----
public class MyCustomTestResource
    implements QuarkusTestResourceLifecycleManager {

    @Override
    public Map<String, String> start() {
        // return system properties that
        // should be set for the running test
        return Collections.emptyMap();
    }

    @Override
    public void stop() {
    }

    // optional
    @Override
    public void inject(Object testInstance) {
    }

    // optional
    @Override
    public int order() {
        return 0;
    }

    // optional
    @Override
    public void setContext(Context context) {
    }

    @Override
    public void inject(TestInjector testInjector) {
        testInjector.injectIntoFields(wireMockServer, 
            new TestInjector.AnnotatedAndMatchesType(InjectWireMock.class, WireMockServer.class));
    }
}

public class MyTest {
    @InjectWireMock
    WireMockServer wireMockServer;
}
----

IMPORTANT: Returning new system properties implies running parallel tests in different JVMs.

And the usage:

[source, java]
----
@QuarkusTestResource(MyCustomTestResource.class)
public class MyTest {
}
----

// tag::update_23_3[]
When using multiple `QuarkusTestResource` you can set `parallel` attribute to `true` to start them concurrently.
// end::update_23_3[]

*Testing Callbacks*

//tag::update_20_6[]
You can enrich *all* your `@QuarkusTest` classes by implementing the following callback interfaces:

* `io.quarkus.test.junit.callback.QuarkusTestBeforeClassCallback`
* `io.quarkus.test.junit.callback.QuarkusTestAfterConstructCallback`
* `io.quarkus.test.junit.callback.QuarkusTestBeforeEachCallback`
* `io.quarkus.test.junit.callback.QuarkusTestAfterEachCallback`

[source, java]
----
public class SimpleAnnotationCheckerBeforeClassCallback implements QuarkusTestBeforeClassCallback {
   @Override
    public void beforeClass(Class<?> testClass) {
    }
}
----

And needs to be registered as Java SPI:

[source]
.META-INF/services/io.quarkus.test.junit.callback.QuarkusTestBeforeClassCallback
----
io.quarkus.it.main.SimpleAnnotationCheckerBeforeClassCallback
----
//end::update_20_6[]

// end::update_4_2[]
*Mocking*

If you need to provide an alternative implementation of a service (for testing purposes) you can do it by using CDI `@Alternative` annotation using it in the test service placed at `src/test/java`:

[source, java]
----
@Alternative
@Priority(1)
@ApplicationScoped
public class MockExternalService extends ExternalService {}
----

IMPORTANT: This does not work when using native image testing.

// tag::update_3_6[]
A stereotype annotation `io.quarkus.test.Mock` is provided declaring `@Alternative`, `@Priority(1)` and `@Dependent`.
// end::update_3_6[]

*Mockito*

// tag::update_15_12[]
Instead of creating stubs, you can also create mocks of your services with mockito.
Add the following dependency `io.quarkus:quarkus-junit5-mockito`:

[source, java]
----
@InjectMock
GreetingService greetingService;

@BeforeEach
public void setup() {
    Mockito.when(greetingService.greet()).thenReturn(""Hi"");
}

@Path(""/hello"")
public class ExampleResource {

    @Inject
    GreetingService greetingService;
}
----

Mock is automatically injected and only valid for the defined test class.

`@InjectMock` has `convertScopes` parameter that if true, then Quarkus will change the scope of the target from `Singleton` bean to `ApplicationScoped` to make the mockable.

// tag::update_16_25[]
Also `spy` is supported:

[source, java]
----
@InjectSpy
GreetingService greetingService;

Mockito.verify(greetingService, Mockito.times(1)).greet();
----
// end::update_16_25[]

*REST Client*

To Mock REST Client, you need to define the interface with `@ApplicationScope`:

[source, java]
----
@ApplicationScoped
@RegisterRestClient
public interface GreetingService {
}

@InjectMock
@RestClient
GreetingService greetingService;

Mockito.when(greetingService.hello()).thenReturn(""hello from mockito"");
----

// end::update_15_12[]

*Interceptors*
// tag::update_5_5[]

Tests are actually full CDI beans, so you can apply CDI interceptors:

[source, java]
----
@QuarkusTest
@Stereotype
@Transactional
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface TransactionalQuarkusTest {
}

@TransactionalQuarkusTest
public class TestStereotypeTestCase {}
----
// end::update_5_5[]

*Decorator*

Quarkus also supports CDI Decorators:

[source, java]
----
@Priority(10)
@Decorator
public class LargeTxAccount implements Account {

   @Inject
   @Any
   @Delegate
   Account delegate;

   @Inject
   LogService logService;

   void withdraw(BigDecimal amount) {
      delegate.withdraw(amount);
      if (amount.compareTo(1000) > 0) {
         logService.logWithdrawal(delegate, amount);
      }
   }

}
----

*Test Coverage*

// tag::update_6_3[]
Due the nature of Quarkus to calculate correctly the coverage information with JaCoCo, you might need offline instrumentation.

[source, bash]
----
./mvnw quarkus:add-extension
  -Dextensions=""quarkus-jacoco ""
----

Possible configuration parameters prefixed `quarkus.jacoco`:

`data-file`::
The jacoco data file. (default: `jacoco-quarkus.exec`)

`report`::
If Quarkus should generate the Jacoco report. (default: `true`)

`output-encoding`::
Encoding of the generated reports. (default: `UTF-8`)

`title`::
Name of the root node HTML report pages.

`footer`::
Footer text used in HTML report pages.

`source-encoding`::
Encoding of the source files. (default: `UTF-8`)

`includes`::
A list of class files to include in the report. (default: `**`)

`excludes`::
A list of class files to exclude from the report.

`report-location`::
The location of the report files. (default: `jacoco-report`)
// end::update_6_3[]

*Native Testing*

To test native executables annotate the test with `@NativeImageTest`.

*Quarkus Integration Tests*

// tag::update_24_2[]
`@QuarkusIntegrationTest` should be used to launch and test the artifact produced by the Quarkus build.
If the result of a Quarkus build is a JAR then the app is launched as `java -jar`, if native is launched as `./application`, if container image is created (JiB, Docker extensions) is launched as `docker run`.

You can connect to already running application by using the following properties: `quarkus.http.test-host=1.2.3.4` `quarkus.http.test-port=4321`
// end::update_24_2[]
",12401,True,2539.3728812385557,median
"/*
// Copyright (c) 2017 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 <gtest/gtest.h>
#include ""api/CPP/memory.hpp""
#include <api/CPP/input_layout.hpp>
#include ""api/CPP/scale.hpp""
#include <api/CPP/topology.hpp>
#include <api/CPP/network.hpp>
#include <api/CPP/engine.hpp>
#include ""test_utils/test_utils.h""
#include ""api/CPP/reorder.hpp""

using namespace cldnn;
using namespace tests;

TEST(scale_gpu, basic_in2x3x2x2_scale_same_size) {
    //  Scale  : 2x3x2x2
    //  Input  : 2x3x2x2
    //  Output : 2x3x2x2

    //  Input:
    //  f0: b0:  1    2  -10   b1:   0    0    -11
    //  f0: b0:  3    4  -14   b1:   0.5 -0.5  -15  
    //  f1: b0:  5    6  -12   b1:   1.5  5.2  -13     
    //  f1: b0:  7    8  -16   b1:   12   8    -17
    //
    //  Scale:
    //  f0: b0:  0.1    0.2  0.25   b1:   0.3   0.4   0.5
    //  f0: b0:  0.6    0.7  0.75   b1:   0.8   0.9   1  
    //  f1: b0:  1.1    1.2  1.25   b1:   1.3   1.4   1.5     
    //  f1: b0:  1.6    1.7  1.75   b1:   1.8   1.9   2

    engine engine;

    auto input = memory::allocate(engine, { data_types::f32, format::yxfb, { 2, 2, 3, 2 } });
    auto scale_input = memory::allocate(engine, { data_types::f32, format::yxfb, { 2, 2, 3, 2 } });

    topology topology;
    topology.add(input_layout(""input"", input.get_layout()));
    topology.add(input_layout(""scale_input"", scale_input.get_layout()));
    topology.add(scale(""scale"", ""input"", ""scale_input""));

    std::vector<float> input_vec = { 1.f, 0.f, 5.f, 1.5f,
        2.f, 0.f, 6.f, 5.2f,
        -10.f, -11.f, -12.f, -13.f,
        3.f, 0.5f, 7.f, 12.f,
        4.f, -0.5f, 8.f, 8.f,
        -14.f, -15.f, -16.f, -17.f };
    set_values(input, input_vec);

    std::vector<float> scale_input_vec = {
        0.1f, 0.3f, 1.1f, 1.3f,
        0.2f, 0.4f, 1.2f, 1.4f,
        0.25f, 0.5f, 1.25f, 1.5f,
        0.6f, 0.8f, 1.6f, 1.8f,
        0.7f, 0.9f, 1.7f, 1.9f,
        0.75f, 1.f, 1.75f, 2.f
    };
    set_values(scale_input, scale_input_vec);

    network network(engine, topology);

    network.set_input_data(""input"", input);
    network.set_input_data(""scale_input"", scale_input);

    auto outputs = network.execute();

    auto output = outputs.at(""scale"").get_memory();
    auto output_ptr = output.pointer<float>();

    for (unsigned int i = 0; i < input_vec.size(); ++i) {
        EXPECT_NEAR(output_ptr[i], input_vec[i] * scale_input_vec[i], 1e-05F);
    }
}

TEST(scale_gpu, basic_in2x3x2x2_scale_same_size_bfyx) {
    //  Scale  : 2x3x2x2
    //  Input  : 2x3x2x2
    //  Output : 2x3x2x2

    //  Input:
    //  f0: b0:  1    2  -10   b1:   0    0    -11
    //  f0: b0:  3    4  -14   b1:   0.5 -0.5  -15  
    //  f1: b0:  5    6  -12   b1:   1.5  5.2  -13     
    //  f1: b0:  7    8  -16   b1:   12   8    -17
    //
    //  Scale:
    //  f0: b0:  0.1    0.2  0.25   b1:   0.3   0.4   0.5
    //  f0: b0:  0.6    0.7  0.75   b1:   0.8   0.9   1  
    //  f1: b0:  1.1    1.2  1.25   b1:   1.3   1.4   1.5     
    //  f1: b0:  1.6    1.7  1.75   b1:   1.8   1.9   2

    engine engine;

    auto input = memory::allocate(engine, { data_types::f32, format::bfyx, { 2, 2, 3, 2 } });
    auto scale_input = memory::allocate(engine, { data_types::f32, format::bfyx, { 2, 2, 3, 2 } });

    topology topology;
    topology.add(input_layout(""input"", input.get_layout()));
    topology.add(input_layout(""scale_input"", scale_input.get_layout()));
    topology.add(scale(""scale"", ""input"", ""scale_input""));

    std::vector<float> input_vec = {
        1.f, 2.f, -10.f, 0.f, 0.f, -11.f,
        3.f, 4.f, -14.f, 0.5f, -0.5f, -15.f,
        5.f, 6.f, -12.f, 1.5f, 5.2f, -13.f,
        7.f, 8.f, -16.f, 12.f, 8.f, -17.f
    };
    set_values(input, input_vec);

    std::vector<float> scale_input_vec = {
        0.1f, 0.2f, 0.25f, 0.3f, 0.4f, 0.5f,
        0.6f, 0.7f, 0.75f, 0.8f, 0.9f, 1.f,
        1.1f, 1.2f, 1.25f, 1.3f, 1.4f, 1.5f,
        1.6f, 1.7f, 1.75f, 1.8f, 1.9f, 2.f
    };
    set_values(scale_input, scale_input_vec);

    network network(engine, topology);

    network.set_input_data(""input"", input);
    network.set_input_data(""scale_input"", scale_input);

    auto outputs = network.execute();

    auto output = outputs.at(""scale"").get_memory();
    auto output_ptr = output.pointer<float>();

    for (unsigned int i = 0; i < input_vec.size(); ++i) {
        EXPECT_NEAR(output_ptr[i], input_vec[i] * scale_input_vec[i], 1e-05F);
    }
}

TEST(scale_gpu, basic_in2x3x2x2_scale_same_size_scale_bfyx) {
    //  Scale  : 2x3x2x2
    //  Input  : 2x3x2x2
    //  Output : 2x3x2x2

    //  Input:
    //  f0: b0:  1    2  -10   b1:   0    0    -11
    //  f0: b0:  3    4  -14   b1:   0.5 -0.5  -15  
    //  f1: b0:  5    6  -12   b1:   1.5  5.2  -13     
    //  f1: b0:  7    8  -16   b1:   12   8    -17
    //
    //  Scale:
    //  f0: b0:  0.1    0.2  0.25   b1:   0.3   0.4   0.5
    //  f0: b0:  0.6    0.7  0.75   b1:   0.8   0.9   1  
    //  f1: b0:  1.1    1.2  1.25   b1:   1.3   1.4   1.5     
    //  f1: b0:  1.6    1.7  1.75   b1:   1.8   1.9   2

    engine engine;

    auto batch_num = 2;
    auto feature_num = 2;
    auto x_size = 3;
    auto y_size = 2;

    auto input = memory::allocate(engine, { data_types::f32,format::yxfb,{ batch_num, feature_num, x_size, y_size } });
    auto scale_input = memory::allocate(engine, { data_types::f32, format::bfyx,{ batch_num, feature_num, x_size, y_size } });

    topology topology;
    topology.add(input_layout(""input"", input.get_layout()));
    topology.add(input_layout(""scale_input"", scale_input.get_layout()));
    topology.add(scale(""scale"", ""input"", ""scale_input""));

    std::vector<float> input_vec = { 1.f, 0.f, 5.f, 1.5f,
        2.f, 0.f, 6.f, 5.2f,
        -10.f, -11.f, -12.f, -13.f,
        3.f, 0.5f, 7.f, 12.f,
        4.f, -0.5f, 8.f, 8.f,
        -14.f, -15.f, -16.f, -17.f };
    set_values(input, input_vec);

    std::vector<float> scale_input_vec = {
        0.1f, 0.2f, 0.25f, 0.3f, 0.4f, 0.5f,
        0.6f, 0.7f, 0.75f, 0.8f, 0.9f, 1.f,
        1.1f, 1.2f, 1.25f, 1.3f, 1.4f, 1.5f,
        1.6f, 1.7f, 1.75f, 1.8f, 1.9f, 2.f
    };
    set_values(scale_input, scale_input_vec);

    network network(engine, topology);

    network.set_input_data(""input"", input);
    network.set_input_data(""scale_input"", scale_input);

    auto outputs = network.execute();

    auto output = outputs.at(""scale"").get_memory();
    auto output_ptr = output.pointer<float>();

    for (int j = 0; j < feature_num; ++j) { //F
        for (int i = 0; i < batch_num; ++i) { //B
            for (int k = 0; k < y_size; ++k) { //Y
                for (int l = 0; l < x_size; ++l) { //X
                    int linear_id = i + batch_num * (j + feature_num * (l + x_size * k));
                    int linear_id_scale = l + x_size * (k + y_size * (j + i * feature_num));
                    EXPECT_NEAR(output_ptr[linear_id], input_vec[linear_id] * scale_input_vec[linear_id_scale], 1e-05F);
                }
            }
        }
    }
}

TEST(scale_gpu, basic_in2x3x2x2_scale_same_size_bias_term) {
    //  Scale  : 2x3x2x2
    //  Bias   : 2x3x2x2
    //  Input  : 2x3x2x2
    //  Output : 2x3x2x2

    //  Input:
    //  f0: b0:  1    2  -10   b1:   0    0    -11
    //  f0: b0:  3    4  -14   b1:   0.5 -0.5  -15  
    //  f1: b0:  5    6  -12   b1:   1.5  5.2  -13     
    //  f1: b0:  7    8  -16   b1:   12   8    -17
    //
    //  Scale:
    //  f0: b0:  0.1    0.2  0.25   b1:   0.3   0.4   0.5
    //  f0: b0:  0.6    0.7  0.75   b1:   0.8   0.9   1  
    //  f1: b0:  1.1    1.2  1.25   b1:   1.3   1.4   1.5     
    //  f1: b0:  1.6    1.7  1.75   b1:   1.8   1.9   2
    //
    //  Bias:
    //  f0: b0:  1.1    1.2  1.25   b1:   1.3   1.4   1.5
    //  f0: b0:  2.6    2.7  2.75   b1:   2.8   2.9   2  
    //  f1: b0:  3.1    3.2  3.25   b1:   3.3   3.4   3.5     
    //  f1: b0:  4.6    4.7  4.75   b1:   4.8   4.9   4

    engine engine;

    auto input = memory::allocate(engine, { data_types::f32, format::yxfb, { 2, 2, 3, 2 } });
    auto scale_input = memory::allocate(engine, { data_types::f32, format::yxfb, { 2, 2, 3, 2 } });
    auto bias = memory::allocate(engine, { data_types::f32, format::yxfb, { 2, 2, 3, 2 } });

    topology topology;
    topology.add(input_layout(""input"", input.get_layout()));
    topology.add(input_layout(""scale_input"", scale_input.get_layout()));
    topology.add(input_layout(""bias"", bias.get_layout()));
    topology.add(scale(""scale"", ""input"", ""scale_input"", ""bias""));

    std::vector<float> input_vec = { 1.f, 0.f, 5.f, 1.5f,
        2.f, 0.f, 6.f, 5.2f,
        -10.f, -11.f, -12.f, -13.f,
        3.f, 0.5f, 7.f, 12.f,
        4.f, -0.5f, 8.f, 8.f,
        -14.f, -15.f, -16.f, -17.f };
    set_values(input, input_vec);

    std::vector<float> scale_input_vec = {
        0.1f, 0.3f, 1.1f, 1.3f,
        0.2f, 0.4f, 1.2f, 1.4f,
        0.25f, 0.5f, 1.25f, 1.5f,
        0.6f, 0.8f, 1.6f, 1.8f,
        0.7f, 0.9f, 1.7f, 1.9f,
        0.75f, 1.f, 1.75f, 2.f
    };
    set_values(scale_input, scale_input_vec);

    std::vector<float> bias_vec = {
        1.1f, 2.3f, 3.1f, 4.3f,
        1.2f, 2.4f, 3.2f, 4.4f,
        1.25f, 2.5f, 3.25f, 4.5f,
        1.6f, 2.8f, 3.6f, 4.8f,
        1.7f, 2.9f, 3.7f, 4.9f,
        1.75f, 2.f, 3.75f, 4.f
    };
    set_values(bias, bias_vec);

    network network(engine, topology);

    network.set_input_data(""input"", input);
    network.set_input_data(""scale_input"", scale_input);
    network.set_input_data(""bias"", bias);

    auto outputs = network.execute();

    auto output = outputs.at(""scale"").get_memory();
    auto output_ptr = output.pointer<float>();

    for (unsigned int i = 0; i < input_vec.size(); ++i) {
        EXPECT_NEAR(output_ptr[i], input_vec[i] * scale_input_vec[i] + bias_vec[i], 1e-05F);
    }
}

TEST(scale_gpu, basic_in2x3x2x2_scale_scalar) {
    //  Scale  : 1
    //  Input  : 2x3x2x2
    //  Output : 2x3x2x2

    //  Input:
    //  f0: b0:  1    2  -10   b1:   0    0    -11
    //  f0: b0:  3    4  -14   b1:   0.5 -0.5  -15  
    //  f1: b0:  5    6  -12   b1:   1.5  5.2  -13     
    //  f1: b0:  7    8  -16   b1:   12   8    -17
    //
    //  Scale:
    //  0.1    0.2

    engine engine;

    auto batch_num = 2;
    auto feature_num = 2;
    auto x_size = 3;
    auto y_size = 2;

    auto input = memory::allocate(engine, { data_types::f32,format::yxfb,{ batch_num, feature_num, x_size, y_size } });
    auto scale_input = memory::allocate(engine, { data_types::f32, format::yxfb, { 1, 1, 1, 1 } });

    topology topology;
    topology.add(input_layout(""input"", input.get_layout()));
    topology.add(input_layout(""scale_input"", scale_input.get_layout()));
    topology.add(scale(""scale"", ""input"", ""scale_input""));

    std::vector<float> input_vec = { 1.f, 0.f, 5.f, 1.5f,
        2.f, 0.f, 6.f, 5.2f,
        -10.f, -11.f, -12.f, -13.f,
        3.f, 0.5f, 7.f, 12.f,
        4.f, -0.5f, 8.f, 8.f,
        -14.f, -15.f, -16.f, -17.f };
    set_values(input, input_vec);

    std::vector<float> scale_input_vec = {
        0.1f,
    };
    set_values(scale_input, scale_input_vec);

    network network(engine, topology);

    network.set_input_data(""input"", input);
    network.set_input_data(""scale_input"", scale_input);

    auto outputs = network.execute();

    auto output = outputs.at(""scale"").get_memory();
    auto output_ptr = output.pointer<float>();

    for (int j = 0; j < feature_num; ++j) { //F
        for (int i = 0; i < batch_num; ++i) { //B
            for (int k = 0; k < y_size; ++k) { //Y
                for (int l = 0; l < x_size; ++l) { //X
                    int linear_id = i + batch_num * (j + feature_num * (l + x_size * k));
                    int linear_id_scale = 0;
                    EXPECT_NEAR(output_ptr[linear_id], input_vec[linear_id] * scale_input_vec[linear_id_scale], 1e-05F);
                }
            }
        }
    }
}

TEST(scale_gpu, basic_in2x3x2x2_scale_y) {
    //  Scale  : 2
    //  Input  : 2x3x2x2
    //  Output : 2x3x2x2

    //  Input:
    //  f0: b0:  1    2  -10   b1:   0    0    -11
    //  f0: b0:  3    4  -14   b1:   0.5 -0.5  -15  
    //  f1: b0:  5    6  -12   b1:   1.5  5.2  -13     
    //  f1: b0:  7    8  -16   b1:   12   8    -17
    //
    //  Scale:
    //  0.1    0.2

    engine engine;

    auto batch_num = 2;
    auto feature_num = 2;
    auto x_size = 3;
    auto y_size = 2;

    auto input = memory::allocate(engine, { data_types::f32,format::yxfb,{ batch_num, feature_num, x_size, y_size } });
    auto scale_input = memory::allocate(engine, { data_types::f32, format::yxfb,{ 1,1,1,y_size } });

    topology topology;
    topology.add(input_layout(""input"", input.get_layout()));
    topology.add(input_layout(""scale_input"", scale_input.get_layout()));
    topology.add(scale(""scale"", ""input"", ""scale_input""));

    std::vector<float> input_vec = { 1.f, 0.f, 5.f, 1.5f,
        2.f, 0.f, 6.f, 5.2f,
        -10.f, -11.f, -12.f, -13.f,
        3.f, 0.5f, 7.f, 12.f,
        4.f, -0.5f, 8.f, 8.f,
        -14.f, -15.f, -16.f, -17.f };
    set_values(input, input_vec);

    std::vector<float> scale_input_vec = {
        0.1f,
        0.2f,
    };
    set_values(scale_input, scale_input_vec);

    network network(engine, topology);

    network.set_input_data(""input"", input);
    network.set_input_data(""scale_input"", scale_input);

    auto outputs = network.execute();

    auto output = outputs.at(""scale"").get_memory();
    auto output_ptr = output.pointer<float>();

    for (int j = 0; j < feature_num; ++j) { //F
        for (int i = 0; i < batch_num; ++i) { //B
            for (int k = 0; k < y_size; ++k) { //Y
                for (int l = 0; l < x_size; ++l) { //X
                    int linear_id = i + batch_num * (j + feature_num * (l + x_size * k));
                    int linear_id_scale = k;
                    EXPECT_NEAR(output_ptr[linear_id], input_vec[linear_id] * scale_input_vec[linear_id_scale], 1e-05F);
                }
            }
        }
    }
}

TEST(scale_gpu, basic_in2x3x2x2_scale_x) {
    //  Scale  : 3
    //  Input  : 2x3x2x2
    //  Output : 2x3x2x2

    //  Input:
    //  f0: b0:  1    2  -10   b1:   0    0    -11
    //  f0: b0:  3    4  -14   b1:   0.5 -0.5  -15  
    //  f1: b0:  5    6  -12   b1:   1.5  5.2  -13     
    //  f1: b0:  7    8  -16   b1:   12   8    -17
    //
    //  Scale:
    //  0.1    0.2  0.25

    engine engine;

    auto batch_num = 2;
    auto feature_num = 2;
    auto x_size = 3;
    auto y_size = 2;

    auto input = memory::allocate(engine, { data_types::f32,format::yxfb,{ batch_num, feature_num, x_size, y_size } });
    auto scale_input = memory::allocate(engine, { data_types::f32, format::yxfb,{ 1, 1, x_size, 1 } });

    topology topology;
    topology.add(input_layout(""input"", input.get_layout()));
    topology.add(input_layout(""scale_input"", scale_input.get_layout()));
    topology.add(scale(""scale"", ""input"", ""scale_input""));

    std::vector<float> input_vec = { 1.f, 0.f, 5.f, 1.5f,
        2.f, 0.f, 6.f, 5.2f,
        -10.f, -11.f, -12.f, -13.f,
        3.f, 0.5f, 7.f, 12.f,
        4.f, -0.5f, 8.f, 8.f,
        -14.f, -15.f, -16.f, -17.f };
    set_values(input, input_vec);

    std::vector<float> scale_input_vec = {
        0.1f,
        0.2f,
        0.25f
    };
    set_values(scale_input, scale_input_vec);

    network network(engine, topology);

    network.set_input_data(""input"", input);
    network.set_input_data(""scale_input"", scale_input);

    auto outputs = network.execute();

    auto output = outputs.at(""scale"").get_memory();
    auto output_ptr = output.pointer<float>();

    for (int j = 0; j < feature_num; ++j) { //F
        for (int i = 0; i < batch_num; ++i) { //B
            for (int k = 0; k < y_size; ++k) { //Y
                for (int l = 0; l < x_size; ++l) { //X
                    int linear_id = i + batch_num * (j + feature_num * (l + x_size * k));
                    int linear_id_scale = l;
                    EXPECT_NEAR(output_ptr[linear_id], input_vec[linear_id] * scale_input_vec[linear_id_scale], 1e-05F);
                }
            }
        }
    }
}

TEST(scale_gpu, basic_in2x3x2x2_scale_xy) {
    //  Scale  : 2x3x1x1
    //  Input  : 2x3x2x2
    //  Output : 2x3x2x2

    //  Input:
    //  f0: b0:  1    2  -10   b1:   0    0    -11
    //  f0: b0:  3    4  -14   b1:   0.5 -0.5  -15  
    //  f1: b0:  5    6  -12   b1:   1.5  5.2  -13     
    //  f1: b0:  7    8  -16   b1:   12   8    -17
    //
    //  Scale:
    //  f0:  0.1    0.2  0.25
    //  f0:  0.6    0.7  0.75

    engine engine;

    auto batch_num = 2;
    auto feature_num = 2;
    auto x_size = 3;
    auto y_size = 2;

    auto input = memory::allocate(engine, { data_types::f32,format::yxfb,{ batch_num, feature_num, x_size, y_size } });
    auto scale_input = memory::allocate(engine, { data_types::f32, format::yxfb,{ 1, 1, x_size, y_size } });

    topology topology;
    topology.add(input_layout(""input"", input.get_layout()));
    topology.add(input_layout(""scale_input"", scale_input.get_layout()));
    topology.add(scale(""scale"", ""input"", ""scale_input""));

    std::vector<float> input_vec = { 1.f, 0.f, 5.f, 1.5f,
        2.f, 0.f, 6.f, 5.2f,
        -10.f, -11.f, -12.f, -13.f,
        3.f, 0.5f, 7.f, 12.f,
        4.f, -0.5f, 8.f, 8.f,
        -14.f, -15.f, -16.f, -17.f };
    set_values(input, input_vec);

    std::vector<float> scale_input_vec = {
        0.1f,
        0.2f,
        0.25f,
        0.6f,
        0.7f,
        0.75f
    };
    set_values(scale_input, scale_input_vec);

    network network(engine, topology);

    network.set_input_data(""input"", input);
    network.set_input_data(""scale_input"", scale_input);

    auto outputs = network.execute();

    auto output = outputs.at(""scale"").get_memory();
    auto output_ptr = output.pointer<float>();

    for (int j = 0; j < feature_num; ++j) { //F
        for (int i = 0; i < batch_num; ++i) { //B
            for (int k = 0; k < y_size; ++k) { //Y
                for (int l = 0; l < x_size; ++l) { //X
                    int linear_id = i + batch_num * (j + feature_num * (l + x_size * k));
                    int linear_id_scale = l + x_size * k;
                    EXPECT_NEAR(output_ptr[linear_id], input_vec[linear_id] * scale_input_vec[linear_id_scale], 1e-05F);
                }
            }
        }
    }
}

TEST(scale_gpu, basic_in2x3x2x2_scale_batch1) {
    //  Scale  : 2x3x2x1
    //  Input  : 2x3x2x2
    //  Output : 2x3x2x2

    //  Input:
    //  f0: b0:  1    2  -10   b1:   0    0    -11
    //  f0: b0:  3    4  -14   b1:   0.5 -0.5  -15  
    //  f1: b0:  5    6  -12   b1:   1.5  5.2  -13     
    //  f1: b0:  7    8  -16   b1:   12   8    -17
    //
    //  Scale:
    //  f0: b0:  0.1    0.2  0.25
    //  f0: b0:  0.6    0.7  0.75
    //  f1: b0:  1.1    1.2  1.25    
    //  f1: b0:  1.6    1.7  1.75

    engine engine;

    auto batch_num = 2;
    auto feature_num = 2;
    auto x_size = 3;
    auto y_size = 2;

    auto input = memory::allocate(engine, { data_types::f32,format::yxfb,{ batch_num, feature_num, x_size, y_size } });
    auto scale_input = memory::allocate(engine, { data_types::f32, format::yxfb,{ 1, feature_num, x_size, y_size } });

    topology topology;
    topology.add(input_layout(""input"", input.get_layout()));
    topology.add(input_layout(""scale_input"", scale_input.get_layout()));
    topology.add(scale(""scale"", ""input"", ""scale_input""));

    std::vector<float> input_vec = { 1.f, 0.f, 5.f, 1.5f,
        2.f, 0.f, 6.f, 5.2f,
        -10.f, -11.f, -12.f, -13.f,
        3.f, 0.5f, 7.f, 12.f,
        4.f, -0.5f, 8.f, 8.f,
        -14.f, -15.f, -16.f, -17.f };
    set_values(input, input_vec);

    std::vector<float> scale_input_vec = {
        0.1f, 1.1f,
        0.2f, 1.2f,
        0.25f, 1.25f,
        0.6f, 1.6f,
        0.7f, 1.7f,
        0.75f, 1.75f
    };
    set_values(scale_input, scale_input_vec);

    network network(engine, topology);

    network.set_input_data(""input"", input);
    network.set_input_data(""scale_input"", scale_input);

    auto outputs = network.execute();

    auto output = outputs.at(""scale"").get_memory();
    auto output_ptr = output.pointer<float>();

    for (int j = 0; j < feature_num; ++j) { //F
        for (int i = 0; i < batch_num; ++i) { //B
            for (int k = 0; k < y_size; ++k) { //Y
                for (int l = 0; l < x_size; ++l) { //X
                    int linear_id = i + batch_num * (j + feature_num * (l + x_size * k));
                    int linear_id_scale = j + feature_num * (l + x_size * k);
                    EXPECT_NEAR(output_ptr[linear_id], input_vec[linear_id] * scale_input_vec[linear_id_scale], 1e-05F);
                }
            }
        }
    }
}

TEST(scale_gpu, basic_in2x3_scale_same_size_bx) {
    //  Scale  : 2x3
    //  Bias   : 2x3
    //  Input  : 2x3
    //  Output : 2x3

    //  Input:
    //  b0:	1		2		-0.75
    //  b1: 0		-1.5	-3
    //
    //  Scale:
    //  b0: 3.1		0.2		0.17   
    //  b1: 10		-3		1

    //  Bias:
    //  b0: -0.1	3.2		7   
    //  b1: 0		1		-1

    engine engine;

    auto input = memory::allocate(engine, { data_types::f32, format::bfyx, { 2, 1, 3, 1 } });
    auto scale_input = memory::allocate(engine, { data_types::f32, format::bfyx, { 2, 1, 3, 1 } });
    auto bias_input = memory::allocate(engine, { data_types::f32, format::bfyx, { 2, 1, 3, 1 } });

	topology topology;
	topology.add(input_layout(""input"", input.get_layout()));
	topology.add(input_layout(""scale_input"", scale_input.get_layout()));
	topology.add(input_layout(""bias_input"", scale_input.get_layout()));
	topology.add(scale(""scale"", ""input"", ""scale_input"", ""bias_input""));

    std::vector<float> input_vec = {
        1.f, 2.f, -0.75f,
        0.f, -1.5f, -3.f,
    };
    set_values(input, input_vec);

    std::vector<float> scale_vec = {
        3.1f, 0.2f, 0.17f,
        10.f, -3.f, 1.f,
    };
    set_values(scale_input, scale_vec);

    std::vector<float> bias_vec = {
        -0.1f, 3.2f, 7.f,
        0.f, 1.f, -1.f,
    };
    set_values(bias_input, bias_vec);

    network network(engine, topology);

    network.set_input_data(""input"", input);
    network.set_input_data(""scale_input"", scale_input);
    network.set_input_data(""bias_input"", bias_input);

    auto outputs = network.execute();

    auto output = outputs.at(""scale"").get_memory();
    auto output_ptr = output.pointer<float>();

    for (unsigned int i = 0; i < input_vec.size(); ++i) {
        EXPECT_NEAR(output_ptr[i], input_vec[i] * scale_vec[i] + bias_vec[i], 1e-05F);
    }
}

TEST(scale_gpu, basic_in2x3_scale_same_size_xb) {
    //  Scale  : 2x3
    //  Bias   : 2x3
    //  Input  : 2x3
    //  Output : 2x3

    //  Input:
    //  x0:	1		2		-0.75
    //  x1: 0		-1.5	-3
    //
    //  Scale:
    //  x0: 3.1		0.2		0.17   
    //  x1: 10		-3		1

    //  Bias:
    //  x0: -0.1	3.2		7   
    //  x1: 0		1		-1

    engine engine;

    auto input = memory::allocate(engine, { data_types::f32, format::yxfb, { 3, 1, 2, 1 } });
    auto scale_input = memory::allocate(engine, { data_types::f32, format::yxfb, { 3, 1, 2, 1 } });
    auto bias_input = memory::allocate(engine, { data_types::f32, format::yxfb, { 3, 1, 2, 1 } });

	topology topology;
	topology.add(input_layout(""input"", input.get_layout()));
	topology.add(input_layout(""scale_input"", scale_input.get_layout()));
	topology.add(input_layout(""bias_input"", scale_input.get_layout()));
	topology.add(scale(""scale"", ""input"", ""scale_input"", ""bias_input""));

    std::vector<float> input_vec = {
        1.f, 2.f, -0.75f,
        0.f, -1.5f, -3.f,
    };
    set_values(input, input_vec);

    std::vector<float> scale_vec = {
        3.1f, 0.2f, 0.17f,
        10.f, -3.f, 1.f,
    };
    set_values(scale_input, scale_vec);

    std::vector<float> bias_vec = {
        -0.1f, 3.2f, 7.f,
        0.f, 1.f, -1.f,
    };
    set_values(bias_input, bias_vec);

    network network(engine, topology);

    network.set_input_data(""input"", input);
    network.set_input_data(""scale_input"", scale_input);
    network.set_input_data(""bias_input"", bias_input);

    auto outputs = network.execute();

    auto output = outputs.at(""scale"").get_memory();
    auto output_ptr = output.pointer<float>();

    for (unsigned int i = 0; i < input_vec.size(); ++i) {
        EXPECT_NEAR(output_ptr[i], input_vec[i] * scale_vec[i] + bias_vec[i], 1e-05F);
    }
}

TEST(scale_gpu, basic_in2x3_scale_single_value_bx) {
    //  Scale  : 1x1
    //  Bias   : 1x1
    //  Input  : 2x3
    //  Output : 2x3

    //  Input:
    //  b0:	1		2		-0.75
    //  b1: 0		-1.5	-3
    //
    //  Scale:
    //  3.1

    //  Bias:
    //  -0.1

    engine engine;

    auto input = memory::allocate(engine, { data_types::f32, format::bfyx, { 2, 1, 3, 1 } });
    auto scale_input = memory::allocate(engine, { data_types::f32, format::bfyx, { 1, 1, 1, 1 } });
    auto bias_input = memory::allocate(engine, { data_types::f32, format::bfyx, { 1, 1, 1, 1 } });

	topology topology;
	topology.add(input_layout(""input"", input.get_layout()));
	topology.add(input_layout(""scale_input"", scale_input.get_layout()));
	topology.add(input_layout(""bias_input"", scale_input.get_layout()));
	topology.add(scale(""scale"", ""input"", ""scale_input"", ""bias_input""));

    std::vector<float> input_vec = {
        1.f, 2.f, -0.75f,
        0.f, -1.5f, -3.f,
    };
    set_values(input, input_vec);

    std::vector<float> scale_vec = {
        3.1f,
    };
    set_values(scale_input, scale_vec);

    std::vector<float> bias_vec = {
        -0.1f,
    };
    set_values(bias_input, bias_vec);

    network network(engine, topology);

    network.set_input_data(""input"", input);
    network.set_input_data(""scale_input"", scale_input);
    network.set_input_data(""bias_input"", bias_input);

    auto outputs = network.execute();

    auto output = outputs.at(""scale"").get_memory();
    auto output_ptr = output.pointer<float>();

    for (unsigned int i = 0; i < input_vec.size(); ++i) {
        EXPECT_NEAR(output_ptr[i], input_vec[i] * scale_vec[0] + bias_vec[0], 1e-05F);
    }
}

TEST(scale_gpu, basic_in2x3_scale_single_value_xb) {
    //  Scale  : 1x1
    //  Bias   : 1x1
    //  Input  : 2x3
    //  Output : 2x3

    //  Input:
    //  x0:	1		2		-0.75
    //  x1: 0		-1.5	-3
    //
    //  Scale:
    //  3.1

    //  Bias:
    //  -0.1

    engine engine;

    auto input = memory::allocate(engine, { data_types::f32, format::yxfb, { 3, 1, 2, 1 } });
    auto scale_input = memory::allocate(engine, { data_types::f32, format::yxfb, { 1, 1, 1, 1 } });
    auto bias_input = memory::allocate(engine, { data_types::f32, format::yxfb, { 1, 1, 1, 1 } });

	topology topology;
	topology.add(input_layout(""input"", input.get_layout()));
	topology.add(input_layout(""scale_input"", scale_input.get_layout()));
	topology.add(input_layout(""bias_input"", scale_input.get_layout()));
	topology.add(scale(""scale"", ""input"", ""scale_input"", ""bias_input""));

    std::vector<float> input_vec = {
        1.f, 2.f, -0.75f,
        0.f, -1.5f, -3.f,
    };
    set_values(input, input_vec);

    std::vector<float> scale_vec = {
        3.1f,
    };
    set_values(scale_input, scale_vec);

    std::vector<float> bias_vec = {
        -0.1f,
    };
    set_values(bias_input, bias_vec);

    network network(engine, topology);

    network.set_input_data(""input"", input);
    network.set_input_data(""scale_input"", scale_input);
    network.set_input_data(""bias_input"", bias_input);

    auto outputs = network.execute();

    auto output = outputs.at(""scale"").get_memory();
    auto output_ptr = output.pointer<float>();

    for (unsigned int i = 0; i < input_vec.size(); ++i) {
        EXPECT_NEAR(output_ptr[i], input_vec[i] * scale_vec[0] + bias_vec[0], 1e-05F);
    }
}

TEST(scale_gpu, basic_in2x3_scale_same_size_no_bias_bx) {
    //  Scale  : 2x3
    //  Input  : 2x3
    //  Output : 2x3

    //  Input:
    //  b0:	1		2		-0.75
    //  b1: 0		-1.5	-3
    //
    //  Scale:
    //  b0: 3.1		0.2		0.17   
    //  b1: 10		-3		1

    engine engine;

    auto input = memory::allocate(engine, { data_types::f32, format::bfyx, { 2, 1, 3, 1 } });
    auto scale_input = memory::allocate(engine, { data_types::f32, format::bfyx, { 2, 1, 3, 1 } });

	topology topology;
	topology.add(input_layout(""input"", input.get_layout()));
	topology.add(input_layout(""scale_input"", scale_input.get_layout()));
	topology.add(scale(""scale"", ""input"", ""scale_input""));

    std::vector<float> input_vec = {
        1.f, 2.f, -0.75f,
        0.f, -1.5f, -3.f,
    };
    set_values(input, input_vec);

    std::vector<float> scale_vec = {
        3.1f, 0.2f, 0.17f,
        10.f, -3.f, 1.f,
    };
    set_values(scale_input, scale_vec);

    network network(engine, topology);

    network.set_input_data(""input"", input);
    network.set_input_data(""scale_input"", scale_input);

    auto outputs = network.execute();

    auto output = outputs.at(""scale"").get_memory();
    auto output_ptr = output.pointer<float>();

    for (unsigned int i = 0; i < input_vec.size(); ++i) {
        EXPECT_NEAR(output_ptr[i], input_vec[i] * scale_vec[i], 1e-05F);
    }
}

TEST(scale_gpu, basic_in2x3_scale_same_size_no_bias_xb) {
    //  Scale  : 2x3
    //  Input  : 2x3
    //  Output : 2x3

    //  Input:
    //  x0:	1		2		-0.75
    //  x1: 0		-1.5	-3
    //
    //  Scale:
    //  x0: 3.1		0.2		0.17   
    //  x1: 10		-3		1

    engine engine;

    auto input = memory::allocate(engine, { data_types::f32, format::yxfb, { 3, 1, 2, 1 } });
    auto scale_input = memory::allocate(engine, { data_types::f32, format::yxfb, { 3, 1, 2, 1 } });

	topology topology;
	topology.add(input_layout(""input"", input.get_layout()));
	topology.add(input_layout(""scale_input"", scale_input.get_layout()));
	topology.add(scale(""scale"", ""input"", ""scale_input""));

    std::vector<float> input_vec = {
        1.f, 2.f, -0.75f,
        0.f, -1.5f, -3.f,
    };
    set_values(input, input_vec);

    std::vector<float> scale_vec = {
        3.1f, 0.2f, 0.17f,
        10.f, -3.f, 1.f,
    };
    set_values(scale_input, scale_vec);

    network network(engine, topology);

    network.set_input_data(""input"", input);
    network.set_input_data(""scale_input"", scale_input);

    auto outputs = network.execute();

    auto output = outputs.at(""scale"").get_memory();
    auto output_ptr = output.pointer<float>();

    for (unsigned int i = 0; i < input_vec.size(); ++i) {
        EXPECT_NEAR(output_ptr[i], input_vec[i] * scale_vec[i], 1e-05F);
    }
}

TEST(scale_gpu, basic_in2x3x2x2_scale_yxfb_bfyx_same_size_padding) {
    //  Scale  : 2x2x1x1
    //  Input  : 2x2x1x1
    //  Output : 2x2x1x1
    //  Output Padding: 2x2
    //  Input Padding: 2x1 (with reorder)

    //  Input:
    //  1    2
    //  3    4

    //
    //  Scale:
    //  0.1    0.2
    //  0.6    0.5
     
    engine engine;
    std::vector<format> formats_to_test = { format::yxfb , format::bfyx };

    for (std::vector<format>::iterator it = formats_to_test.begin(); it != formats_to_test.end(); ++it)
    {
        std::cout << ""Testing format: "" << format::order(*it) << std::endl;

        tensor input_tensor(1, 1, 2, 2);

        auto input = memory::allocate(engine, { data_types::f32, *it, input_tensor });
        auto scale_input = memory::allocate(engine, { data_types::f32, *it, input_tensor });

        topology topology;
        topology.add(input_layout(""input"", input.get_layout()));
        topology.add(reorder(""reorder"", ""input"", input.get_layout().with_padding({ { 0, 0, 1, 2 }, 0 })));
        topology.add(input_layout(""scale_input"", scale_input.get_layout()));
        topology.add(scale(""scale"", ""reorder"", ""scale_input"", padding( { 0, 0, 2, 2 }, 0 )));

        std::vector<float> input_vec = { 1.f, 2.f, 3.f, 4.f };
        set_values(input, input_vec);

        std::vector<float> scale_input_vec = { 0.1f, 0.2f, 0.6f, 0.5f };
        set_values(scale_input, scale_input_vec);

        std::vector<float> expected = {
            0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
            0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
            0.f, 0.f, 0.1f, 0.4f, 0.f, 0.f,
            0.f, 0.f, 1.8f, 2.0f, 0.f, 0.f,
            0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
            0.f, 0.f, 0.f, 0.f, 0.f, 0.f,
        };

        network network(engine, topology);

        network.set_input_data(""input"", input);
        network.set_input_data(""scale_input"", scale_input);

        auto outputs = network.execute();

        auto output = outputs.at(""scale"").get_memory();
        auto output_ptr = output.pointer<float>();

        for (unsigned int i = 0; i < expected.size(); ++i) {
            EXPECT_NEAR(output_ptr[i], expected[i], 1e-05F);
        }
    }
}
//////////////////////////////////////////////////////////////////////////////
//                                                                          //
//                      Exhaustive Negative Matrix tests                    //
//                                                                          //
//////////////////////////////////////////////////////////////////////////////

//TODO: this should be done using TEST_P or some equivallent construct
static network setup_scale_network(
    const data_types dt,
    const tensor input_tensor,
    const tensor scale_tensor,
    const tensor bias_tensor,
    const format f,
    const format of,
    bool pass_bias          //TODO: a WA for lack of std::optional<tensor> bias
)
{
    engine engine;
    topology topology;

    auto input_mem = memory::allocate(engine, { dt, f, input_tensor });
    auto scale_mem = memory::allocate(engine, { dt, of, scale_tensor });
    topology.add(input_layout(""input"", input_mem.get_layout()));
    topology.add(input_layout(""scale_input"", scale_mem.get_layout()));

    if (pass_bias)
    {
        auto bias_mem = memory::allocate(engine, { dt, f, bias_tensor });
        topology.add(input_layout(""bias_input"", bias_mem.get_layout()));

        topology.add(scale(""scale"", ""input"", ""scale_input"", ""bias_input"" ));
    }
    else
    {
        topology.add(scale(""scale"", ""input"", ""scale_input""));
    }
//TODO: this will be supported after the API change
//    else
//    {
//        assert(!pass_bias);
//
//        topology.add(scale(""scale"", ""input"", ""scale_input""));
//    }

    return network(engine, topology);
}

TEST(NegativeScaleTest, TestAll) {
    auto d = data_types::f32;
    auto f = format::bfyx;
    auto of = format::yxfb;

    std::vector<int> t { 3, 4, 5, 6 };
    std::vector<int> t2 { 5, 6, 4, 3 };

    // broadcast rules mean that either the dim size is equal to input dim or is 1
    std::vector<std::vector<int>> good_ts =
    {
        { 1, 4, 5, 6 }, { 3, 1, 5, 6 }, { 3, 4, 1, 6 }, { 3, 4, 5, 1 },
        { 1, 1, 5, 6 }, { 1, 4, 1, 6 }, { 1, 4, 5, 1 }, { 3, 1, 1, 6 }, { 3, 1, 5, 1 }, { 3, 4, 1, 1 },
        { 1, 1, 1, 6 }, { 1, 1, 5, 1 }, { 1, 4, 1, 1 }, { 3, 1, 1, 1 }
    };
    std::vector<std::vector<int>> bad_ts = { { 2, 4, 5, 6 }, { 3, 2, 5, 6 }, { 3, 4, 2, 6 }, { 3, 4, 5, 2 } };

    //TODO: should be ASSERT_THROW(statement, exception_type) - but what exception type?
    ASSERT_ANY_THROW(setup_scale_network(d, { }, { }, { }, f, of, false));
    ASSERT_ANY_THROW(setup_scale_network(d, { }, { }, { }, f, of, true));

    ASSERT_ANY_THROW(setup_scale_network(d, tensor(t), tensor(t2), tensor(t), f, of, true));
    ASSERT_ANY_THROW(setup_scale_network(d, tensor(t), tensor(t2), tensor(t), f, of, false));

    // make sure that it's the input that's masked in the scale/bias with a ""1"", not ther other way around
    for (const auto & good : good_ts)
    {
        ASSERT_ANY_THROW(setup_scale_network(d, tensor(good), tensor(t), tensor(t), f, of, true));
    }

    // sizes must either be equal to input or at most have 
    for (const auto & bad : bad_ts)
    {
        ASSERT_ANY_THROW(setup_scale_network(d, tensor(t), tensor(bad), tensor(t), f, of, true));
        ASSERT_ANY_THROW(setup_scale_network(d, tensor(t), tensor(t), tensor(bad), f, of, true));

        for (const auto & good : good_ts)
        {
            ASSERT_ANY_THROW(setup_scale_network(d, tensor(t), tensor(bad), tensor(good), f, of, true));
            ASSERT_ANY_THROW(setup_scale_network(d, tensor(t), tensor(good), tensor(bad), f, of, true));
        }
    }

    // we expect the broadcast mask to be identical for scale and bias, when present
    for (unsigned i = 0; i < good_ts.size(); ++i)
    for (unsigned j = 0; j < good_ts.size(); ++j)
        if (i != j)
            ASSERT_ANY_THROW(setup_scale_network(d, tensor(t), tensor(good_ts[i]), tensor(good_ts[j]), f, of, true));

}

//////////////////////////////////////////////////////////////////////////////
//                                                                          //
//                      Exhaustive Positive Matrix tests                    //
//                                                                          //
//////////////////////////////////////////////////////////////////////////////

using namespace cldnn;

class scale_test : public tests::generic_test
{
public:
    static void TearDownTestCase()
    {
        all_generic_params.clear();
        all_layer_params.clear();
    }

    //TODO: use an enum instead of int i
    static std::vector<cldnn::primitive*> generate_specific_test_params(int variant)
    {
        std::vector<cldnn::primitive*> all_layer_params;

        switch(variant)
        {
            case 0: all_layer_params.push_back(new scale(""scale"", ""input0"", ""input1"")); break;
            case 1: all_layer_params.push_back(new scale(""scale"", ""input0"", ""input1"", ""input2"")); break;
                    //	case 3: all_layer_params.push_back(new scale(""scale"", ""input0"", ""input1"", true));	// This case should be checked by negative_scale_test
                    //	case 4: all_layer_params.push_back(new scale(""scale"", ""input0"", ""input1"", false));	// This case should be checked by negative_scale_test
            default: assert(0);
        }

        return all_layer_params;
    }

    static std::vector<tests::test_params*> generate_generic_test_params(int variant)
    {
        assert(!variant || variant == 1);

        std::vector<tests::test_params*> all_generic_params;

        for (cldnn::data_types dt : test_data_types)
        for (tensor & t : test_input_sizes)
        {
            std::vector<std::vector<int>> attempted_dims;

            for (int32_t b : test_batch_sizes)
            for (auto f : test_feature_sizes)
            for (int mask = 0; mask < 16; ++mask)	//TODO: do we want to restrict it to some smaller subset like for (auto mask : { 0, 1, 3, 7, 15, 5, 10})? the problem is that because of the layout we might miss some interesting combinations since this is effectively hardcoded int he kernels
            {
                const int w = t.spatial[0];
                const int h = t.spatial[1];

                const auto mb = mask & 0x8 ? b : 1;
                const auto mf = mask & 0x4 ? f : 1;
                const auto mh = mask & 0x2 ? h : 1;
                const auto mw = mask & 0x1 ? w : 1;

                // avoid adding test cases with different masks leading to the same dimensions
                if(attempted_dims.end() == std::find_if(attempted_dims.begin(), attempted_dims.end(), [=](const std::vector<int> & arr) { return arr[0] == mb && arr[1] == mf && arr[2] == mh && arr[3] == mw; }))
                {
                    std::vector<int> tmp { mb, mf, mh, mw };
                    attempted_dims.push_back(tmp);

                    test_params * tp = new test_params();
                    tp->data_type = dt;

                    tp->input_layouts.push_back( cldnn::tensor(  b, f, w, h  ));
                    tp->input_layouts.push_back( cldnn::tensor(  mb, mf, mw, mh  ));
                    if (variant)
                            tp->input_layouts.push_back( cldnn::tensor(  mb, mf, mw, mh  ));

                    all_generic_params.emplace_back(tp);
                }
            }
        }

        return all_generic_params;
    }

    static std::vector<std::tuple<test_params*, cldnn::primitive*>> generate_all_test_params()
    {
        std::vector<std::tuple<test_params*, cldnn::primitive*>> res;

        for (int variant = 0; variant <= 1; ++variant)
        {
            auto tpv = generate_generic_test_params(variant); 
            auto pv = generate_specific_test_params(variant);

            for (auto & tp : tpv)
                all_generic_params.emplace_back(tp);

            for (auto & p : pv)
                all_layer_params.emplace_back(p);

            for (auto & tp : tpv)
            for (auto & p: pv)
                res.emplace_back(tp, p);
        }

        return res;
    }

    virtual bool is_format_supported(cldnn::format format) override
    {
        return format == cldnn_format_type::cldnn_format_bfyx;
    }

    template<typename Type>
    memory generate_reference_typed(const std::vector<memory> & inputs)
    {
        assert(inputs.size() == 3 || inputs.size() == 2);
        const bool bias_input_present = inputs.size() == 3;

        const memory & input = inputs[0];
        const memory & scale = inputs[1];
        const memory * bias = bias_input_present ? &inputs[2] : nullptr;
        assert(!bias_input_present || bias);

        //Output is bfyx
        auto output = memory::allocate(engine, cldnn::layout(input.get_layout().data_type, cldnn::format::bfyx, input.get_layout().size ));

        const auto in0_mem = input.pointer<Type>();
        const auto in1_mem = scale.pointer<Type>();
        const auto in2_mem_ptr = bias ? std::make_shared<pointer<Type>>(*bias) : nullptr;
        const Type * const in2_mem = in2_mem_ptr ? in2_mem_ptr->data() : nullptr; //TODO: is the condition needed or is it nullptr anyway?
        auto out_mem = output.pointer<Type>();

        const int in0_b = input.get_layout().size.sizes()[0];
        const int in0_f = input.get_layout().size.sizes()[1];
        const int in0_h = input.get_layout().size.sizes()[2];
        const int in0_w = input.get_layout().size.sizes()[3];

        { // asserting dims
            const int out_b = output.get_layout().size.sizes()[0]; (void) out_b;
            const int out_f = output.get_layout().size.sizes()[1]; (void) out_f;
            const int out_h = output.get_layout().size.sizes()[2]; (void) out_h;
            const int out_w = output.get_layout().size.sizes()[3]; (void) out_w;

            const int in1_b = scale.get_layout().size.sizes()[0]; (void) in1_b;
            const int in1_f = scale.get_layout().size.sizes()[1]; (void) in1_f;
            const int in1_h = scale.get_layout().size.sizes()[2]; (void) in1_h;
            const int in1_w = scale.get_layout().size.sizes()[3]; (void) in1_w;
            // input and output dims must match
            assert(in0_b == out_b && in0_f == out_f && in0_h == out_h && in0_w == out_w);

            // input and output dims must match
            assert(in0_b == out_b && in0_f == out_f && in0_h == out_h && in0_w == out_w);

            // scale/bias dims must be equal to in/out or be 1 for broadcast
            assert(in1_b == 1 || in1_b == in0_b);
            assert(in1_f == 1 || in1_f == in0_f);
            assert(in1_h == 1 || in1_h == in0_h);
            assert(in1_w == 1 || in1_w == in0_w);

            if (bias)
            {
                const int in2_b = scale.get_layout().size.sizes()[0]; (void) in2_b;
                const int in2_f = scale.get_layout().size.sizes()[1]; (void) in2_f;
                const int in2_h = scale.get_layout().size.sizes()[2]; (void) in2_h;
                const int in2_w = scale.get_layout().size.sizes()[3]; (void) in2_w;

                // scale and bias dims must match
                assert(in1_b == in2_b && in1_f == in2_f && in1_h == in2_h && in1_w == in2_w);
            }
        }

        for (int n = 0; n < in0_b; ++n)
        for (int c = 0; c < in0_f; ++c)
        for (int y = 0; y < in0_h; ++y)
        for (int x = 0; x < in0_w; ++x)
        {
            const size_t in0_idx = get_linear_index(input.get_layout(), n, c, y, x);
            const size_t in1_idx = get_linear_index_with_broadcast(scale.get_layout(), n, c, y, x, input.get_layout());
            const size_t out_idx = get_linear_index(output.get_layout(), n, c, y, x);

            out_mem[out_idx] = in0_mem[in0_idx] * in1_mem[in1_idx];

            if (bias)
            {
                const size_t in2_idx = get_linear_index_with_broadcast(bias->get_layout(), n, c, y, x, input.get_layout());
                out_mem[out_idx] += in2_mem[in2_idx];
            }
        }

        return output;
    }

    virtual memory generate_reference(const std::vector<memory> & inputs) override
    {
        if (generic_params->data_type == data_types::f32)
        {
            return generate_reference_typed<float>(inputs);
        }
        else
        {
            return generate_reference_typed<FLOAT16>(inputs);
        }
    }

    static std::string custom_param_name(const ::testing::TestParamInfo<std::tuple<test_params*, cldnn::primitive*>>& info)
    {
        std::stringstream res;

        const auto & p = std::get<0>(info.param);

        assert (p->data_type == data_types::f32 ||
                p->data_type == data_types::f16);

        res << info.index
            << ""_"" << (p->data_type == data_types::f32 ? ""f32"" : ""f16"");

        for (unsigned i = 0; i < p->input_layouts.size(); ++i)
        {
            if (i == 0) res << ""_Input"";
            if (i == 1) res << ""_ScaleInput"";
            if (i == 2) res << ""_BiasInput"";

            const auto chans = format::traits(p->fmt).order;

            for (unsigned int j = 0; j < p->input_layouts[i].sizes(p->fmt).size(); ++j)
            {
                res << chans[j] << p->input_layouts[i].sizes(p->fmt)[j];
            }
        }
        return res.str();
    }

private:
    static std::vector<std::unique_ptr<tests::test_params>> all_generic_params;
    static std::vector<std::unique_ptr<cldnn::primitive>> all_layer_params;
};

std::vector<std::unique_ptr<cldnn::primitive>> scale_test::all_layer_params = {};
std::vector<std::unique_ptr<tests::test_params>> scale_test::all_generic_params = {};

TEST_P(scale_test, DISABLED_TestAll)
{
    run_single_test();
}

INSTANTIATE_TEST_CASE_P(SCALE,
    scale_test,
    ::testing::ValuesIn(scale_test::generate_all_test_params()),
    scale_test::custom_param_name);
",16199,True,3392.0263743131186,median
"= TAble - Developer Guide
:site-section: DeveloperGuide
: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/AY1920-CS2103-W15-3/main/master

By: `AY1920-CS2103-W15-3`      Since: `Apr 2020`      Licence: `MIT`

== Setting up

Refer to the guide <<SettingUp#, here>>.

== Design

[[Design-Architecture]]
=== Architecture

.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/address/Main.java[`Main`] and 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.

<<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

.Structure of the UI Component
image::UiClassDiagram.png[]

*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`, `StudentListPanel`, `ConsultListPanel`, `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/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.
* Listens for changes to `Model` data so that the UI can be updated with the modified data.

[[Design-Logic]]
=== Logic component

[[fig-LogicClassDiagram]]
.Structure of the Logic Component
image::LogicClassDiagram.png[]

*API* :
link:{repoURL}/src/main/java/seedu/address/logic/Logic.java[`Logic.java`]

.  `Logic` uses the `TAbleParser` 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 student).
.  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.

[[Design-Model]]
=== Model component

.Structure of the Model Component
image::ModelClassDiagram.png[]

*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 data of Students, and other data sources named as `{component}TAble` e.g. `ModTAble`.
* exposes an unmodifiable `ObservableList<Student>` 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

.Structure of the Storage Component
image::StorageClassDiagram.png[]

*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 TAble data in json format and read it back.

[[Design-Commons]]
=== Common classes

Classes used by multiple components are in the `seedu.address.commons` package.

== Implementation

This section describes some noteworthy details on how certain features are implemented.

// tag::module[]
=== Module feature (Written by Nigel Neo)
*TAble* allows NUS SoC teaching assistants to track and record all modules that they are teaching. Users can leave notes on the modules that they are teaching and store a list of links for the module that are useful for reference.

==== Implementation
A module can be stored as a Mod object in TAble (renamed due to naming restrictions on Java keywords). The main components are the module code, which is used to identify unique modules, and module name. Mod can also store the user's notes of the module through its description parameter, as well as a list of module links which are relevant to the course.

.Class diagram of 'Mod' feature, displaying only directly related classes
image::ModClassDiagram.png[]

The following sequence diagram shows how notes of a module can be updated with the `noteMod` command. Each command is parsed into a ModCode object and the note stored as string. The ModCode is then used to retrieve the appropriate Mod object in `model`. Next, this is used in the Mod constructor to come up with a new Mod with the given note. This new Mod replaces the original Mod in model and the command returns a string indicating success.

.Sequence diagram of updating Mod notes
image::NoteModSequenceDiagram.png[]

Module links are stored as ModLink objects in TAble. The collection of ModLinks are stored as `List<ModLinkPair>` (where a ModLinkPair is actually a class wrapper for a Pair<String, ModLink> object) since each module link can be described differently. This allows for more flexibility in naming the module links, rather than solely using an index based notation, and ensures that the order of addition into the collection is maintained. The activity diagram of adding module links is shown below.

.Activity diagram of adding ModLinks to Mod
image::AddModLinkActivityDiagram.png[]

Users can then view the information associated with a Mod object by using the `viewModInfo` command, and copy module links with the `copyModLink` command. Discussion on the copyModLink command is shown below.

==== Design Considerations

===== Unable to delete module with associated tutorials

[width=""100%"", cols=""1, 5, 5""]
|===
||*Alternative 1: (Current Choice)* Disable deletion of module with associated tutorials
|*Alternative 2 :* Delete module together with its associated tutorials

|*Pros*
|Informs user if there are any dependencies between module to be deleted and tutorials in TAble.
|Fast deletion of module and related objects.

|*Cons*
|User needs to individually delete associated tutorials before module can be deleted.
|Information in TAble will be lost easily as user may not be aware of such an association. As there is no undo command, it will not be easy to undo this command and revert TAble to its original state.
|===

Reason for choosing Alternative 1: On a user design perspective, it is not advisable to delete all objects associated with module, as the user may be unaware of these associated objects. By individually confirming the objects to be deleted, the user is made more aware of any information that they may want to export or save first before deleting said information.

===== ModLink behaviour

[width=""100%"", cols=""1, 5, 5""]
|===
||*Alternative 1: (Current Choice)* Copy link into user's clipboard
|*Alternative 2 :* Open a new browser page

|*Pros*
|Allows for easier access and sharing of link.
|Fast access to module's weblink by directly opening a browser.

|*Cons*
| User needs to open a browser before accessing link.
| Very distracting when opening link, as focus changes from TAble to browser unexpectedly (depending on when browser loads).
|===

Reason for choosing Alternative 1: On a user design perspective, it is less jarring to copy link into the user's clipboard, since the user can choose when they want to access the link and have the flexibility to share the link to others. Additionally, opening a new browser page requires more complicated code that depends on another program.

// end::module[]

// tag::tutorial[]

=== Tutorial feature (Written by Sarah Lim)
*TAble* allows NUS teaching assistants to track and record all the tutorials they are teaching, and maintain details of the tutorial, such as the module it is under, start and end time of the tutorial, and the location it is held.
Tutorials in *TAble* also allow teaching assistants to enroll students in a tutorial and mark their attendance for every week of the semester, and allows for convenient referencing (particularly when there's a pandemic and contact tracing is critical).

==== Implementation
Since a `Tutorial` in *TAble* has to manage many parameters and attributes, different components of *TAble* were distinctly separated in order to ensure maintainability and adhere to good coding practices.
The following illustrates the sequence diagram for AddTutorialCommand, in which a tutorial is added to *TAble*.

.Sequence diagram for the command to add a tutorial
image::TutorialCommandSequenceDiagram.png[]

The `LogicManager` is responsible for handling the execution of the user's input command to add a tutorial, calling `parseCommand()`, which returns an `AddTutorialCommand` object
and subsequently calls for the `AddTutorialCommand` object to perform `execute()`. This leads to the `Model` being updated accordingly,
and feedback in the form of a formatted String is finally shown to the user after being returned from `AddTutorialCommand`.

As can be observed, each step of the process is clearly separated, with each component only responsible for single task (eg. parsing user input, executing the actual command etc.)
This enables bugs to be easily caught, and for the process to be structured and comprehensible.

==== Design Considerations
As a `Tutorial` in TAble should be able to keep track of enrolled students and mark their attendance, the `Tutorial` object will have to contain a list of `Student` objects (ie. the enrolled students).
However, a `Student` object, as we are implementing it, does not contain the attribute of whether they are present or not for a particular `tutorial`.

[width=""100%"", cols=""1, 5, 5""]
|===
||*Alternative 1:* Include an attendance attribute to each `Student` such that they keep track of their own attendance for every tutorial they are enrolled in.
|*Alternative 2 : (Current Choice)* Each `Tutorial` contains an attendance sheet, comprised of a list of 11 nested lists of booleans. Each nested list represents each week of a typical NUS school semester, while the size in each of the nested lists corresponds to the number of enrolled students.

|*Pros*
|Efficient to mark the attendance of just a single student, and retrieve all attendance information of a particular `Student`.
|Efficient to mark the attendance of all students in a given tutorial as the whole attendance sheet is stored in `Tutorial`.

|*Cons*
|Difficult to mark attendance of all students in a tutorial as the system will have to individually search and modify the correct boolean in each `Student` in the tutorial.
|Difficult to mark attendance by student instead of tutorial, and inefficient in retrieving attendance information for a particular student as the system will have to iterate through every tutorial that the student is enrolled in.
|===

Reason for choosing Alternative 2:  From a user design perspective, it is more likely that a teaching assistant will want to mark his attendance by tutorial and week rather than by student, hence it is more practical and efficient to choose Alternative 2.
From a software engineering perspective, it is the responsibility of the `Tutorial` to keep track of the attendance, not the `Student` 's.
This allows attendance of a `Student` to be easily referenced and marked in a `Tutorial` without requiring the `Student` to be privy to that information, and allows for convenient retrieval of attendance by week or by student.

As such, the following activity diagram of the system illustrates what occurs when the user calls the markPresent command to mark a student in a tutorial as present, for a specified week in the school semester.

.Activity diagram for the command markPresent in the tutorial feature
image::TutorialMarkPresentActivityDiagram.png[]

When executing the markPresent command, the system will first ensure that all prefixes are present and formatted correctly, before subsequently checking if the specified tutorial exists in the TAble database.
If the tutorial does exist, then the system attempts to retrieve and update the attendance of the respective student in the tutorial. If the student does not exist, an error message is shown, informing the user.
If successful, the updated information is then saved.

// end::tutorial[]

// tag::consult[]
=== Consult feature (Written by Han Ching)
*TAble* allows NUS SoC teaching assistants to track and record all their consultations scheduled with their students.

==== Implementation
A `Consult` class stores all of the relevant information of consults. The class diagram below shows how all the different components interact to allow the consult feature to function. Note that the XYZConsultCommand and XYZConsultCommandParser refers to all Consult related commands like add, edit, delete etc.

.Class diagram of 'Consults' feature
image::ConsultsCommandClassDiagram.png[]

A consultation slot is represented by the `Consult` class which contains 5 key attributes, the `beginDateTime`, `endDateTime`, `location`, `studentMatricNumber` and `studentName`.
The `beginDateTime` and `endDateTime` attributes are represented using Java's `LocalDateTime` class. The `studentMatricNumber` and `studentName` attributes are classes that belong to a certain `Student`. The `studentMatricNumber` is used to uniquely identify the `Student` involved in the consultation, while the studentName is used in the front end of the application, displayed to the TA.

The `XYZConsultCommand` class represent classes that extend the abstract class `Command` and allows the TA to add, edit, delete, view and clear consultations added to TAble. These `XYZConsultCommandS` are created by the respective `XYZConsultCommandParserS`.

A `ConsultTAble` that has a `UniqueConsultList` stores and manages all `ConsultS`. When a `Consult` is added to the ConsultTAble, there will first be a check that the `Consult` does not already exist in the `UniqueConsultList`.

Given the class diagram and the understanding of how the `Consult` class interacts with other classes, let us examine how an `addConsult` command behaves, by using the following activity diagram of the system.

.Activity diagram for the command addConsult in the `Consult` feature
image::AddConsultActivityDiagram.png[]

The workflow above shows how a `Consult` is added and the various checks that occurs at the different points throughout the workflow.

To summarize the above activity diagram, there are 5 key checks which TAble checks for when the user is adding a `consult`. Firstly, TAble checks if all 4 prefixes are present in the command.
Then, TAble checks if all prefixes present are formatted correctly. Following which, TAble will check if each of the data passed for the prefixes are in the right format. Firstly, it checks if
the `Student` index provided is within the range of the `Student` list. Then, it checks if the timing and `Location` provided are in the correct format. Lastly, and most importantly, it checks if the
`Consult` timing provided clashes with other existing `Consult` timings.

==== Design Considerations

===== Consult storing Matric Number and Name

[width=""100%"", cols=""1, 5, 5""]
|===
||*Alternative 1 (Current Choice):* Make the consult store the matric number and name of the student that is attending the consult.
|*Alternative 2 :* Make the consult store the entire Student class that is attending the consult.

|*Pros*
|It is easier to implement and coupling will be reduced as `Student` will not be directly related to the `consult` class.
|It is easier to visualise as the entire `Student` related to the `consult` will be stored.

|*Cons*
|It is not as intuitive as currently, the `Consult` class only stores certain attributes of the `Student` that is attending the `consult`.
|It will be harder to test due to the high degree of coupling.
|===

Reason for choosing Alternative 1: Due to the time constraint of this project, our group has decided to choose alternative 1, as it not only reduces coupling, but is sufficient for us to uniquely identify the `Student` participating in the `consult` as the `MatricNumber` would be unique.

===== Sorting the consults

[width=""100%"", cols=""1, 5, 5""]
|===
||*Alternative 1 (Current Choice):* Automatically sorts the consult list by the time of the consult, whenever a consult is added
|*Alternative 2 :* Sorts the consult list only when user enters a sort command

|*Pros*
|It is intuitive for the consult list to be sorted according to their date and time.
|User can decide how they want the list to be sorted (e.g. by alphabetical order for location).

|*Cons*
|User are not able to sort the list according to their preferences.
|User have to type the sort command each time a new consult is added.
|===

Reason for choosing Alternative 1:  We believe that automatically sorting the consult list provides  a better user experience as the user can immediately see the upcoming consults in the panel, without having to type a sort command.
// end::consult[]

// tag::reminder[]
=== Reminder feature (Written by Cranston Yeo)
*TAble* allows NUS SoC teaching assistants to create reminders to help them in keeping track of their ongoing or upcoming tasks.

==== Implementation
A reminder is made up of a description, date and time which uniquely identify each reminder. Each reminder has a boolean attribute to indicate if the task is done.

To find a reminder in the reminder list, user must key in at least one of the optional predicates, `DescriptionContainsKeywordsPredicate` or `DatePredicate`. `DescriptionContainsKeywordsPredicate` contains a list of strings entered by the user while `DatePredicate` contains the input `LocalDate`.

The list of strings are matched against the description of the reminders in the reminder list while the `LocalDate` is matched against the date field. The reminder list is then updated with the list of matching reminders via `updatedFilteredReminderList` in `Model`. Below shows a sequence diagram of the execution.

.Sequence diagram for finding reminders
image::FindReminderSequenceDiagram.png[]

A snooze reminder feature is also implemented for the users to easily postpone a reminder. It's implementation is similar to the `editReminderCommand` where it creates a new reminder to replace the specified reminder instead of editing the current reminder directly. This is to ensure the reminders are immutable which improves the stability of the application.

User can choose to snooze the reminder in any/all of the following time units: days, hours and/or minutes. Only positive integer are allowed as the user are not supposed to snooze the reminders backwards or snooze it by zero duration. Reminders that are done are also not allowed to be snoozed. Following is an activity diagram for the command.

.Activity diagram for the command snoozeReminder in the reminder feature
image::SnoozeReminderActivityDiagram.png[]

==== Design Considerations

===== Sorting the reminders

[width=""100%"", cols=""1, 5, 5""]
|===
||*Alternative 1 (Current Choice):* Automatically sorts the reminder list whenever a reminder is added
|*Alternative 2 :* Sorts the reminder list only when user enters a sort command

|*Pros*
|It is intuitive for the reminder list to be sorted according to their done status and deadline.
|User can decide how they want the list to be sorted (e.g. in alphabetical order).

|*Cons*
|User are not able to sort the list according to their preferences.
|User have to type the sort command each time a new task is added.
|===

Reason for choosing Alternative 1:  We believe that automatically sorting the list provide with a better user experience as they could immediately see the most urgent tasks in the reminder's list upon startup without first typing a sort command.

===== Ways to inform user about their upcoming tasks

[width=""100%"", cols=""1, 5, 5""]
|===
||*Alternative 1: (Current Choice)* Each reminder displays the duration left before the task is due
|*Alternative 2 :* A pop-up notification when a reminder is due or about to due

|*Pros*
| User could see clearly the duration left for each task at a glance.
| User are notified of upcoming tasks without having to look through the list of reminders.

|*Cons*
| Reminders that are about to due could be missed out.
| Multiple pop-up notifications from the reminders could cause annoyance for the user.
|===

Reason for choosing Alternative 1: Pop-up notifications can be intrusive and potentially cause lag to the program which negatively impacts user's experience.
Furthermore, they are hard to test due to their volatile nature and including them might decrease the stability of the application.
// end::reminder[]

// tag::calendar[]
=== Calendar feature (Written by Han Ching)
*TAble* allows NUS SoC teaching assistants to bring up a calendar view of all their upcoming consults, tutorials and reminders.

==== Implementation
The key command which users can call is the `viewCalendar` command.

Most functions to display the calendar window are called within the `CalendarWindow` class, as it is the main class that drives the calendar view.
The `CalendarWindow` class extends `UiPart<Stage>`, and represents the calendar using a `GridPane` as the skeleton of the calendar, with individual dates being populated by a `CalendarDay` class which extends `UiPart<Region>`.
The `CalendarDay` has a `StackPane` that displays the number of `ConsultS`, `TutorialS` and `ReminderS` each day.

The following sequence diagram demonstrates how the Calendar is initialised, each time the TAble app is set up.

.Sequence diagram of creation of Calendar
image::CalendarWindowSequenceDiagram.png[]

The above sequence diagram illustrates how the Calendar is initialised when the TAble app is start up. Thus, whenever the user inputs the `viewCalendar` command,
this calendar window is brought up, similar to how the Help window is brought up as well. The calendar window brought up will show the calendar view of the current month and year.

The calendar window also stores the `UniqueConsultList`, `UniqueTutorialList` and the `UniqueReminderList`. As seen in the sequence diagram above, the calendar window checks for the consults, tutorials and reminders in the 3 lists, to see if they are on a particular date.
If they occur on that date, the `StackPane` in `CalendarDay` will be updated to reflect the corresponding number of consults, tutorials and reminders.
As seen in the screenshot below, the number of reminders, tutorials and consults will not clash, as they take up the top, middle and bottom rows respectively.

.Screenshot of how the number of reminders, tutorials and consults are displayed on the same day
image::CalendarReminderTutConsult.png[]

==== Design Considerations

===== Displaying calendar as a separate window

[width=""100%"", cols=""1, 5, 5""]
|===
||*Alternative 1 (Current Choice):* Displaying the calendar view as a separate window.
|*Alternative 2 :* Having a calendar view permanently by the side of TAble.

|*Pros*
|It is clearer and less visually clunky for the user, as information overload is prevented.
|It is more intuitive, as the user can always view the calendar at the side for his upcoming schedules.

|*Cons*
|Lower user experience as the user has to type in a command to view the calendar.
|The UI may be too cluttered as there are already alot of information being displayed currently.
|===

Reason for choosing Alternative 1:  We believe that our current implementation of the UI has all of TAble's core features, and the calendar view can and should
be implemented as a separate window to prevent visual clutter. The command to view the calendar window command is also short and intuitive to remember, thus the user experience
would likely not be significantly affected.

// end::calendar[]

=== Common Design Considerations

==== Length of command prefixes (For all features)

[width=""100%"", cols=""1, 5, 5""]
|===
||*Alternative 1 (Current Choice):* Make the prefixes of the command descriptive, such as `student/`.
|*Alternative 2 :* Make the prefixes of the commands short, by using the first few letters of the command word, such as `s/` for students.

|*Pros*
|It is more clear and intuitive for the user to type in the full prefix.
|It is easier for the user to type in shorter command prefixes, so that it is less tedious to input the commands.

|*Cons*
|Lower user experience as the user has to type in longer commands to use the TAble application.
|It may be confusing for the user, as certain command prefixes may share similar initials, such as `tags` and `time`.
|===

Reason for choosing Alternative 1:  We believe that the user experience will be better when using more descriptive command prefixes, as the user will not be required to constantly check on the user guide since the command prefixes are intuitive. Furthermore, TAble comes with the autocomplete feature which removes the hassle of typing out long prefixes.

=== 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*:

* Is a NUS SoC Teaching Assistant
* Prefers desktop apps over other types
* Can type fast
* Prefers typing over mouse input
* Is reasonably comfortable using CLI apps

*Value proposition*: Manage students faster than a typical mouse/GUI driven app

[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...

|`* * *` |teaching assistant |add a new student |track all my students in a list

|`* * *` |teaching assistant |delete a student |remove students that have changed classes

|`* * *` |teaching assistant |find a student by name |locate details of students without having to go through the entire list

|`* * *` |teaching assistant |add consult timing and locations |keep track of all new consults promptly

|`* * *` |teaching assistant |edit consult timing and locations |change consults when the students have to reschedule

|`* * *` |teaching assistant |delete consults |remove consults that are cancelled

|`* * *` |teaching assistant |list consults |track all consults that I have

|`* * *` |teaching assistant |add a new tutorial slot| track what tutorials I am teaching

|`* * *` |teaching assistant |delete a new tutorial slot| remove tutorials I have mistakenly added

|`* * *` |teaching assistant |view all tutorial slots I am teaching| track my tutorials and their respective details (eg. time and place)

|`* * *` |teaching assistant |enroll a student in my tutorial| track the students in my tutorial

|`* * *` |teaching assistant |remove a student from my tutorial| remove mistakenly added students or those who dropped the module

|`* * *` |teaching assistant |mark students in my tutorial as absent or present| record attendance of my students

|`* * *` |teaching assistant |view attendance sheet for my tutorial| track attendance of my students

|`* *` |teaching assistant |easily copy all students' emails from a tutorial group onto my clipboard| mass email my students quickly

|`* *` |teaching assistant |find consults based on the date or place |easily locate my consults without having to go through the entire list

|`* *` |teaching assistant |set a reminder |easily keep track and remember my tasks

|`* *` |teaching assistant |edit a reminder |change the description of my reminder

|`* *` |teaching assistant |mark a reminder as done |know which task is completed

|`* *` |teaching assistant |delete reminders |remove reminders that are done

|`* *` |teaching assistant |list reminders |track all tasks that I have

|`* *` |teaching assistant |find reminders based on the description or due date |easily locate my tasks without having to go through the entire list

|`* *` |teaching assistant |snooze a reminder |easily postpone a task

|`* * *` |teaching assistant |find a module |retrieve information on it

|`* * *` |teaching assistant |view module links |quickly access module resources

|`* * *` |teaching assistant |add module links |update module resources

|`* * *` |teaching assistant |have a calendar view |track all of my consults, tutorials and reminders in a single calendar window

|`* *` |teaching assistant |easily input my last entered command |be more productive by entering repetitive commands quickly

|`* *` |teaching assistant |get suggestions and autocomplete my input |easily enter commands without having to type out each prefix

|`* *` |new user |see usage instructions |refer to instructions when I forget how to use the App


|=======================================================================


[appendix]
== Use Cases

(For all use cases below, the *System* is the `TAble Application` and the *Actor* is the `user`, unless specified otherwise)

[discrete]
=== Use case: Delete student (U01)

*MSS*

1.  User requests to list student
2.  System shows a list of students
3.  User requests to delete a specific student in the list
4.  System deletes the student
+
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: Add consult (U02)

*MSS*

1.  User requests to add consult with student, date, time and location of consult included
2.  System saves the new consult into the database
+
Use case ends.

*Extensions*

[none]
* 1a. The student, date, time or location of consult is not included.
+
[none]
** 1a1. System shows an error message that student, date, time and location must all be included.
+
Use case ends.

// tag::hc[]

[discrete]
=== Use case: Edit consult (U03)

*MSS*

1.  User requests to update either the time, date or place of an existing consult
2.  System updates the existing consult according to the User's request
+
Use case ends.

*Extensions*

[none]
* 1a. The consult does not exist.
+
[none]
** 1a1. System shows an error message that the consult does not exist.
+
Use case ends.
[none]
* 1b. The time, date or place provided is in the wrong format.
+
[none]
** 1b1. System shows an error message that time, date or place must be provided in the correct format.
+
Use case ends.

[discrete]
=== Use case: Delete consult (U04)

*MSS*

1.  User requests to delete an existing consult
2.  System removes the existing consult from the database
+
Use case ends.

*Extensions*

[none]
* 1a. The consult does not exist.
+
[none]
** 1a1. System shows an error message that the consult does not exist.
+
Use case ends.
[none]
* 1b. The user enters the delete consult command in the wrong format.
+
[none]
** 1b1. System shows an error message that the wrong delete consult command format was given.
+
Use case ends.
// end::hc[]

[discrete]
=== Use case: List consults (U05)

*MSS*

1.  User requests to list all existing consults
2.  System brings up the panel that stores all of the existing consults in the database
+
Use case ends.

*Extensions*

[none]
* 2a. The list is empty.
+
Use case ends.

// tag::sarah[]
[discrete]
=== Use case: Add tutorial (U06)

*MSS*

1. User requests to add tutorial
2. System saves the new tutorial into the database.
+
Use case ends.

*Extensions*

[none]
* 1a. The user enters an invalid command format to add tutorial.
+
[none]
** 1a1. System shows an error message that a wrong format was given.
+
Use case ends.

[discrete]
=== Use case: Delete tutorial (U07)

*MSS*

1. User requests to delete tutorial
2. System deletes the existing tutorial from the database.
+
Use case ends.

*Extensions*

[none]
* 1a. The user enters an invalid command format to delete tutorial.
+
[none]
** 1a1. System shows an error message that a wrong format was given.
+
Use case ends.

[none]
* 2a. The tutorial requested does not exist in the database.
+
[none]
** 2a1. System shows an error message that the requested tutorial was not found.
+
Use case ends.

[discrete]
=== Use case: List tutorials (U08)

*MSS*

1. User requests to view all tutorials.
2. System returns the list of tutorials and their respective information from the database.
+
Use case ends.

[discrete]
=== Use case: Add a student to an existing tutorial (U09)

*MSS*

1. User requests to add an existing student to an existing tutorial
2. System updates enrolled student list of the requested tutorial with the specified student in the database.
+
Use case ends.

*Extensions*

[none]
* 1a. The user enters an invalid command format to add a student.
+
[none]
** 1a1. System shows an error message that a wrong format was given.
+
Use case ends.

[none]
* 2a. The student requested does not exist in the database.
+
[none]
** 2a1. System shows an error message that the requested student was not found.
+
Use case ends.

[none]
* 3a. The tutorial requested does not exist in the database.
+
[none]
** 3a1. System shows an error message that the requested tutorial was not found.
+
Use case ends.

[discrete]
=== Use case: Remove a student from an existing tutorial (U10)

*MSS*

1. User requests to remove an existing student from an existing tutorial
2. System removes the specified student from the tutorial's student list in the database.
+
Use case ends.

*Extensions*

[none]
* 1a. The user enters an invalid command format to remove a student.
+
[none]
** 1a1. System shows an error message that a wrong format was given.
+
Use case ends.

[none]
* 2a. The student requested does not exist in the database or is not enrolled in the tutorial specified.
+
[none]
** 2a1. System shows an error message that the requested student was not found in the tutorial.
+
Use case ends.

[none]
* 3a. The tutorial requested does not exist in the database.
+
[none]
** 3a1. System shows an error message that the requested tutorial was not found.
+
Use case ends.

[discrete]
=== Use case: Mark attendance of student (U11)

*MSS*

1. User requests to mark attendance of student, either absent or present.
2. System updates attendance of the requested student in the database, with the respective attendance specified.
+
Use case ends.

*Extensions*

[none]
* 1a. The user enters an invalid command format to mark attendance.
+
[none]
** 1a1. System shows an error message that a wrong format was given.
+
Use case ends.

[none]
* 2a. The student requested does not exist in the database.
+
[none]
** 2a1. System shows an error message that the requested student was not found.
+
Use case ends.

[discrete]
=== Use case: View attendance sheet (U12)

*MSS*

1. User requests to view attendance of students from a particular tutorial.
2. System brings up the attendance panel, and shows all students in a tutorial and their attendance from the database.
+
Use case ends.
// end::sarah[]

// tag::cranston[]
[discrete]
=== Use case: Add reminder (U13)

*MSS*

1.  User requests to add reminder with description, date and time of reminder included
2.  System saves the new reminder into the database
+
Use case ends.

*Extensions*

[none]
* 1a. The description, date or time of reminder is not included.
+
[none]
** 1a1. System shows an error message that description, date and time must all be included.
+
Use case ends.

[discrete]
=== Use case: Mark reminder as done (U14)

*MSS*

1.  User requests to mark an existing reminder as done
2.  System updates the existing reminder according to the User's request
+
Use case ends.

*Extensions*

[none]
* 1a. The reminder does not exist.
+
[none]
** 1a1. System shows an error message that the reminder does not exist.
+
Use case ends.
[none]
* 1b. The reminder is already done.
+
[none]
** 1b1. System shows an error message that the reminder is already done.
+
Use case ends.

[discrete]
=== Use case: Update reminder (U15)

*MSS*

1.  User requests to update either the description, date or time of an existing reminder
2.  System updates the existing reminder according to the User's request
+
Use case ends.

*Extensions*

[none]
* 1a. The reminder does not exist.
+
[none]
** 1a1. System shows an error message that the reminder does not exist.
+
Use case ends.
[none]
* 1b. The description, date and time of reminder are not included.
+
[none]
** 1b1. System shows an error message that at least one of description, date or time must be included.
+
Use case ends.

[discrete]
=== Use case: Delete reminder (U16)

*MSS*

1.  User requests to delete an existing reminder
2.  System removes the existing reminder from the database
+
Use case ends.

*Extensions*

[none]
* 1a. The reminder does not exist.
+
[none]
** 1a1. System shows an error message that the reminder does not exist.
+
Use case ends.

[discrete]
=== Use case: List reminders (U17)

*MSS*

1.  User requests to list all existing reminders
2.  System returns all the existing reminders from the database
+
Use case ends.

*Extensions*

[none]
* 2a. The list is empty.
+
Use case ends.

[discrete]
=== Use case: Find reminders (U18)

*MSS*

1.  User requests to find all reminders matching with some keywords and/or date.
2.  System returns a list with all the matching reminders from the database
+
Use case ends.

*Extensions*

[none]
* 1a. The keyword and date are not included.
+
[none]
** 1a1. System shows an error message that at least a keyword or date must be included.
+
Use case ends.
[none]
* 2a. The list is empty.
+
Use case ends.

[discrete]
=== Use case: Snooze reminder (U19)

*MSS*

1.  User requests to snooze an existing reminder by a certain number of day, hour or minute
2.  System updates the existing reminder according to the User's request
+
Use case ends.

*Extensions*

[none]
* 1a. The reminder does not exist.
+
[none]
** 1a1. System shows an error message that the reminder does not exist.
+
Use case ends.
[none]
* 1b. The day, hour and minute of reminder to be snoozed by are not included.
+
[none]
** 1b1. System shows an error message that at least one of day, hour or minute must be included.
+
Use case ends.
[none]
* 1c. The reminder is already done.
+
[none]
** 1c1. System shows an error message that the reminder is already done.
+
Use case ends.
// end::cranston[]

[discrete]
=== Use case: Create Module (U20)

*MSS*

1.  User requests to create Module
2.  System creates Module and includes it in its storage
+
Use case ends.

*Extensions*

[none]
* 1a. The user enters an invalid command format to add module.
+
[none]
** 1a1. System shows an error message that a wrong format was given.
+
[none]
* 2a. The user enters a module code that is already present in the storage
[none]
** 2a1. System shows an error message stating that the module already exists.

Use case ends.

[discrete]
=== Use case: View Module (U21)

*MSS*

1.  User requests to view an existing module
2.  System updates the module information tab to show the existing module according to the User's request
+
Use case ends.

*Extensions*

[none]
* 1a. The module does not exist.
+
[none]
** 1a1. System shows an error message that the module does not exist.
+
Use case ends.

[discrete]
=== Use case: Update Module (U22)

*MSS*

1.  User requests to update the notes of an existing module
2.  System updates the existing module according to the User's request
+
Use case ends.

*Extensions*

[none]
* 1a. The module does not exist.
+
[none]
** 1a1. System shows an error message that the module does not exist.
+
Use case ends.

[discrete]
=== Use case: Add Module links (U23)

*MSS*

1.  User requests to add links to module
2.  System updates the existing module links according to the User's request by appending the link to the module links section.
+
Use case ends.

*Extensions*

[none]
* 1a. The module does not exist.
+
[none]
** 1a1. System shows an error message that the module does not exist.
+
Use case ends.

[none]
* 2a. Link provided by user does not match the URL format as specified in Java 11.
+
[none]
** 2a1. System shows an error message that the URL provided is not valid.
+
Use case ends.

[discrete]
=== Use case: Clear All Module links (U24)

*MSS*

1.  User requests to clear all links to module
2.  System removes all existing module links according to the User's request
+
Use case ends.

*Extensions*

[none]
* 1a. The module does not exist.
+
[none]
** 1a1. System shows an error message that the module does not exist.
+
Use case ends.


[discrete]
=== Use case: Open Calendar Window (U25)

*MSS*

1.  User requests to open the calendar window
2.  System displays a calendar window with all of the user's reminders, consults and tutorials.
+
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, since Computing TAs should have at least Java `11` installed.
.  Should be intuitive for users to use after following the User Guide.
.  Should be able to be scaled for use past 1000 students, so that even professors are able to use this app.
.  Should be able to process all commands input in a reasonably quick time (less than 5 seconds).
.  Should not force shutdown regardless of commands inputted by user.
.  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.
.  Data stored into TAble should be available to users without any data corruption.
. Teaching assistant is able to teach as many tutorial slots as possible, with no limit.

[appendix]
== Glossary

[[events]] Events::
Events are things which the <<teaching-assistant, Teaching Assistant>> is required to take note of.
The Teaching Assistant will be required to attend these events, which can be in the form of tutorials or consultations.

[[mainstream-os]] Mainstream OS::
Windows, Linux, Unix, OS-X

[[students]] Students::
The primary group of people which the Teaching Assistant wil have to keep track of.

[[events]] TA::
Refers to Teaching Assistant. See Teaching Assistant for more information.

[[teaching-assistant]] Teaching Assistant::
The primary user of this application.

[[module]] Module::
Course that Teaching Assistant teaches and Students register for.
Due to naming restrictions, Module is shortened to Mod in file names.

[[reminder]] Reminders::
Additional notes or tasking the Teaching Assistant wants to keep track of.
Each reminder has a deadline and status attached to them.

[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 students, modules, tutorials, consults and reminders. The window size is fixed.

. Shutting down

.. Add, edit or delete some data in TAble. Close the window or type `exit`.
.. Re-launch the app by double-clicking the jar file +
   Expected: Modifications to the data in TAble are retained.

=== Command history and Auto suggestion

. Command history

.. Prerequisites: Successfully entered a command and the command box is selected.
.. Test case: Press kbd:[↑] +
   Expected: Last successfully entered command shows up in the command box.
.. Prerequisites: TAble just started up, no commands have been successfully entered and the command box is selected.
.. Test case: Press kbd:[↑] +
   Expected: No changes in command box.

. Auto suggestion

.. Test case: Type 'add' into command box +
   Expected: A dialog pops up below the command box and suggest a list of add commands.
.. Test case: Type 'add' into command box and press kbd:[Tab] +
   Expected: The first suggested add command is displayed in the command box.

=== Deleting a student

. Deleting a student while all students are listed

.. Prerequisites: List all students using the `listStudent` command. Multiple students in the list.
.. Test case: `deleteStudent 1` +
   Expected: First student is deleted from the list. Details of the deleted student shown in the status message. Timestamp in the status bar is updated.
.. Test case: `deleteStudent 0` +
   Expected: No student is deleted. Error details shown in the status message. Status bar remains the same.
.. Other incorrect delete commands to try: `deleteStudent`, `deleteStudent x` (where x is larger than the list size) _{give more}_ +
   Expected: Similar to previous.


=== Copying module links from module

After storing a module link using the `AddModLink` command on a target module, the user can easily copy it to their clipboard with the `copyModLink` command.

[NOTE]
It is recommended that the module information panel is currently showing the target module (via the `viewModInfo` command), as the prefix for the module link is needed in this function. However, viewing the module information is not necessary; the user can simply enter the prefix if they remember it.

. Prerequisities: Target module must exist in TAble and have at least one module link associated with it.
. Test case: `copyModLink 1 modCode/CS2103` +
Expected: The first module link of the module is copied to the user's clipboard.
. Test case: `copyModLink -1 modCode/CS2103` +
Expected: No module link is copied to the clipboard, and an error message is shown to the user.
. Test case: `copyModLink 1 modCode/ZZ9999` +
Expected: No module link is copied to the clipboard (unless there is a module with a module code of ZZ9999), and an error message is shown to the user.

=== Marking attendance of a tutorial student

. Marking a student as present or absent (by default absent) for a particular week in the semester (3-13 inclusive).

.. Prerequisities: Target tutorial must exist in TAble and have at least one student enrolled in it.
.. Test case: `markPresent tutorialIndex/2 week/3 student/1` +
Expected: Using `listAttendance tutorialIndex/2 week/3` will display an attendance list with the 1st student highlighted green.
.. Test case: `markPresent tutorialIndex/2 week/3 student/all` +
Expected: Using `listAttendance tutorialIndex/2 week/3` will display an attendance list with all the students highlighted green.
.. Test case: `markAbsent tutorialIndex/2 week/3 student/1` +
Expected: Using `listAttendance tutorialIndex/2 week/3` will display an attendance list with the 1st student highlighted red.
.. Test case: `markAbsent tutorialIndex/2 week/3 student/all` +
Expected: Using `listAttendance tutorialIndex/2 week/3` will display an attendance list with all the students highlighted red.
.. Test case: `markPresent tutorialIndex/-1 week/3 student/1` +
Expected: Error message displayed, with no change to attendance list. Error details shown in the status message.
.. Test case: `markPresent tutorialIndex/1 week/0 student/1` +
Expected: Error message displayed, with no change to attendance list. Error details shown in the status message.
.. Test case: `markPresent tutorialIndex/-1 week/3 student/-2` +
Expected: Error message displayed, with no change to attendance list. Error details shown in the status message.

=== Copying tutorial students' emails

. Copying all tutorial students' emails at once onto user's clipboard with the `copyTutorialEmails` command.

.. Prerequisities: Target tutorial must exist in TAble and have at least one student enrolled in it, otherwise the copied information would be blank.
.. Test case: `copyTutorialEmails tutorialIndex/2` +
Expected: All the emails of the students in the specified tutorial is copied to the user's clipboard, separated with ""; ""
.. Test case: `copyTutorialEmails tutorialIndex/-1` +
Expected: No student emails are copied to the clipboard, and an error message is shown to the user.

=== Snoozing a reminder

. Snoozing a reminder while some reminders are listed

.. Prerequisites: List reminders using `listReminder` or `findReminder` command. Multiple reminders in the list.
.. Test case: `snoozeReminder 1 hour/1` +
   Expected: First reminder in the list is snoozed by an hour. Details of the updated reminder shown in the status message.
.. Test case: `snoozeReminder -2 day/3` +
   Expected: No reminder is snoozed. Error details shown in the status message.
.. Test case: `snoozeReminder 1 hour/0` +
   Expected: No reminder is snoozed. Error details shown in the status message.
.. Other incorrect snooze commands to try: `snoozeReminder`, `snoozeReminder x` (where x is larger than the list size), `snoozeReminder 1 hour/y (where y is a negative integer)` +
   Expected: Similar to previous.

// tag::hc1[]

=== Viewing calendar

. Displaying the calendar for the current month and year.
.. Test case: `viewCalendar` +
   Expected: A new `Calendar` window is brought up at the current year and month. A success message ""Opened Calendar window."" will appear.
.. Test case: `VIEWCALENDAR` +
   Expected: No new `Calendar` window appears. Error details shown in the status message.
.. Test case: Click the left/right arrow in the `Calendar` window or press kbd:[←] / kbd:[→] buttons. +
   Expected: The new month before/after the current displayed month is displayed in the new `Calendar` window.
.. Test case: `closeCalendar` +
    Expected: The `Calendar` window will be closed. Alternatively, the user may choose to click the cross on the top right corner of the `Calendar` window to close it.
// end::hc1[]
",12358,False,2008.0229565940692,median
"// Copyright (c) 2005-2014 Code Synthesis Tools CC
//
// This program was generated by CodeSynthesis XSD, an XML Schema to
// C++ data binding compiler.
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2 as
// published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
//
// In addition, as a special exception, Code Synthesis Tools CC gives
// permission to link this program with the Xerces-C++ library (or with
// modified versions of Xerces-C++ that use the same license as Xerces-C++),
// and distribute linked combinations including the two. You must obey
// the GNU General Public License version 2 in all respects for all of
// the code used other than Xerces-C++. If you modify this copy of the
// program, you may extend this exception to your version of the program,
// but you are not obligated to do so. If you do not wish to do so, delete
// this exception statement from your version.
//
// Furthermore, Code Synthesis Tools CC makes a special exception for
// the Free/Libre and Open Source Software (FLOSS) which is described
// in the accompanying FLOSSE file.
//

// Begin prologue.
//
//
// End prologue.

#include <xsd/cxx/pre.hxx>

#include ""SimSpace_Occupied.hxx""

#include ""t24kitchexhhooddutylist.hxx""

#include ""doublelist.hxx""

#include ""t24kitchexhhoodstylelist.hxx""

#include ""integerlist.hxx""

#include ""t24mandlightcntrldescrpt.hxx""

#include ""t24mandlightcntrlaccepreqrpt.hxx""

#include ""t24mandlightcntrlisautoshoffcntrlrpt.hxx""

#include ""t24mandlightcntrlisdayltngcntrlrpt.hxx""

#include ""t24mandlightcntrlisdmndrespcntrlrpt.hxx""

#include ""t24mandlightcntrlismanareacntrlrpt.hxx""

namespace schema
{
  namespace simxml
  {
    namespace BuildingModel
    {
      // SimSpace_Occupied
      // 

      const SimSpace_Occupied::T24CommRefrigEPD_optional& SimSpace_Occupied::
      T24CommRefrigEPD () const
      {
        return this->T24CommRefrigEPD_;
      }

      SimSpace_Occupied::T24CommRefrigEPD_optional& SimSpace_Occupied::
      T24CommRefrigEPD ()
      {
        return this->T24CommRefrigEPD_;
      }

      void SimSpace_Occupied::
      T24CommRefrigEPD (const T24CommRefrigEPD_type& x)
      {
        this->T24CommRefrigEPD_.set (x);
      }

      void SimSpace_Occupied::
      T24CommRefrigEPD (const T24CommRefrigEPD_optional& x)
      {
        this->T24CommRefrigEPD_ = x;
      }

      const SimSpace_Occupied::T24CommRefrigEqmtSchedRef_optional& SimSpace_Occupied::
      T24CommRefrigEqmtSchedRef () const
      {
        return this->T24CommRefrigEqmtSchedRef_;
      }

      SimSpace_Occupied::T24CommRefrigEqmtSchedRef_optional& SimSpace_Occupied::
      T24CommRefrigEqmtSchedRef ()
      {
        return this->T24CommRefrigEqmtSchedRef_;
      }

      void SimSpace_Occupied::
      T24CommRefrigEqmtSchedRef (const T24CommRefrigEqmtSchedRef_type& x)
      {
        this->T24CommRefrigEqmtSchedRef_.set (x);
      }

      void SimSpace_Occupied::
      T24CommRefrigEqmtSchedRef (const T24CommRefrigEqmtSchedRef_optional& x)
      {
        this->T24CommRefrigEqmtSchedRef_ = x;
      }

      void SimSpace_Occupied::
      T24CommRefrigEqmtSchedRef (::std::auto_ptr< T24CommRefrigEqmtSchedRef_type > x)
      {
        this->T24CommRefrigEqmtSchedRef_.set (x);
      }

      const SimSpace_Occupied::T24CommRefrigLatentFraction_optional& SimSpace_Occupied::
      T24CommRefrigLatentFraction () const
      {
        return this->T24CommRefrigLatentFraction_;
      }

      SimSpace_Occupied::T24CommRefrigLatentFraction_optional& SimSpace_Occupied::
      T24CommRefrigLatentFraction ()
      {
        return this->T24CommRefrigLatentFraction_;
      }

      void SimSpace_Occupied::
      T24CommRefrigLatentFraction (const T24CommRefrigLatentFraction_type& x)
      {
        this->T24CommRefrigLatentFraction_.set (x);
      }

      void SimSpace_Occupied::
      T24CommRefrigLatentFraction (const T24CommRefrigLatentFraction_optional& x)
      {
        this->T24CommRefrigLatentFraction_ = x;
      }

      const SimSpace_Occupied::T24CommRefrigLostFraction_optional& SimSpace_Occupied::
      T24CommRefrigLostFraction () const
      {
        return this->T24CommRefrigLostFraction_;
      }

      SimSpace_Occupied::T24CommRefrigLostFraction_optional& SimSpace_Occupied::
      T24CommRefrigLostFraction ()
      {
        return this->T24CommRefrigLostFraction_;
      }

      void SimSpace_Occupied::
      T24CommRefrigLostFraction (const T24CommRefrigLostFraction_type& x)
      {
        this->T24CommRefrigLostFraction_.set (x);
      }

      void SimSpace_Occupied::
      T24CommRefrigLostFraction (const T24CommRefrigLostFraction_optional& x)
      {
        this->T24CommRefrigLostFraction_ = x;
      }

      const SimSpace_Occupied::T24CommRefrigRadFraction_optional& SimSpace_Occupied::
      T24CommRefrigRadFraction () const
      {
        return this->T24CommRefrigRadFraction_;
      }

      SimSpace_Occupied::T24CommRefrigRadFraction_optional& SimSpace_Occupied::
      T24CommRefrigRadFraction ()
      {
        return this->T24CommRefrigRadFraction_;
      }

      void SimSpace_Occupied::
      T24CommRefrigRadFraction (const T24CommRefrigRadFraction_type& x)
      {
        this->T24CommRefrigRadFraction_.set (x);
      }

      void SimSpace_Occupied::
      T24CommRefrigRadFraction (const T24CommRefrigRadFraction_optional& x)
      {
        this->T24CommRefrigRadFraction_ = x;
      }

      const SimSpace_Occupied::T24EnvelopeStatus_optional& SimSpace_Occupied::
      T24EnvelopeStatus () const
      {
        return this->T24EnvelopeStatus_;
      }

      SimSpace_Occupied::T24EnvelopeStatus_optional& SimSpace_Occupied::
      T24EnvelopeStatus ()
      {
        return this->T24EnvelopeStatus_;
      }

      void SimSpace_Occupied::
      T24EnvelopeStatus (const T24EnvelopeStatus_type& x)
      {
        this->T24EnvelopeStatus_.set (x);
      }

      void SimSpace_Occupied::
      T24EnvelopeStatus (const T24EnvelopeStatus_optional& x)
      {
        this->T24EnvelopeStatus_ = x;
      }

      void SimSpace_Occupied::
      T24EnvelopeStatus (::std::auto_ptr< T24EnvelopeStatus_type > x)
      {
        this->T24EnvelopeStatus_.set (x);
      }

      const SimSpace_Occupied::T24ExhaustAirChangesPerHour_optional& SimSpace_Occupied::
      T24ExhaustAirChangesPerHour () const
      {
        return this->T24ExhaustAirChangesPerHour_;
      }

      SimSpace_Occupied::T24ExhaustAirChangesPerHour_optional& SimSpace_Occupied::
      T24ExhaustAirChangesPerHour ()
      {
        return this->T24ExhaustAirChangesPerHour_;
      }

      void SimSpace_Occupied::
      T24ExhaustAirChangesPerHour (const T24ExhaustAirChangesPerHour_type& x)
      {
        this->T24ExhaustAirChangesPerHour_.set (x);
      }

      void SimSpace_Occupied::
      T24ExhaustAirChangesPerHour (const T24ExhaustAirChangesPerHour_optional& x)
      {
        this->T24ExhaustAirChangesPerHour_ = x;
      }

      const SimSpace_Occupied::T24ExhaustPerArea_optional& SimSpace_Occupied::
      T24ExhaustPerArea () const
      {
        return this->T24ExhaustPerArea_;
      }

      SimSpace_Occupied::T24ExhaustPerArea_optional& SimSpace_Occupied::
      T24ExhaustPerArea ()
      {
        return this->T24ExhaustPerArea_;
      }

      void SimSpace_Occupied::
      T24ExhaustPerArea (const T24ExhaustPerArea_type& x)
      {
        this->T24ExhaustPerArea_.set (x);
      }

      void SimSpace_Occupied::
      T24ExhaustPerArea (const T24ExhaustPerArea_optional& x)
      {
        this->T24ExhaustPerArea_ = x;
      }

      const SimSpace_Occupied::T24ExhaustPerSpace_optional& SimSpace_Occupied::
      T24ExhaustPerSpace () const
      {
        return this->T24ExhaustPerSpace_;
      }

      SimSpace_Occupied::T24ExhaustPerSpace_optional& SimSpace_Occupied::
      T24ExhaustPerSpace ()
      {
        return this->T24ExhaustPerSpace_;
      }

      void SimSpace_Occupied::
      T24ExhaustPerSpace (const T24ExhaustPerSpace_type& x)
      {
        this->T24ExhaustPerSpace_.set (x);
      }

      void SimSpace_Occupied::
      T24ExhaustPerSpace (const T24ExhaustPerSpace_optional& x)
      {
        this->T24ExhaustPerSpace_ = x;
      }

      const SimSpace_Occupied::T24HasProcessExhaust_optional& SimSpace_Occupied::
      T24HasProcessExhaust () const
      {
        return this->T24HasProcessExhaust_;
      }

      SimSpace_Occupied::T24HasProcessExhaust_optional& SimSpace_Occupied::
      T24HasProcessExhaust ()
      {
        return this->T24HasProcessExhaust_;
      }

      void SimSpace_Occupied::
      T24HasProcessExhaust (const T24HasProcessExhaust_type& x)
      {
        this->T24HasProcessExhaust_.set (x);
      }

      void SimSpace_Occupied::
      T24HasProcessExhaust (const T24HasProcessExhaust_optional& x)
      {
        this->T24HasProcessExhaust_ = x;
      }

      const SimSpace_Occupied::T24IntLightingSpecMethod_optional& SimSpace_Occupied::
      T24IntLightingSpecMethod () const
      {
        return this->T24IntLightingSpecMethod_;
      }

      SimSpace_Occupied::T24IntLightingSpecMethod_optional& SimSpace_Occupied::
      T24IntLightingSpecMethod ()
      {
        return this->T24IntLightingSpecMethod_;
      }

      void SimSpace_Occupied::
      T24IntLightingSpecMethod (const T24IntLightingSpecMethod_type& x)
      {
        this->T24IntLightingSpecMethod_.set (x);
      }

      void SimSpace_Occupied::
      T24IntLightingSpecMethod (const T24IntLightingSpecMethod_optional& x)
      {
        this->T24IntLightingSpecMethod_ = x;
      }

      void SimSpace_Occupied::
      T24IntLightingSpecMethod (::std::auto_ptr< T24IntLightingSpecMethod_type > x)
      {
        this->T24IntLightingSpecMethod_.set (x);
      }

      const SimSpace_Occupied::T24KitchExhHoodDutyList_optional& SimSpace_Occupied::
      T24KitchExhHoodDutyList () const
      {
        return this->T24KitchExhHoodDutyList_;
      }

      SimSpace_Occupied::T24KitchExhHoodDutyList_optional& SimSpace_Occupied::
      T24KitchExhHoodDutyList ()
      {
        return this->T24KitchExhHoodDutyList_;
      }

      void SimSpace_Occupied::
      T24KitchExhHoodDutyList (const T24KitchExhHoodDutyList_type& x)
      {
        this->T24KitchExhHoodDutyList_.set (x);
      }

      void SimSpace_Occupied::
      T24KitchExhHoodDutyList (const T24KitchExhHoodDutyList_optional& x)
      {
        this->T24KitchExhHoodDutyList_ = x;
      }

      void SimSpace_Occupied::
      T24KitchExhHoodDutyList (::std::auto_ptr< T24KitchExhHoodDutyList_type > x)
      {
        this->T24KitchExhHoodDutyList_.set (x);
      }

      const SimSpace_Occupied::T24KitchExhHoodFlowList_optional& SimSpace_Occupied::
      T24KitchExhHoodFlowList () const
      {
        return this->T24KitchExhHoodFlowList_;
      }

      SimSpace_Occupied::T24KitchExhHoodFlowList_optional& SimSpace_Occupied::
      T24KitchExhHoodFlowList ()
      {
        return this->T24KitchExhHoodFlowList_;
      }

      void SimSpace_Occupied::
      T24KitchExhHoodFlowList (const T24KitchExhHoodFlowList_type& x)
      {
        this->T24KitchExhHoodFlowList_.set (x);
      }

      void SimSpace_Occupied::
      T24KitchExhHoodFlowList (const T24KitchExhHoodFlowList_optional& x)
      {
        this->T24KitchExhHoodFlowList_ = x;
      }

      void SimSpace_Occupied::
      T24KitchExhHoodFlowList (::std::auto_ptr< T24KitchExhHoodFlowList_type > x)
      {
        this->T24KitchExhHoodFlowList_.set (x);
      }

      const SimSpace_Occupied::T24KitchExhHoodLengthList_optional& SimSpace_Occupied::
      T24KitchExhHoodLengthList () const
      {
        return this->T24KitchExhHoodLengthList_;
      }

      SimSpace_Occupied::T24KitchExhHoodLengthList_optional& SimSpace_Occupied::
      T24KitchExhHoodLengthList ()
      {
        return this->T24KitchExhHoodLengthList_;
      }

      void SimSpace_Occupied::
      T24KitchExhHoodLengthList (const T24KitchExhHoodLengthList_type& x)
      {
        this->T24KitchExhHoodLengthList_.set (x);
      }

      void SimSpace_Occupied::
      T24KitchExhHoodLengthList (const T24KitchExhHoodLengthList_optional& x)
      {
        this->T24KitchExhHoodLengthList_ = x;
      }

      void SimSpace_Occupied::
      T24KitchExhHoodLengthList (::std::auto_ptr< T24KitchExhHoodLengthList_type > x)
      {
        this->T24KitchExhHoodLengthList_.set (x);
      }

      const SimSpace_Occupied::T24KitchExhHoodStyleList_optional& SimSpace_Occupied::
      T24KitchExhHoodStyleList () const
      {
        return this->T24KitchExhHoodStyleList_;
      }

      SimSpace_Occupied::T24KitchExhHoodStyleList_optional& SimSpace_Occupied::
      T24KitchExhHoodStyleList ()
      {
        return this->T24KitchExhHoodStyleList_;
      }

      void SimSpace_Occupied::
      T24KitchExhHoodStyleList (const T24KitchExhHoodStyleList_type& x)
      {
        this->T24KitchExhHoodStyleList_.set (x);
      }

      void SimSpace_Occupied::
      T24KitchExhHoodStyleList (const T24KitchExhHoodStyleList_optional& x)
      {
        this->T24KitchExhHoodStyleList_ = x;
      }

      void SimSpace_Occupied::
      T24KitchExhHoodStyleList (::std::auto_ptr< T24KitchExhHoodStyleList_type > x)
      {
        this->T24KitchExhHoodStyleList_.set (x);
      }

      const SimSpace_Occupied::T24LabExhRateType_optional& SimSpace_Occupied::
      T24LabExhRateType () const
      {
        return this->T24LabExhRateType_;
      }

      SimSpace_Occupied::T24LabExhRateType_optional& SimSpace_Occupied::
      T24LabExhRateType ()
      {
        return this->T24LabExhRateType_;
      }

      void SimSpace_Occupied::
      T24LabExhRateType (const T24LabExhRateType_type& x)
      {
        this->T24LabExhRateType_.set (x);
      }

      void SimSpace_Occupied::
      T24LabExhRateType (const T24LabExhRateType_optional& x)
      {
        this->T24LabExhRateType_ = x;
      }

      void SimSpace_Occupied::
      T24LabExhRateType (::std::auto_ptr< T24LabExhRateType_type > x)
      {
        this->T24LabExhRateType_.set (x);
      }

      const SimSpace_Occupied::T24LightingStatus_optional& SimSpace_Occupied::
      T24LightingStatus () const
      {
        return this->T24LightingStatus_;
      }

      SimSpace_Occupied::T24LightingStatus_optional& SimSpace_Occupied::
      T24LightingStatus ()
      {
        return this->T24LightingStatus_;
      }

      void SimSpace_Occupied::
      T24LightingStatus (const T24LightingStatus_type& x)
      {
        this->T24LightingStatus_.set (x);
      }

      void SimSpace_Occupied::
      T24LightingStatus (const T24LightingStatus_optional& x)
      {
        this->T24LightingStatus_ = x;
      }

      void SimSpace_Occupied::
      T24LightingStatus (::std::auto_ptr< T24LightingStatus_type > x)
      {
        this->T24LightingStatus_.set (x);
      }

      const SimSpace_Occupied::T24MandLightCntrlCntRpt_optional& SimSpace_Occupied::
      T24MandLightCntrlCntRpt () const
      {
        return this->T24MandLightCntrlCntRpt_;
      }

      SimSpace_Occupied::T24MandLightCntrlCntRpt_optional& SimSpace_Occupied::
      T24MandLightCntrlCntRpt ()
      {
        return this->T24MandLightCntrlCntRpt_;
      }

      void SimSpace_Occupied::
      T24MandLightCntrlCntRpt (const T24MandLightCntrlCntRpt_type& x)
      {
        this->T24MandLightCntrlCntRpt_.set (x);
      }

      void SimSpace_Occupied::
      T24MandLightCntrlCntRpt (const T24MandLightCntrlCntRpt_optional& x)
      {
        this->T24MandLightCntrlCntRpt_ = x;
      }

      void SimSpace_Occupied::
      T24MandLightCntrlCntRpt (::std::auto_ptr< T24MandLightCntrlCntRpt_type > x)
      {
        this->T24MandLightCntrlCntRpt_.set (x);
      }

      const SimSpace_Occupied::T24MandLightCntrlDescRpt_optional& SimSpace_Occupied::
      T24MandLightCntrlDescRpt () const
      {
        return this->T24MandLightCntrlDescRpt_;
      }

      SimSpace_Occupied::T24MandLightCntrlDescRpt_optional& SimSpace_Occupied::
      T24MandLightCntrlDescRpt ()
      {
        return this->T24MandLightCntrlDescRpt_;
      }

      void SimSpace_Occupied::
      T24MandLightCntrlDescRpt (const T24MandLightCntrlDescRpt_type& x)
      {
        this->T24MandLightCntrlDescRpt_.set (x);
      }

      void SimSpace_Occupied::
      T24MandLightCntrlDescRpt (const T24MandLightCntrlDescRpt_optional& x)
      {
        this->T24MandLightCntrlDescRpt_ = x;
      }

      void SimSpace_Occupied::
      T24MandLightCntrlDescRpt (::std::auto_ptr< T24MandLightCntrlDescRpt_type > x)
      {
        this->T24MandLightCntrlDescRpt_.set (x);
      }

      const SimSpace_Occupied::T24MandLightCntrlAccepReqRpt_optional& SimSpace_Occupied::
      T24MandLightCntrlAccepReqRpt () const
      {
        return this->T24MandLightCntrlAccepReqRpt_;
      }

      SimSpace_Occupied::T24MandLightCntrlAccepReqRpt_optional& SimSpace_Occupied::
      T24MandLightCntrlAccepReqRpt ()
      {
        return this->T24MandLightCntrlAccepReqRpt_;
      }

      void SimSpace_Occupied::
      T24MandLightCntrlAccepReqRpt (const T24MandLightCntrlAccepReqRpt_type& x)
      {
        this->T24MandLightCntrlAccepReqRpt_.set (x);
      }

      void SimSpace_Occupied::
      T24MandLightCntrlAccepReqRpt (const T24MandLightCntrlAccepReqRpt_optional& x)
      {
        this->T24MandLightCntrlAccepReqRpt_ = x;
      }

      void SimSpace_Occupied::
      T24MandLightCntrlAccepReqRpt (::std::auto_ptr< T24MandLightCntrlAccepReqRpt_type > x)
      {
        this->T24MandLightCntrlAccepReqRpt_.set (x);
      }

      const SimSpace_Occupied::T24MandLightCntrlIsAutoShOffCntrlRpt_optional& SimSpace_Occupied::
      T24MandLightCntrlIsAutoShOffCntrlRpt () const
      {
        return this->T24MandLightCntrlIsAutoShOffCntrlRpt_;
      }

      SimSpace_Occupied::T24MandLightCntrlIsAutoShOffCntrlRpt_optional& SimSpace_Occupied::
      T24MandLightCntrlIsAutoShOffCntrlRpt ()
      {
        return this->T24MandLightCntrlIsAutoShOffCntrlRpt_;
      }

      void SimSpace_Occupied::
      T24MandLightCntrlIsAutoShOffCntrlRpt (const T24MandLightCntrlIsAutoShOffCntrlRpt_type& x)
      {
        this->T24MandLightCntrlIsAutoShOffCntrlRpt_.set (x);
      }

      void SimSpace_Occupied::
      T24MandLightCntrlIsAutoShOffCntrlRpt (const T24MandLightCntrlIsAutoShOffCntrlRpt_optional& x)
      {
        this->T24MandLightCntrlIsAutoShOffCntrlRpt_ = x;
      }

      void SimSpace_Occupied::
      T24MandLightCntrlIsAutoShOffCntrlRpt (::std::auto_ptr< T24MandLightCntrlIsAutoShOffCntrlRpt_type > x)
      {
        this->T24MandLightCntrlIsAutoShOffCntrlRpt_.set (x);
      }

      const SimSpace_Occupied::T24MandLightCntrlIsDayltngCntrlRpt_optional& SimSpace_Occupied::
      T24MandLightCntrlIsDayltngCntrlRpt () const
      {
        return this->T24MandLightCntrlIsDayltngCntrlRpt_;
      }

      SimSpace_Occupied::T24MandLightCntrlIsDayltngCntrlRpt_optional& SimSpace_Occupied::
      T24MandLightCntrlIsDayltngCntrlRpt ()
      {
        return this->T24MandLightCntrlIsDayltngCntrlRpt_;
      }

      void SimSpace_Occupied::
      T24MandLightCntrlIsDayltngCntrlRpt (const T24MandLightCntrlIsDayltngCntrlRpt_type& x)
      {
        this->T24MandLightCntrlIsDayltngCntrlRpt_.set (x);
      }

      void SimSpace_Occupied::
      T24MandLightCntrlIsDayltngCntrlRpt (const T24MandLightCntrlIsDayltngCntrlRpt_optional& x)
      {
        this->T24MandLightCntrlIsDayltngCntrlRpt_ = x;
      }

      void SimSpace_Occupied::
      T24MandLightCntrlIsDayltngCntrlRpt (::std::auto_ptr< T24MandLightCntrlIsDayltngCntrlRpt_type > x)
      {
        this->T24MandLightCntrlIsDayltngCntrlRpt_.set (x);
      }

      const SimSpace_Occupied::T24MandLightCntrlIsDmndRespCntrlRpt_optional& SimSpace_Occupied::
      T24MandLightCntrlIsDmndRespCntrlRpt () const
      {
        return this->T24MandLightCntrlIsDmndRespCntrlRpt_;
      }

      SimSpace_Occupied::T24MandLightCntrlIsDmndRespCntrlRpt_optional& SimSpace_Occupied::
      T24MandLightCntrlIsDmndRespCntrlRpt ()
      {
        return this->T24MandLightCntrlIsDmndRespCntrlRpt_;
      }

      void SimSpace_Occupied::
      T24MandLightCntrlIsDmndRespCntrlRpt (const T24MandLightCntrlIsDmndRespCntrlRpt_type& x)
      {
        this->T24MandLightCntrlIsDmndRespCntrlRpt_.set (x);
      }

      void SimSpace_Occupied::
      T24MandLightCntrlIsDmndRespCntrlRpt (const T24MandLightCntrlIsDmndRespCntrlRpt_optional& x)
      {
        this->T24MandLightCntrlIsDmndRespCntrlRpt_ = x;
      }

      void SimSpace_Occupied::
      T24MandLightCntrlIsDmndRespCntrlRpt (::std::auto_ptr< T24MandLightCntrlIsDmndRespCntrlRpt_type > x)
      {
        this->T24MandLightCntrlIsDmndRespCntrlRpt_.set (x);
      }

      const SimSpace_Occupied::T24MandLightCntrlIsManAreaCntrlRpt_optional& SimSpace_Occupied::
      T24MandLightCntrlIsManAreaCntrlRpt () const
      {
        return this->T24MandLightCntrlIsManAreaCntrlRpt_;
      }

      SimSpace_Occupied::T24MandLightCntrlIsManAreaCntrlRpt_optional& SimSpace_Occupied::
      T24MandLightCntrlIsManAreaCntrlRpt ()
      {
        return this->T24MandLightCntrlIsManAreaCntrlRpt_;
      }

      void SimSpace_Occupied::
      T24MandLightCntrlIsManAreaCntrlRpt (const T24MandLightCntrlIsManAreaCntrlRpt_type& x)
      {
        this->T24MandLightCntrlIsManAreaCntrlRpt_.set (x);
      }

      void SimSpace_Occupied::
      T24MandLightCntrlIsManAreaCntrlRpt (const T24MandLightCntrlIsManAreaCntrlRpt_optional& x)
      {
        this->T24MandLightCntrlIsManAreaCntrlRpt_ = x;
      }

      void SimSpace_Occupied::
      T24MandLightCntrlIsManAreaCntrlRpt (::std::auto_ptr< T24MandLightCntrlIsManAreaCntrlRpt_type > x)
      {
        this->T24MandLightCntrlIsManAreaCntrlRpt_.set (x);
      }

      const SimSpace_Occupied::T24MandLightCntrlIsMultLvlCntrlRpt_optional& SimSpace_Occupied::
      T24MandLightCntrlIsMultLvlCntrlRpt () const
      {
        return this->T24MandLightCntrlIsMultLvlCntrlRpt_;
      }

      SimSpace_Occupied::T24MandLightCntrlIsMultLvlCntrlRpt_optional& SimSpace_Occupied::
      T24MandLightCntrlIsMultLvlCntrlRpt ()
      {
        return this->T24MandLightCntrlIsMultLvlCntrlRpt_;
      }

      void SimSpace_Occupied::
      T24MandLightCntrlIsMultLvlCntrlRpt (const T24MandLightCntrlIsMultLvlCntrlRpt_type& x)
      {
        this->T24MandLightCntrlIsMultLvlCntrlRpt_.set (x);
      }

      void SimSpace_Occupied::
      T24MandLightCntrlIsMultLvlCntrlRpt (const T24MandLightCntrlIsMultLvlCntrlRpt_optional& x)
      {
        this->T24MandLightCntrlIsMultLvlCntrlRpt_ = x;
      }

      void SimSpace_Occupied::
      T24MandLightCntrlIsMultLvlCntrlRpt (::std::auto_ptr< T24MandLightCntrlIsMultLvlCntrlRpt_type > x)
      {
        this->T24MandLightCntrlIsMultLvlCntrlRpt_.set (x);
      }

      const SimSpace_Occupied::T24SkylightRqmtExcep_optional& SimSpace_Occupied::
      T24SkylightRqmtExcep () const
      {
        return this->T24SkylightRqmtExcep_;
      }

      SimSpace_Occupied::T24SkylightRqmtExcep_optional& SimSpace_Occupied::
      T24SkylightRqmtExcep ()
      {
        return this->T24SkylightRqmtExcep_;
      }

      void SimSpace_Occupied::
      T24SkylightRqmtExcep (const T24SkylightRqmtExcep_type& x)
      {
        this->T24SkylightRqmtExcep_.set (x);
      }

      void SimSpace_Occupied::
      T24SkylightRqmtExcep (const T24SkylightRqmtExcep_optional& x)
      {
        this->T24SkylightRqmtExcep_ = x;
      }

      void SimSpace_Occupied::
      T24SkylightRqmtExcep (::std::auto_ptr< T24SkylightRqmtExcep_type > x)
      {
        this->T24SkylightRqmtExcep_.set (x);
      }

      const SimSpace_Occupied::T24SpaceFunction_optional& SimSpace_Occupied::
      T24SpaceFunction () const
      {
        return this->T24SpaceFunction_;
      }

      SimSpace_Occupied::T24SpaceFunction_optional& SimSpace_Occupied::
      T24SpaceFunction ()
      {
        return this->T24SpaceFunction_;
      }

      void SimSpace_Occupied::
      T24SpaceFunction (const T24SpaceFunction_type& x)
      {
        this->T24SpaceFunction_.set (x);
      }

      void SimSpace_Occupied::
      T24SpaceFunction (const T24SpaceFunction_optional& x)
      {
        this->T24SpaceFunction_ = x;
      }

      void SimSpace_Occupied::
      T24SpaceFunction (::std::auto_ptr< T24SpaceFunction_type > x)
      {
        this->T24SpaceFunction_.set (x);
      }

      const SimSpace_Occupied::T24ConstructStatus3_optional& SimSpace_Occupied::
      T24ConstructStatus3 () const
      {
        return this->T24ConstructStatus3_;
      }

      SimSpace_Occupied::T24ConstructStatus3_optional& SimSpace_Occupied::
      T24ConstructStatus3 ()
      {
        return this->T24ConstructStatus3_;
      }

      void SimSpace_Occupied::
      T24ConstructStatus3 (const T24ConstructStatus3_type& x)
      {
        this->T24ConstructStatus3_.set (x);
      }

      void SimSpace_Occupied::
      T24ConstructStatus3 (const T24ConstructStatus3_optional& x)
      {
        this->T24ConstructStatus3_ = x;
      }

      void SimSpace_Occupied::
      T24ConstructStatus3 (::std::auto_ptr< T24ConstructStatus3_type > x)
      {
        this->T24ConstructStatus3_.set (x);
      }
    }
  }
}

#include <xsd/cxx/xml/dom/parsing-source.hxx>

#include <xsd/cxx/tree/type-factory-map.hxx>

namespace _xsd
{
  static
  const ::xsd::cxx::tree::type_factory_plate< 0, char >
  type_factory_plate_init;
}

namespace schema
{
  namespace simxml
  {
    namespace BuildingModel
    {
      // SimSpace_Occupied
      //

      SimSpace_Occupied::
      SimSpace_Occupied ()
      : ::schema::simxml::BuildingModel::SimSpace (),
        T24CommRefrigEPD_ (this),
        T24CommRefrigEqmtSchedRef_ (this),
        T24CommRefrigLatentFraction_ (this),
        T24CommRefrigLostFraction_ (this),
        T24CommRefrigRadFraction_ (this),
        T24EnvelopeStatus_ (this),
        T24ExhaustAirChangesPerHour_ (this),
        T24ExhaustPerArea_ (this),
        T24ExhaustPerSpace_ (this),
        T24HasProcessExhaust_ (this),
        T24IntLightingSpecMethod_ (this),
        T24KitchExhHoodDutyList_ (this),
        T24KitchExhHoodFlowList_ (this),
        T24KitchExhHoodLengthList_ (this),
        T24KitchExhHoodStyleList_ (this),
        T24LabExhRateType_ (this),
        T24LightingStatus_ (this),
        T24MandLightCntrlCntRpt_ (this),
        T24MandLightCntrlDescRpt_ (this),
        T24MandLightCntrlAccepReqRpt_ (this),
        T24MandLightCntrlIsAutoShOffCntrlRpt_ (this),
        T24MandLightCntrlIsDayltngCntrlRpt_ (this),
        T24MandLightCntrlIsDmndRespCntrlRpt_ (this),
        T24MandLightCntrlIsManAreaCntrlRpt_ (this),
        T24MandLightCntrlIsMultLvlCntrlRpt_ (this),
        T24SkylightRqmtExcep_ (this),
        T24SpaceFunction_ (this),
        T24ConstructStatus3_ (this)
      {
      }

      SimSpace_Occupied::
      SimSpace_Occupied (const RefId_type& RefId)
      : ::schema::simxml::BuildingModel::SimSpace (RefId),
        T24CommRefrigEPD_ (this),
        T24CommRefrigEqmtSchedRef_ (this),
        T24CommRefrigLatentFraction_ (this),
        T24CommRefrigLostFraction_ (this),
        T24CommRefrigRadFraction_ (this),
        T24EnvelopeStatus_ (this),
        T24ExhaustAirChangesPerHour_ (this),
        T24ExhaustPerArea_ (this),
        T24ExhaustPerSpace_ (this),
        T24HasProcessExhaust_ (this),
        T24IntLightingSpecMethod_ (this),
        T24KitchExhHoodDutyList_ (this),
        T24KitchExhHoodFlowList_ (this),
        T24KitchExhHoodLengthList_ (this),
        T24KitchExhHoodStyleList_ (this),
        T24LabExhRateType_ (this),
        T24LightingStatus_ (this),
        T24MandLightCntrlCntRpt_ (this),
        T24MandLightCntrlDescRpt_ (this),
        T24MandLightCntrlAccepReqRpt_ (this),
        T24MandLightCntrlIsAutoShOffCntrlRpt_ (this),
        T24MandLightCntrlIsDayltngCntrlRpt_ (this),
        T24MandLightCntrlIsDmndRespCntrlRpt_ (this),
        T24MandLightCntrlIsManAreaCntrlRpt_ (this),
        T24MandLightCntrlIsMultLvlCntrlRpt_ (this),
        T24SkylightRqmtExcep_ (this),
        T24SpaceFunction_ (this),
        T24ConstructStatus3_ (this)
      {
      }

      SimSpace_Occupied::
      SimSpace_Occupied (const SimSpace_Occupied& x,
                         ::xml_schema::flags f,
                         ::xml_schema::container* c)
      : ::schema::simxml::BuildingModel::SimSpace (x, f, c),
        T24CommRefrigEPD_ (x.T24CommRefrigEPD_, f, this),
        T24CommRefrigEqmtSchedRef_ (x.T24CommRefrigEqmtSchedRef_, f, this),
        T24CommRefrigLatentFraction_ (x.T24CommRefrigLatentFraction_, f, this),
        T24CommRefrigLostFraction_ (x.T24CommRefrigLostFraction_, f, this),
        T24CommRefrigRadFraction_ (x.T24CommRefrigRadFraction_, f, this),
        T24EnvelopeStatus_ (x.T24EnvelopeStatus_, f, this),
        T24ExhaustAirChangesPerHour_ (x.T24ExhaustAirChangesPerHour_, f, this),
        T24ExhaustPerArea_ (x.T24ExhaustPerArea_, f, this),
        T24ExhaustPerSpace_ (x.T24ExhaustPerSpace_, f, this),
        T24HasProcessExhaust_ (x.T24HasProcessExhaust_, f, this),
        T24IntLightingSpecMethod_ (x.T24IntLightingSpecMethod_, f, this),
        T24KitchExhHoodDutyList_ (x.T24KitchExhHoodDutyList_, f, this),
        T24KitchExhHoodFlowList_ (x.T24KitchExhHoodFlowList_, f, this),
        T24KitchExhHoodLengthList_ (x.T24KitchExhHoodLengthList_, f, this),
        T24KitchExhHoodStyleList_ (x.T24KitchExhHoodStyleList_, f, this),
        T24LabExhRateType_ (x.T24LabExhRateType_, f, this),
        T24LightingStatus_ (x.T24LightingStatus_, f, this),
        T24MandLightCntrlCntRpt_ (x.T24MandLightCntrlCntRpt_, f, this),
        T24MandLightCntrlDescRpt_ (x.T24MandLightCntrlDescRpt_, f, this),
        T24MandLightCntrlAccepReqRpt_ (x.T24MandLightCntrlAccepReqRpt_, f, this),
        T24MandLightCntrlIsAutoShOffCntrlRpt_ (x.T24MandLightCntrlIsAutoShOffCntrlRpt_, f, this),
        T24MandLightCntrlIsDayltngCntrlRpt_ (x.T24MandLightCntrlIsDayltngCntrlRpt_, f, this),
        T24MandLightCntrlIsDmndRespCntrlRpt_ (x.T24MandLightCntrlIsDmndRespCntrlRpt_, f, this),
        T24MandLightCntrlIsManAreaCntrlRpt_ (x.T24MandLightCntrlIsManAreaCntrlRpt_, f, this),
        T24MandLightCntrlIsMultLvlCntrlRpt_ (x.T24MandLightCntrlIsMultLvlCntrlRpt_, f, this),
        T24SkylightRqmtExcep_ (x.T24SkylightRqmtExcep_, f, this),
        T24SpaceFunction_ (x.T24SpaceFunction_, f, this),
        T24ConstructStatus3_ (x.T24ConstructStatus3_, f, this)
      {
      }

      SimSpace_Occupied::
      SimSpace_Occupied (const ::xercesc::DOMElement& e,
                         ::xml_schema::flags f,
                         ::xml_schema::container* c)
      : ::schema::simxml::BuildingModel::SimSpace (e, f | ::xml_schema::flags::base, c),
        T24CommRefrigEPD_ (this),
        T24CommRefrigEqmtSchedRef_ (this),
        T24CommRefrigLatentFraction_ (this),
        T24CommRefrigLostFraction_ (this),
        T24CommRefrigRadFraction_ (this),
        T24EnvelopeStatus_ (this),
        T24ExhaustAirChangesPerHour_ (this),
        T24ExhaustPerArea_ (this),
        T24ExhaustPerSpace_ (this),
        T24HasProcessExhaust_ (this),
        T24IntLightingSpecMethod_ (this),
        T24KitchExhHoodDutyList_ (this),
        T24KitchExhHoodFlowList_ (this),
        T24KitchExhHoodLengthList_ (this),
        T24KitchExhHoodStyleList_ (this),
        T24LabExhRateType_ (this),
        T24LightingStatus_ (this),
        T24MandLightCntrlCntRpt_ (this),
        T24MandLightCntrlDescRpt_ (this),
        T24MandLightCntrlAccepReqRpt_ (this),
        T24MandLightCntrlIsAutoShOffCntrlRpt_ (this),
        T24MandLightCntrlIsDayltngCntrlRpt_ (this),
        T24MandLightCntrlIsDmndRespCntrlRpt_ (this),
        T24MandLightCntrlIsManAreaCntrlRpt_ (this),
        T24MandLightCntrlIsMultLvlCntrlRpt_ (this),
        T24SkylightRqmtExcep_ (this),
        T24SpaceFunction_ (this),
        T24ConstructStatus3_ (this)
      {
        if ((f & ::xml_schema::flags::base) == 0)
        {
          ::xsd::cxx::xml::dom::parser< char > p (e, true, false, true);
          this->parse (p, f);
        }
      }

      void SimSpace_Occupied::
      parse (::xsd::cxx::xml::dom::parser< char >& p,
             ::xml_schema::flags f)
      {
        this->::schema::simxml::BuildingModel::SimSpace::parse (p, f);

        for (; p.more_content (); p.next_content (false))
        {
          const ::xercesc::DOMElement& i (p.cur_element ());
          const ::xsd::cxx::xml::qualified_name< char > n (
            ::xsd::cxx::xml::dom::name< char > (i));

          // T24CommRefrigEPD
          //
          if (n.name () == ""T24CommRefrigEPD"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            if (!this->T24CommRefrigEPD_)
            {
              this->T24CommRefrigEPD_.set (T24CommRefrigEPD_traits::create (i, f, this));
              continue;
            }
          }

          // T24CommRefrigEqmtSchedRef
          //
          if (n.name () == ""T24CommRefrigEqmtSchedRef"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            ::std::auto_ptr< T24CommRefrigEqmtSchedRef_type > r (
              T24CommRefrigEqmtSchedRef_traits::create (i, f, this));

            if (!this->T24CommRefrigEqmtSchedRef_)
            {
              this->T24CommRefrigEqmtSchedRef_.set (r);
              continue;
            }
          }

          // T24CommRefrigLatentFraction
          //
          if (n.name () == ""T24CommRefrigLatentFraction"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            if (!this->T24CommRefrigLatentFraction_)
            {
              this->T24CommRefrigLatentFraction_.set (T24CommRefrigLatentFraction_traits::create (i, f, this));
              continue;
            }
          }

          // T24CommRefrigLostFraction
          //
          if (n.name () == ""T24CommRefrigLostFraction"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            if (!this->T24CommRefrigLostFraction_)
            {
              this->T24CommRefrigLostFraction_.set (T24CommRefrigLostFraction_traits::create (i, f, this));
              continue;
            }
          }

          // T24CommRefrigRadFraction
          //
          if (n.name () == ""T24CommRefrigRadFraction"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            if (!this->T24CommRefrigRadFraction_)
            {
              this->T24CommRefrigRadFraction_.set (T24CommRefrigRadFraction_traits::create (i, f, this));
              continue;
            }
          }

          // T24EnvelopeStatus
          //
          if (n.name () == ""T24EnvelopeStatus"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            ::std::auto_ptr< T24EnvelopeStatus_type > r (
              T24EnvelopeStatus_traits::create (i, f, this));

            if (!this->T24EnvelopeStatus_)
            {
              this->T24EnvelopeStatus_.set (r);
              continue;
            }
          }

          // T24ExhaustAirChangesPerHour
          //
          if (n.name () == ""T24ExhaustAirChangesPerHour"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            if (!this->T24ExhaustAirChangesPerHour_)
            {
              this->T24ExhaustAirChangesPerHour_.set (T24ExhaustAirChangesPerHour_traits::create (i, f, this));
              continue;
            }
          }

          // T24ExhaustPerArea
          //
          if (n.name () == ""T24ExhaustPerArea"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            if (!this->T24ExhaustPerArea_)
            {
              this->T24ExhaustPerArea_.set (T24ExhaustPerArea_traits::create (i, f, this));
              continue;
            }
          }

          // T24ExhaustPerSpace
          //
          if (n.name () == ""T24ExhaustPerSpace"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            if (!this->T24ExhaustPerSpace_)
            {
              this->T24ExhaustPerSpace_.set (T24ExhaustPerSpace_traits::create (i, f, this));
              continue;
            }
          }

          // T24HasProcessExhaust
          //
          if (n.name () == ""T24HasProcessExhaust"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            if (!this->T24HasProcessExhaust_)
            {
              this->T24HasProcessExhaust_.set (T24HasProcessExhaust_traits::create (i, f, this));
              continue;
            }
          }

          // T24IntLightingSpecMethod
          //
          if (n.name () == ""T24IntLightingSpecMethod"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            ::std::auto_ptr< T24IntLightingSpecMethod_type > r (
              T24IntLightingSpecMethod_traits::create (i, f, this));

            if (!this->T24IntLightingSpecMethod_)
            {
              this->T24IntLightingSpecMethod_.set (r);
              continue;
            }
          }

          // T24KitchExhHoodDutyList
          //
          if (n.name () == ""T24KitchExhHoodDutyList"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            ::std::auto_ptr< T24KitchExhHoodDutyList_type > r (
              T24KitchExhHoodDutyList_traits::create (i, f, this));

            if (!this->T24KitchExhHoodDutyList_)
            {
              this->T24KitchExhHoodDutyList_.set (r);
              continue;
            }
          }

          // T24KitchExhHoodFlowList
          //
          if (n.name () == ""T24KitchExhHoodFlowList"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            ::std::auto_ptr< T24KitchExhHoodFlowList_type > r (
              T24KitchExhHoodFlowList_traits::create (i, f, this));

            if (!this->T24KitchExhHoodFlowList_)
            {
              this->T24KitchExhHoodFlowList_.set (r);
              continue;
            }
          }

          // T24KitchExhHoodLengthList
          //
          if (n.name () == ""T24KitchExhHoodLengthList"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            ::std::auto_ptr< T24KitchExhHoodLengthList_type > r (
              T24KitchExhHoodLengthList_traits::create (i, f, this));

            if (!this->T24KitchExhHoodLengthList_)
            {
              this->T24KitchExhHoodLengthList_.set (r);
              continue;
            }
          }

          // T24KitchExhHoodStyleList
          //
          if (n.name () == ""T24KitchExhHoodStyleList"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            ::std::auto_ptr< T24KitchExhHoodStyleList_type > r (
              T24KitchExhHoodStyleList_traits::create (i, f, this));

            if (!this->T24KitchExhHoodStyleList_)
            {
              this->T24KitchExhHoodStyleList_.set (r);
              continue;
            }
          }

          // T24LabExhRateType
          //
          if (n.name () == ""T24LabExhRateType"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            ::std::auto_ptr< T24LabExhRateType_type > r (
              T24LabExhRateType_traits::create (i, f, this));

            if (!this->T24LabExhRateType_)
            {
              this->T24LabExhRateType_.set (r);
              continue;
            }
          }

          // T24LightingStatus
          //
          if (n.name () == ""T24LightingStatus"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            ::std::auto_ptr< T24LightingStatus_type > r (
              T24LightingStatus_traits::create (i, f, this));

            if (!this->T24LightingStatus_)
            {
              this->T24LightingStatus_.set (r);
              continue;
            }
          }

          // T24MandLightCntrlCntRpt
          //
          if (n.name () == ""T24MandLightCntrlCntRpt"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            ::std::auto_ptr< T24MandLightCntrlCntRpt_type > r (
              T24MandLightCntrlCntRpt_traits::create (i, f, this));

            if (!this->T24MandLightCntrlCntRpt_)
            {
              this->T24MandLightCntrlCntRpt_.set (r);
              continue;
            }
          }

          // T24MandLightCntrlDescRpt
          //
          if (n.name () == ""T24MandLightCntrlDescRpt"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            ::std::auto_ptr< T24MandLightCntrlDescRpt_type > r (
              T24MandLightCntrlDescRpt_traits::create (i, f, this));

            if (!this->T24MandLightCntrlDescRpt_)
            {
              this->T24MandLightCntrlDescRpt_.set (r);
              continue;
            }
          }

          // T24MandLightCntrlAccepReqRpt
          //
          if (n.name () == ""T24MandLightCntrlAccepReqRpt"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            ::std::auto_ptr< T24MandLightCntrlAccepReqRpt_type > r (
              T24MandLightCntrlAccepReqRpt_traits::create (i, f, this));

            if (!this->T24MandLightCntrlAccepReqRpt_)
            {
              this->T24MandLightCntrlAccepReqRpt_.set (r);
              continue;
            }
          }

          // T24MandLightCntrlIsAutoShOffCntrlRpt
          //
          if (n.name () == ""T24MandLightCntrlIsAutoShOffCntrlRpt"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            ::std::auto_ptr< T24MandLightCntrlIsAutoShOffCntrlRpt_type > r (
              T24MandLightCntrlIsAutoShOffCntrlRpt_traits::create (i, f, this));

            if (!this->T24MandLightCntrlIsAutoShOffCntrlRpt_)
            {
              this->T24MandLightCntrlIsAutoShOffCntrlRpt_.set (r);
              continue;
            }
          }

          // T24MandLightCntrlIsDayltngCntrlRpt
          //
          if (n.name () == ""T24MandLightCntrlIsDayltngCntrlRpt"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            ::std::auto_ptr< T24MandLightCntrlIsDayltngCntrlRpt_type > r (
              T24MandLightCntrlIsDayltngCntrlRpt_traits::create (i, f, this));

            if (!this->T24MandLightCntrlIsDayltngCntrlRpt_)
            {
              this->T24MandLightCntrlIsDayltngCntrlRpt_.set (r);
              continue;
            }
          }

          // T24MandLightCntrlIsDmndRespCntrlRpt
          //
          if (n.name () == ""T24MandLightCntrlIsDmndRespCntrlRpt"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            ::std::auto_ptr< T24MandLightCntrlIsDmndRespCntrlRpt_type > r (
              T24MandLightCntrlIsDmndRespCntrlRpt_traits::create (i, f, this));

            if (!this->T24MandLightCntrlIsDmndRespCntrlRpt_)
            {
              this->T24MandLightCntrlIsDmndRespCntrlRpt_.set (r);
              continue;
            }
          }

          // T24MandLightCntrlIsManAreaCntrlRpt
          //
          if (n.name () == ""T24MandLightCntrlIsManAreaCntrlRpt"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            ::std::auto_ptr< T24MandLightCntrlIsManAreaCntrlRpt_type > r (
              T24MandLightCntrlIsManAreaCntrlRpt_traits::create (i, f, this));

            if (!this->T24MandLightCntrlIsManAreaCntrlRpt_)
            {
              this->T24MandLightCntrlIsManAreaCntrlRpt_.set (r);
              continue;
            }
          }

          // T24MandLightCntrlIsMultLvlCntrlRpt
          //
          if (n.name () == ""T24MandLightCntrlIsMultLvlCntrlRpt"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            ::std::auto_ptr< T24MandLightCntrlIsMultLvlCntrlRpt_type > r (
              T24MandLightCntrlIsMultLvlCntrlRpt_traits::create (i, f, this));

            if (!this->T24MandLightCntrlIsMultLvlCntrlRpt_)
            {
              this->T24MandLightCntrlIsMultLvlCntrlRpt_.set (r);
              continue;
            }
          }

          // T24SkylightRqmtExcep
          //
          if (n.name () == ""T24SkylightRqmtExcep"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            ::std::auto_ptr< T24SkylightRqmtExcep_type > r (
              T24SkylightRqmtExcep_traits::create (i, f, this));

            if (!this->T24SkylightRqmtExcep_)
            {
              this->T24SkylightRqmtExcep_.set (r);
              continue;
            }
          }

          // T24SpaceFunction
          //
          if (n.name () == ""T24SpaceFunction"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            ::std::auto_ptr< T24SpaceFunction_type > r (
              T24SpaceFunction_traits::create (i, f, this));

            if (!this->T24SpaceFunction_)
            {
              this->T24SpaceFunction_.set (r);
              continue;
            }
          }

          // T24ConstructStatus3
          //
          if (n.name () == ""T24ConstructStatus3"" && n.namespace_ () == ""http://d-alchemy.com/schema/simxml/BuildingModel"")
          {
            ::std::auto_ptr< T24ConstructStatus3_type > r (
              T24ConstructStatus3_traits::create (i, f, this));

            if (!this->T24ConstructStatus3_)
            {
              this->T24ConstructStatus3_.set (r);
              continue;
            }
          }

          break;
        }
      }

      SimSpace_Occupied* SimSpace_Occupied::
      _clone (::xml_schema::flags f,
              ::xml_schema::container* c) const
      {
        return new class SimSpace_Occupied (*this, f, c);
      }

      SimSpace_Occupied& SimSpace_Occupied::
      operator= (const SimSpace_Occupied& x)
      {
        if (this != &x)
        {
          static_cast< ::schema::simxml::BuildingModel::SimSpace& > (*this) = x;
          this->T24CommRefrigEPD_ = x.T24CommRefrigEPD_;
          this->T24CommRefrigEqmtSchedRef_ = x.T24CommRefrigEqmtSchedRef_;
          this->T24CommRefrigLatentFraction_ = x.T24CommRefrigLatentFraction_;
          this->T24CommRefrigLostFraction_ = x.T24CommRefrigLostFraction_;
          this->T24CommRefrigRadFraction_ = x.T24CommRefrigRadFraction_;
          this->T24EnvelopeStatus_ = x.T24EnvelopeStatus_;
          this->T24ExhaustAirChangesPerHour_ = x.T24ExhaustAirChangesPerHour_;
          this->T24ExhaustPerArea_ = x.T24ExhaustPerArea_;
          this->T24ExhaustPerSpace_ = x.T24ExhaustPerSpace_;
          this->T24HasProcessExhaust_ = x.T24HasProcessExhaust_;
          this->T24IntLightingSpecMethod_ = x.T24IntLightingSpecMethod_;
          this->T24KitchExhHoodDutyList_ = x.T24KitchExhHoodDutyList_;
          this->T24KitchExhHoodFlowList_ = x.T24KitchExhHoodFlowList_;
          this->T24KitchExhHoodLengthList_ = x.T24KitchExhHoodLengthList_;
          this->T24KitchExhHoodStyleList_ = x.T24KitchExhHoodStyleList_;
          this->T24LabExhRateType_ = x.T24LabExhRateType_;
          this->T24LightingStatus_ = x.T24LightingStatus_;
          this->T24MandLightCntrlCntRpt_ = x.T24MandLightCntrlCntRpt_;
          this->T24MandLightCntrlDescRpt_ = x.T24MandLightCntrlDescRpt_;
          this->T24MandLightCntrlAccepReqRpt_ = x.T24MandLightCntrlAccepReqRpt_;
          this->T24MandLightCntrlIsAutoShOffCntrlRpt_ = x.T24MandLightCntrlIsAutoShOffCntrlRpt_;
          this->T24MandLightCntrlIsDayltngCntrlRpt_ = x.T24MandLightCntrlIsDayltngCntrlRpt_;
          this->T24MandLightCntrlIsDmndRespCntrlRpt_ = x.T24MandLightCntrlIsDmndRespCntrlRpt_;
          this->T24MandLightCntrlIsManAreaCntrlRpt_ = x.T24MandLightCntrlIsManAreaCntrlRpt_;
          this->T24MandLightCntrlIsMultLvlCntrlRpt_ = x.T24MandLightCntrlIsMultLvlCntrlRpt_;
          this->T24SkylightRqmtExcep_ = x.T24SkylightRqmtExcep_;
          this->T24SpaceFunction_ = x.T24SpaceFunction_;
          this->T24ConstructStatus3_ = x.T24ConstructStatus3_;
        }

        return *this;
      }

      SimSpace_Occupied::
      ~SimSpace_Occupied ()
      {
      }
    }
  }
}

#include <istream>
#include <xsd/cxx/xml/sax/std-input-source.hxx>
#include <xsd/cxx/tree/error-handler.hxx>

namespace schema
{
  namespace simxml
  {
    namespace BuildingModel
    {
    }
  }
}

#include <xsd/cxx/post.hxx>

// Begin epilogue.
//
//
// End epilogue.

",16361,True,4001.838684596476,median
"[[netty-component]]
= Netty Component
:page-source: components/camel-netty/src/main/docs/netty-component.adoc

*Available as of Camel version 2.14*

The Netty component in Camel is a socket communication component,
based on the http://netty.io/[Netty] project version 4. +
 Netty is a NIO client server framework which enables quick and easy
development of networkServerInitializerFactory applications such as
protocol servers and clients. +
 Netty greatly simplifies and streamlines network programming such as
TCP and UDP socket server.

This camel component supports both producer and consumer endpoints.

The Netty component has several options and allows fine-grained control
of a number of TCP/UDP communication parameters (buffer sizes,
keepAlives, tcpNoDelay, etc) and facilitates both In-Only and In-Out
communication on a Camel route.

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-netty</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>
----

== URI format

The URI scheme for a netty component is as follows

[source,text]
----
netty:tcp://0.0.0.0:99999[?options]
netty:udp://remotehost:99999/[?options]
----

This component supports producer and consumer endpoints for both TCP and
UDP.

You can append query options to the URI in the following format,
`?option=value&option=value&...`

== Options

// component options: START
The Netty component supports 6 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *maximumPoolSize* (advanced) | The thread pool size for the EventExecutorGroup if its in use. The default value is 16. | 16 | int
| *configuration* (advanced) | To use the NettyConfiguration as configuration when creating endpoints. |  | NettyConfiguration
| *executorService* (advanced) | To use the given EventExecutorGroup. |  | EventExecutorGroup
| *useGlobalSslContext Parameters* (security) | Enable usage of global SSL context parameters. | false | boolean
| *sslContextParameters* (security) | To configure security using SSLContextParameters |  | SSLContextParameters
| *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 Netty endpoint is configured using URI syntax:

----
netty:protocol:host:port
----

with the following path and query parameters:

=== Path Parameters (3 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *protocol* | *Required* The protocol to use which can be tcp or udp. |  | String
| *host* | *Required* The hostname. For the consumer the hostname is localhost or 0.0.0.0. For the producer the hostname is the remote host to connect to |  | String
| *port* | *Required* The host port number |  | int
|===


=== Query Parameters (71 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *disconnect* (common) | Whether or not to disconnect(close) from Netty Channel right after use. Can be used for both consumer and producer. | false | boolean
| *keepAlive* (common) | Setting to ensure socket is not closed due to inactivity | true | boolean
| *reuseAddress* (common) | Setting to facilitate socket multiplexing | true | boolean
| *reuseChannel* (common) | This option allows producers and consumers (in client mode) to reuse the same Netty Channel for the lifecycle of processing the Exchange. This is useful if you need to call a server multiple times in a Camel route and want to use the same network connection. When using this, the channel is not returned to the connection pool until the Exchange is done; or disconnected if the disconnect option is set to true. The reused Channel is stored on the Exchange as an exchange property with the key NettyConstants#NETTY_CHANNEL which allows you to obtain the channel during routing and use it as well. | false | boolean
| *sync* (common) | Setting to set endpoint as one-way or request-response | true | boolean
| *tcpNoDelay* (common) | Setting to improve TCP protocol performance | true | 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
| *broadcast* (consumer) | Setting to choose Multicast over UDP | false | boolean
| *clientMode* (consumer) | If the clientMode is true, netty consumer will connect the address as a TCP client. | false | boolean
| *reconnect* (consumer) | Used only in clientMode in consumer, the consumer will attempt to reconnect on disconnection if this is enabled | true | boolean
| *reconnectInterval* (consumer) | Used if reconnect and clientMode is enabled. The interval in milli seconds to attempt reconnection | 10000 | int
| *backlog* (consumer) | Allows to configure a backlog for netty consumer (server). Note the backlog is just a best effort depending on the OS. Setting this option to a value such as 200, 500 or 1000, tells the TCP stack how long the accept queue can be If this option is not configured, then the backlog depends on OS setting. |  | int
| *bossCount* (consumer) | When netty works on nio mode, it uses default bossCount parameter from Netty, which is 1. User can use this operation to override the default bossCount from Netty | 1 | int
| *bossGroup* (consumer) | Set the BossGroup which could be used for handling the new connection of the server side across the NettyEndpoint |  | EventLoopGroup
| *disconnectOnNoReply* (consumer) | If sync is enabled then this option dictates NettyConsumer if it should disconnect where there is no reply to send back. | true | 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
| *nettyServerBootstrapFactory* (consumer) | To use a custom NettyServerBootstrapFactory |  | NettyServerBootstrapFactory
| *networkInterface* (consumer) | When using UDP then this option can be used to specify a network interface by its name, such as eth0 to join a multicast group. |  | String
| *noReplyLogLevel* (consumer) | If sync is enabled this option dictates NettyConsumer which logging level to use when logging a there is no reply to send back. | WARN | LoggingLevel
| *serverClosedChannel ExceptionCaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an java.nio.channels.ClosedChannelException then its logged using this logging level. This is used to avoid logging the closed channel exceptions, as clients can disconnect abruptly and then cause a flood of closed exceptions in the Netty server. | DEBUG | LoggingLevel
| *serverExceptionCaughtLog Level* (consumer) | If the server (NettyConsumer) catches an exception then its logged using this logging level. | WARN | LoggingLevel
| *serverInitializerFactory* (consumer) | To use a custom ServerInitializerFactory |  | ServerInitializerFactory
| *usingExecutorService* (consumer) | Whether to use ordered thread pool, to ensure events are processed orderly on the same channel. | true | boolean
| *connectTimeout* (producer) | Time to wait for a socket connection to be available. Value is in milliseconds. | 10000 | int
| *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
| *requestTimeout* (producer) | Allows to use a timeout for the Netty producer when calling a remote server. By default no timeout is in use. The value is in milli seconds, so eg 30000 is 30 seconds. The requestTimeout is using Netty's ReadTimeoutHandler to trigger the timeout. |  | long
| *clientInitializerFactory* (producer) | To use a custom ClientInitializerFactory |  | ClientInitializerFactory
| *correlationManager* (producer) | To use a custom correlation manager to manage how request and reply messages are mapped when using request/reply with the netty producer. This should only be used if you have a way to map requests together with replies such as if there is correlation ids in both the request and reply messages. This can be used if you want to multiplex concurrent messages on the same channel (aka connection) in netty. When doing this you must have a way to correlate the request and reply messages so you can store the right reply on the inflight Camel Exchange before its continued routed. We recommend extending the TimeoutCorrelationManagerSupport when you build custom correlation managers. This provides support for timeout and other complexities you otherwise would need to implement as well. See also the producerPoolEnabled option for more details. |  | NettyCamelStateCorrelationManager
| *lazyChannelCreation* (producer) | Channels can be lazily created to avoid exceptions, if the remote server is not up and running when the Camel producer is started. | true | boolean
| *producerPoolEnabled* (producer) | Whether producer pool is enabled or not. Important: If you turn this off then a single shared connection is used for the producer, also if you are doing request/reply. That means there is a potential issue with interleaved responses if replies comes back out-of-order. Therefore you need to have a correlation id in both the request and reply messages so you can properly correlate the replies to the Camel callback that is responsible for continue processing the message in Camel. To do this you need to implement NettyCamelStateCorrelationManager as correlation manager and configure it via the correlationManager option. See also the correlationManager option for more details. | true | boolean
| *producerPoolMaxActive* (producer) | Sets the cap on the number of objects that can be allocated by the pool (checked out to clients, or idle awaiting checkout) at a given time. Use a negative value for no limit. | -1 | int
| *producerPoolMaxIdle* (producer) | Sets the cap on the number of idle instances in the pool. | 100 | int
| *producerPoolMinEvictable Idle* (producer) | Sets the minimum amount of time (value in millis) an object may sit idle in the pool before it is eligible for eviction by the idle object evictor. | 300000 | long
| *producerPoolMinIdle* (producer) | Sets the minimum number of instances allowed in the producer pool before the evictor thread (if active) spawns new objects. |  | int
| *udpConnectionlessSending* (producer) | This option supports connection less udp sending which is a real fire and forget. A connected udp send receive the PortUnreachableException if no one is listen on the receiving port. | false | boolean
| *useByteBuf* (producer) | If the useByteBuf is true, netty producer will turn the message body into ByteBuf before sending it out. | false | boolean
| *allowSerializedHeaders* (advanced) | Only used for TCP when transferExchange is true. When set to true, serializable objects in headers and properties will be added to the exchange. Otherwise Camel will exclude any non-serializable objects and log it at WARN level. | 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
| *channelGroup* (advanced) | To use a explicit ChannelGroup. |  | ChannelGroup
| *nativeTransport* (advanced) | Whether to use native transport instead of NIO. Native transport takes advantage of the host operating system and is only supported on some platforms. You need to add the netty JAR for the host operating system you are using. See more details at: \\http://netty.io/wiki/native-transports.html | false | boolean
| *options* (advanced) | Allows to configure additional netty options using option. as prefix. For example option.child.keepAlive=false to set the netty option child.keepAlive=false. See the Netty documentation for possible options that can be used. |  | Map
| *receiveBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during inbound communication. Size is bytes. | 65536 | int
| *receiveBufferSizePredictor* (advanced) | Configures the buffer size predictor. See details at Jetty documentation and this mail thread. |  | int
| *sendBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during outbound communication. Size is bytes. | 65536 | int
| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported). | false | boolean
| *transferExchange* (advanced) | Only used for TCP. You can transfer the exchange over the wire instead of just the body. The following fields are transferred: In body, Out body, fault body, In headers, Out headers, fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *udpByteArrayCodec* (advanced) | For UDP only. If enabled the using byte array codec instead of Java serialization protocol. | false | boolean
| *workerCount* (advanced) | When netty works on nio mode, it uses default workerCount parameter from Netty, which is cpu_core_threads x 2. User can use this operation to override the default workerCount from Netty. |  | int
| *workerGroup* (advanced) | To use a explicit EventLoopGroup as the boss thread pool. For example to share a thread pool with multiple consumers or producers. By default each consumer or producer has their own worker pool with 2 x cpu count core threads. |  | EventLoopGroup
| *allowDefaultCodec* (codec) | The netty component installs a default codec if both, encoder/decoder is null and textline is false. Setting allowDefaultCodec to false prevents the netty component from installing a default codec as the first element in the filter chain. | true | boolean
| *autoAppendDelimiter* (codec) | Whether or not to auto append missing end delimiter when sending using the textline codec. | true | boolean
| *decoderMaxLineLength* (codec) | The max line length to use for the textline codec. | 1024 | int
| *decoders* (codec) | A list of decoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *delimiter* (codec) | The delimiter to use for the textline codec. Possible values are LINE and NULL. | LINE | TextLineDelimiter
| *encoders* (codec) | A list of encoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *encoding* (codec) | The encoding (a charset name) to use for the textline codec. If not provided, Camel will use the JVM default Charset. |  | String
| *textline* (codec) | Only used for TCP. If no codec is specified, you can use this flag to indicate a text line based codec; if not specified or the value is false, then Object Serialization is assumed over TCP. | false | boolean
| *enabledProtocols* (security) | Which protocols to enable when using SSL | TLSv1,TLSv1.1,TLSv1.2 | String
| *keyStoreFile* (security) | Client side certificate keystore to be used for encryption |  | File
| *keyStoreFormat* (security) | Keystore format to be used for payload encryption. Defaults to JKS if not set |  | String
| *keyStoreResource* (security) | Client side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
| *needClientAuth* (security) | Configures whether the server needs client authentication when using SSL. | false | boolean
| *passphrase* (security) | Password setting to use in order to encrypt/decrypt payloads sent using SSH |  | String
| *securityProvider* (security) | Security provider to be used for payload encryption. Defaults to SunX509 if not set. |  | String
| *ssl* (security) | Setting to specify whether SSL encryption is applied to this endpoint | false | boolean
| *sslClientCertHeaders* (security) | When enabled and in SSL mode, then the Netty consumer will enrich the Camel Message with headers having information about the client certificate such as subject name, issuer name, serial number, and the valid date range. | false | boolean
| *sslContextParameters* (security) | To configure security using SSLContextParameters |  | SSLContextParameters
| *sslHandler* (security) | Reference to a class that could be used to return an SSL Handler |  | SslHandler
| *trustStoreFile* (security) | Server side certificate keystore to be used for encryption |  | File
| *trustStoreResource* (security) | Server side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
|===
// 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-netty-starter</artifactId>
  <version>x.x.x</version>
  <!-- use the same version as your Camel core version -->
</dependency>
----


The component supports 78 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *camel.component.netty.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.netty.configuration.allow-default-codec* | The netty component installs a default codec if both, encoder/decoder is null and textline is false. Setting allowDefaultCodec to false prevents the netty component from installing a default codec as the first element in the filter chain. | true | Boolean
| *camel.component.netty.configuration.allow-serialized-headers* | Only used for TCP when transferExchange is true. When set to true, serializable objects in headers and properties will be added to the exchange. Otherwise Camel will exclude any non-serializable objects and log it at WARN level. | false | Boolean
| *camel.component.netty.configuration.auto-append-delimiter* | Whether or not to auto append missing end delimiter when sending using the textline codec. | true | Boolean
| *camel.component.netty.configuration.backlog* | Allows to configure a backlog for netty consumer (server). Note the backlog is just a best effort depending on the OS. Setting this option to a value such as 200, 500 or 1000, tells the TCP stack how long the ""accept"" queue can be If this option is not configured, then the backlog depends on OS setting. |  | Integer
| *camel.component.netty.configuration.boss-count* | When netty works on nio mode, it uses default bossCount parameter from Netty, which is 1. User can use this operation to override the default bossCount from Netty | 1 | Integer
| *camel.component.netty.configuration.boss-group* | Set the BossGroup which could be used for handling the new connection of the server side across the NettyEndpoint |  | EventLoopGroup
| *camel.component.netty.configuration.broadcast* | Setting to choose Multicast over UDP | false | Boolean
| *camel.component.netty.configuration.channel-group* | To use a explicit ChannelGroup. |  | ChannelGroup
| *camel.component.netty.configuration.client-initializer-factory* | To use a custom ClientInitializerFactory |  | ClientInitializerFactory
| *camel.component.netty.configuration.client-mode* | If the clientMode is true, netty consumer will connect the address as a TCP client. | false | Boolean
| *camel.component.netty.configuration.connect-timeout* | Time to wait for a socket connection to be available. Value is in milliseconds. | 10000 | Integer
| *camel.component.netty.configuration.correlation-manager* | To use a custom correlation manager to manage how request and reply messages are mapped when using request/reply with the netty producer. This should only be used if you have a way to map requests together with replies such as if there is correlation ids in both the request and reply messages. This can be used if you want to multiplex concurrent messages on the same channel (aka connection) in netty. When doing this you must have a way to correlate the request and reply messages so you can store the right reply on the inflight Camel Exchange before its continued routed. <p/> We recommend extending the {@link TimeoutCorrelationManagerSupport} when you build custom correlation managers. This provides support for timeout and other complexities you otherwise would need to implement as well. <p/> See also the <tt>producerPoolEnabled</tt> option for more details. |  | NettyCamelStateCorrelationManager
| *camel.component.netty.configuration.decoder* | A custom ChannelHandler class that can be used to perform special marshalling of inbound payloads. |  | ChannelHandler
| *camel.component.netty.configuration.decoder-max-line-length* | The max line length to use for the textline codec. | 1024 | Integer
| *camel.component.netty.configuration.decoders* | A list of decoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *camel.component.netty.configuration.delimiter* | The delimiter to use for the textline codec. Possible values are LINE and NULL. |  | TextLineDelimiter
| *camel.component.netty.configuration.disconnect* | Whether or not to disconnect(close) from Netty Channel right after use. Can be used for both consumer and producer. | false | Boolean
| *camel.component.netty.configuration.disconnect-on-no-reply* | If sync is enabled then this option dictates NettyConsumer if it should disconnect where there is no reply to send back. | true | Boolean
| *camel.component.netty.configuration.enabled-protocols* | Which protocols to enable when using SSL | TLSv1,TLSv1.1,TLSv1.2 | String
| *camel.component.netty.configuration.encoder* | A custom ChannelHandler class that can be used to perform special marshalling of outbound payloads. |  | ChannelHandler
| *camel.component.netty.configuration.encoders* | A list of encoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *camel.component.netty.configuration.encoding* | The encoding (a charset name) to use for the textline codec. If not provided, Camel will use the JVM default Charset. |  | String
| *camel.component.netty.configuration.host* | The hostname. <p/> For the consumer the hostname is localhost or 0.0.0.0. For the producer the hostname is the remote host to connect to |  | String
| *camel.component.netty.configuration.keep-alive* | Setting to ensure socket is not closed due to inactivity | true | Boolean
| *camel.component.netty.configuration.key-store-format* | Keystore format to be used for payload encryption. Defaults to ""JKS"" if not set |  | String
| *camel.component.netty.configuration.key-store-resource* | Client side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with ""classpath:"", ""file:"", or ""http:"" to load the resource from different systems. |  | String
| *camel.component.netty.configuration.lazy-channel-creation* | Channels can be lazily created to avoid exceptions, if the remote server is not up and running when the Camel producer is started. | true | Boolean
| *camel.component.netty.configuration.native-transport* | Whether to use native transport instead of NIO. Native transport takes advantage of the host operating system and is only supported on some platforms. You need to add the netty JAR for the host operating system you are using. See more details at: \\http://netty.io/wiki/native-transports.html | false | Boolean
| *camel.component.netty.configuration.need-client-auth* | Configures whether the server needs client authentication when using SSL. | false | Boolean
| *camel.component.netty.configuration.netty-server-bootstrap-factory* | To use a custom NettyServerBootstrapFactory |  | NettyServerBootstrapFactory
| *camel.component.netty.configuration.network-interface* | When using UDP then this option can be used to specify a network interface by its name, such as eth0 to join a multicast group. |  | String
| *camel.component.netty.configuration.no-reply-log-level* | If sync is enabled this option dictates NettyConsumer which logging level to use when logging a there is no reply to send back. |  | LoggingLevel
| *camel.component.netty.configuration.options* | Allows to configure additional netty options using ""option."" as prefix. For example ""option.child.keepAlive=false"" to set the netty option ""child.keepAlive=false"". See the Netty documentation for possible options that can be used. |  | Map
| *camel.component.netty.configuration.passphrase* | Password setting to use in order to encrypt/decrypt payloads sent using SSH |  | String
| *camel.component.netty.configuration.port* | The host port number |  | Integer
| *camel.component.netty.configuration.producer-pool-enabled* | Whether producer pool is enabled or not. Important: If you turn this off then a single shared connection is used for the producer, also if you are doing request/reply. That means there is a potential issue with interleaved responses if replies comes back out-of-order. Therefore you need to have a correlation id in both the request and reply messages so you can properly correlate the replies to the Camel callback that is responsible for continue processing the message in Camel. To do this you need to implement {@link NettyCamelStateCorrelationManager} as correlation manager and configure it via the <tt>correlationManager</tt> option. <p/> See also the <tt>correlationManager</tt> option for more details. | true | Boolean
| *camel.component.netty.configuration.producer-pool-max-active* | Sets the cap on the number of objects that can be allocated by the pool (checked out to clients, or idle awaiting checkout) at a given time. Use a negative value for no limit. | -1 | Integer
| *camel.component.netty.configuration.producer-pool-max-idle* | Sets the cap on the number of ""idle"" instances in the pool. | 100 | Integer
| *camel.component.netty.configuration.producer-pool-min-evictable-idle* | Sets the minimum amount of time (value in millis) an object may sit idle in the pool before it is eligible for eviction by the idle object evictor. | 300000 | Long
| *camel.component.netty.configuration.producer-pool-min-idle* | Sets the minimum number of instances allowed in the producer pool before the evictor thread (if active) spawns new objects. |  | Integer
| *camel.component.netty.configuration.protocol* | The protocol to use which can be tcp or udp. |  | String
| *camel.component.netty.configuration.receive-buffer-size* | The TCP/UDP buffer sizes to be used during inbound communication. Size is bytes. | 65536 | Integer
| *camel.component.netty.configuration.receive-buffer-size-predictor* | Configures the buffer size predictor. See details at Jetty documentation and this mail thread. |  | Integer
| *camel.component.netty.configuration.reconnect* | Used only in clientMode in consumer, the consumer will attempt to reconnect on disconnection if this is enabled | true | Boolean
| *camel.component.netty.configuration.reconnect-interval* | Used if reconnect and clientMode is enabled. The interval in milli seconds to attempt reconnection | 10000 | Integer
| *camel.component.netty.configuration.request-timeout* | Allows to use a timeout for the Netty producer when calling a remote server. By default no timeout is in use. The value is in milli seconds, so eg 30000 is 30 seconds. The requestTimeout is using Netty's ReadTimeoutHandler to trigger the timeout. |  | Long
| *camel.component.netty.configuration.reuse-address* | Setting to facilitate socket multiplexing | true | Boolean
| *camel.component.netty.configuration.reuse-channel* | This option allows producers and consumers (in client mode) to reuse the same Netty {@link Channel} for the lifecycle of processing the {@link Exchange}. This is useful if you need to call a server multiple times in a Camel route and want to use the same network connection. When using this, the channel is not returned to the connection pool until the {@link Exchange} is done; or disconnected if the disconnect option is set to true. <p/> The reused {@link Channel} is stored on the {@link Exchange} as an exchange property with the key {@link NettyConstants#NETTY_CHANNEL} which allows you to obtain the channel during routing and use it as well. | false | Boolean
| *camel.component.netty.configuration.security-provider* | Security provider to be used for payload encryption. Defaults to ""SunX509"" if not set. |  | String
| *camel.component.netty.configuration.send-buffer-size* | The TCP/UDP buffer sizes to be used during outbound communication. Size is bytes. | 65536 | Integer
| *camel.component.netty.configuration.server-closed-channel-exception-caught-log-level* | If the server (NettyConsumer) catches an java.nio.channels.ClosedChannelException then its logged using this logging level. This is used to avoid logging the closed channel exceptions, as clients can disconnect abruptly and then cause a flood of closed exceptions in the Netty server. |  | LoggingLevel
| *camel.component.netty.configuration.server-exception-caught-log-level* | If the server (NettyConsumer) catches an exception then its logged using this logging level. |  | LoggingLevel
| *camel.component.netty.configuration.server-initializer-factory* | To use a custom ServerInitializerFactory |  | ServerInitializerFactory
| *camel.component.netty.configuration.ssl* | Setting to specify whether SSL encryption is applied to this endpoint | false | Boolean
| *camel.component.netty.configuration.ssl-client-cert-headers* | When enabled and in SSL mode, then the Netty consumer will enrich the Camel Message with headers having information about the client certificate such as subject name, issuer name, serial number, and the valid date range. | false | Boolean
| *camel.component.netty.configuration.ssl-context-parameters* | To configure security using SSLContextParameters |  | SSLContextParameters
| *camel.component.netty.configuration.ssl-handler* | Reference to a class that could be used to return an SSL Handler |  | SslHandler
| *camel.component.netty.configuration.sync* | Setting to set endpoint as one-way or request-response | true | Boolean
| *camel.component.netty.configuration.tcp-no-delay* | Setting to improve TCP protocol performance | true | Boolean
| *camel.component.netty.configuration.textline* | Only used for TCP. If no codec is specified, you can use this flag to indicate a text line based codec; if not specified or the value is false, then Object Serialization is assumed over TCP. | false | Boolean
| *camel.component.netty.configuration.transfer-exchange* | Only used for TCP. You can transfer the exchange over the wire instead of just the body. The following fields are transferred: In body, Out body, fault body, In headers, Out headers, fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. | false | Boolean
| *camel.component.netty.configuration.trust-store-resource* | Server side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with ""classpath:"", ""file:"", or ""http:"" to load the resource from different systems. |  | String
| *camel.component.netty.configuration.udp-byte-array-codec* | For UDP only. If enabled the using byte array codec instead of Java serialization protocol. | false | Boolean
| *camel.component.netty.configuration.udp-connectionless-sending* | This option supports connection less udp sending which is a real fire and forget. A connected udp send receive the PortUnreachableException if no one is listen on the receiving port. | false | Boolean
| *camel.component.netty.configuration.use-byte-buf* | If the useByteBuf is true, netty producer will turn the message body into {@link ByteBuf} before sending it out. | false | Boolean
| *camel.component.netty.configuration.using-executor-service* | Whether to use ordered thread pool, to ensure events are processed orderly on the same channel. | true | Boolean
| *camel.component.netty.configuration.worker-count* | When netty works on nio mode, it uses default workerCount parameter from Netty, which is cpu_core_threads x 2. User can use this operation to override the default workerCount from Netty. |  | Integer
| *camel.component.netty.configuration.worker-group* | To use a explicit EventLoopGroup as the boss thread pool. For example to share a thread pool with multiple consumers or producers. By default each consumer or producer has their own worker pool with 2 x cpu count core threads. |  | EventLoopGroup
| *camel.component.netty.enabled* | Whether to enable auto configuration of the netty component. This is enabled by default. |  | Boolean
| *camel.component.netty.executor-service* | To use the given EventExecutorGroup. The option is a io.netty.util.concurrent.EventExecutorGroup type. |  | String
| *camel.component.netty.maximum-pool-size* | The thread pool size for the EventExecutorGroup if its in use. The default value is 16. | 16 | Integer
| *camel.component.netty.ssl-context-parameters* | To configure security using SSLContextParameters. The option is a org.apache.camel.support.jsse.SSLContextParameters type. |  | String
| *camel.component.netty.use-global-ssl-context-parameters* | Enable usage of global SSL context parameters. | false | Boolean
| *camel.component.netty.configuration.client-pipeline-factory* | *Deprecated*  |  | ClientInitializerFactory
| *camel.component.netty.configuration.key-store-file* | *Deprecated* Client side certificate keystore to be used for encryption |  | File
| *camel.component.netty.configuration.server-pipeline-factory* | *Deprecated*  |  | ServerInitializerFactory
| *camel.component.netty.configuration.trust-store-file* | *Deprecated* Server side certificate keystore to be used for encryption |  | File
|===
// spring-boot-auto-configure options: END



== Registry based Options

Codec Handlers and SSL Keystores can be enlisted in the Registry, such as in the Spring XML file.
The values that could be passed in, are the following:

[width=""100%"",cols=""10%,90%"",options=""header"",]
|===
|Name |Description

|`passphrase` |password setting to use in order to encrypt/decrypt payloads sent using
SSH

|`keyStoreFormat` |keystore format to be used for payload encryption. Defaults to ""JKS"" if
not set

|`securityProvider` |Security provider to be used for payload encryption. Defaults to
""SunX509"" if not set.

|`keyStoreFile` |*deprecated:* Client side certificate keystore to be used for encryption

|`trustStoreFile` |*deprecated:* Server side certificate keystore to be used for encryption

|`keyStoreResource` |Client side certificate keystore to be used for
encryption. Is loaded by default from classpath, but you can prefix with
`""classpath:""`, `""file:""`, or `""http:""` to load the resource from
different systems.

|`trustStoreResource` |Server side certificate keystore to be used for
encryption. Is loaded by default from classpath, but you can prefix with
`""classpath:""`, `""file:""`, or `""http:""` to load the resource from
different systems.

|`sslHandler` |Reference to a class that could be used to return an SSL Handler

|`encoder` |A custom `ChannelHandler` class that can be used to perform special
marshalling of outbound payloads. Must override
io.netty.channel.ChannelInboundHandlerAdapter.

|`encoders` |A list of encoders to be used. You can use a String which have values
separated by comma, and have the values be looked up in the
Registry. Just remember to prefix the value with #
so Camel knows it should lookup.

|`decoder` |A custom `ChannelHandler` class that can be used to perform special
marshalling of inbound payloads. Must override
io.netty.channel.ChannelOutboundHandlerAdapter.

|`decoders` |A list of decoders to be used. You can use a String which have values
separated by comma, and have the values be looked up in the
Registry. Just remember to prefix the value with #
so Camel knows it should lookup.
|===

NOTE: Read below about using non shareable encoders/decoders.

=== Using non shareable encoders or decoders

If your encoders or decoders are not shareable (e.g. they don't have the
@Shareable class annotation), then your encoder/decoder must implement
the `org.apache.camel.component.netty.ChannelHandlerFactory` interface,
and return a new instance in the `newChannelHandler` method. This is to
ensure the encoder/decoder can safely be used. If this is not the case,
then the Netty component will log a WARN when an endpoint is created.

The Netty component offers a
`org.apache.camel.component.netty.ChannelHandlerFactories` factory
class, that has a number of commonly used methods.

== Sending Messages to/from a Netty endpoint

=== Netty Producer

In Producer mode, the component provides the ability to send payloads to
a socket endpoint using either TCP or UDP protocols (with optional SSL support).

The producer mode supports both one-way and request-response based operations.

=== Netty Consumer

In Consumer mode, the component provides the ability to:

* listen on a specified socket using either TCP or UDP protocols (with
optional SSL support),
* receive requests on the socket using text/xml, binary and serialized
object based payloads and
* send them along on a route as message exchanges.

The consumer mode supports both one-way and request-response based
operations.

== Examples

=== A UDP Netty endpoint using Request-Reply and serialized object payload

[source,java]
----
RouteBuilder builder = new RouteBuilder() {
  public void configure() {
    from(""netty:udp://0.0.0.0:5155?sync=true"")
      .process(new Processor() {
         public void process(Exchange exchange) throws Exception {
           Poetry poetry = (Poetry) exchange.getIn().getBody();
           poetry.setPoet(""Dr. Sarojini Naidu"");
           exchange.getOut().setBody(poetry);
         }
       }
    }
};
----

=== A TCP based Netty consumer endpoint using One-way communication

[source,java]
----
RouteBuilder builder = new RouteBuilder() {
  public void configure() {
       from(""netty:tcp://0.0.0.0:5150"")
           .to(""mock:result"");
  }
};
----

=== An SSL/TCP based Netty consumer endpoint using Request-Reply communication

[[Netty-UsingtheJSSEConfigurationUtility]]
Using the JSSE Configuration Utility

The Netty component supports SSL/TLS configuration
through the xref:manual::camel-configuration-utilities.adoc[Camel JSSE
Configuration Utility].  This utility greatly decreases the amount of
component specific code you need to write and is configurable at the
endpoint and component levels.  The following examples demonstrate how
to use the utility with the Netty component.

[[Netty-Programmaticconfigurationofthecomponent]]
Programmatic configuration of the component

[source,java]
----
KeyStoreParameters ksp = new KeyStoreParameters();
ksp.setResource(""/users/home/server/keystore.jks"");
ksp.setPassword(""keystorePassword"");

KeyManagersParameters kmp = new KeyManagersParameters();
kmp.setKeyStore(ksp);
kmp.setKeyPassword(""keyPassword"");

SSLContextParameters scp = new SSLContextParameters();
scp.setKeyManagers(kmp);

NettyComponent nettyComponent = getContext().getComponent(""netty"", NettyComponent.class);
nettyComponent.setSslContextParameters(scp);
----

[[Netty-SpringDSLbasedconfigurationofendpoint]]
Spring DSL based configuration of endpoint

[source,xml]
----
...
  <camel:sslContextParameters
      id=""sslContextParameters"">
    <camel:keyManagers
        keyPassword=""keyPassword"">
      <camel:keyStore
          resource=""/users/home/server/keystore.jks""
          password=""keystorePassword""/>
    </camel:keyManagers>
  </camel:sslContextParameters>...
...
  <to uri=""netty:tcp://0.0.0.0:5150?sync=true&ssl=true&sslContextParameters=#sslContextParameters""/>
...
----

[[Netty-UsingBasicSSL/TLSconfigurationontheJettyComponent]]
Using Basic SSL/TLS configuration on the Jetty Component

[source,java]
----
Registry registry = context.getRegistry();
registry.bind(""password"", ""changeit"");
registry.bind(""ksf"", new File(""src/test/resources/keystore.jks""));
registry.bind(""tsf"", new File(""src/test/resources/keystore.jks""));

context.addRoutes(new RouteBuilder() {
  public void configure() {
      String netty_ssl_endpoint =
         ""netty:tcp://0.0.0.0:5150?sync=true&ssl=true&passphrase=#password""
         + ""&keyStoreFile=#ksf&trustStoreFile=#tsf"";
      String return_string =
         ""When You Go Home, Tell Them Of Us And Say,""
         + ""For Your Tomorrow, We Gave Our Today."";

      from(netty_ssl_endpoint)
       .process(new Processor() {
          public void process(Exchange exchange) throws Exception {
            exchange.getOut().setBody(return_string);
          }
       }
  }
});
----

[[Netty-GettingaccesstoSSLSessionandtheclientcertificate]]
Getting access to SSLSession and the client certificate

You can get access to the `javax.net.ssl.SSLSession` if you eg need to
get details about the client certificate. When `ssl=true` then the
xref:netty-component.adoc[Netty] component will store the `SSLSession` as a
header on the Camel Message as shown below:

[source,java]
----
SSLSession session = exchange.getIn().getHeader(NettyConstants.NETTY_SSL_SESSION, SSLSession.class);
// get the first certificate which is client certificate
javax.security.cert.X509Certificate cert = session.getPeerCertificateChain()[0];
Principal principal = cert.getSubjectDN();
----

Remember to set `needClientAuth=true` to authenticate the client,
otherwise `SSLSession` cannot access information about the client
certificate, and you may get an exception
`javax.net.ssl.SSLPeerUnverifiedException: peer not authenticated`. You
may also get this exception if the client certificate is expired or not
valid etc.

TIP: The option `sslClientCertHeaders` can be set to `true` which then
enriches the Camel Message with headers having
details about the client certificate. For example the subject name is
readily available in the header `CamelNettySSLClientCertSubjectName`.

=== Using Multiple Codecs

In certain cases it may be necessary to add chains of encoders and
decoders to the netty pipeline. To add multpile codecs to a camel netty
endpoint the 'encoders' and 'decoders' uri parameters should be used.
Like the 'encoder' and 'decoder' parameters they are used to supply
references (lists of ChannelUpstreamHandlers and
ChannelDownstreamHandlers) that should be added to the pipeline. Note
that if encoders is specified then the encoder param will be ignored,
similarly for decoders and the decoder param.

NOTE: Read further above about using non shareable encoders/decoders.

The lists of codecs need to be added to the Camel's registry so they can
be resolved when the endpoint is created.

[source,java]
----
ChannelHandlerFactory lengthDecoder = ChannelHandlerFactories.newLengthFieldBasedFrameDecoder(1048576, 0, 4, 0, 4);

StringDecoder stringDecoder = new StringDecoder();
registry.bind(""length-decoder"", lengthDecoder);
registry.bind(""string-decoder"", stringDecoder);

LengthFieldPrepender lengthEncoder = new LengthFieldPrepender(4);
StringEncoder stringEncoder = new StringEncoder();
registry.bind(""length-encoder"", lengthEncoder);
registry.bind(""string-encoder"", stringEncoder);

List<ChannelHandler> decoders = new ArrayList<ChannelHandler>();
decoders.add(lengthDecoder);
decoders.add(stringDecoder);

List<ChannelHandler> encoders = new ArrayList<ChannelHandler>();
encoders.add(lengthEncoder);
encoders.add(stringEncoder);

registry.bind(""encoders"", encoders);
registry.bind(""decoders"", decoders);
----

Spring's native collections support can be used to specify the codec
lists in an application context

[source,xml]
----
<util:list id=""decoders"" list-class=""java.util.LinkedList"">
        <bean class=""org.apache.camel.component.netty.ChannelHandlerFactories"" factory-method=""newLengthFieldBasedFrameDecoder"">
            <constructor-arg value=""1048576""/>
            <constructor-arg value=""0""/>
            <constructor-arg value=""4""/>
            <constructor-arg value=""0""/>
            <constructor-arg value=""4""/>
        </bean>
        <bean class=""io.netty.handler.codec.string.StringDecoder""/>
    </util:list>

    <util:list id=""encoders"" list-class=""java.util.LinkedList"">
        <bean class=""io.netty.handler.codec.LengthFieldPrepender"">
            <constructor-arg value=""4""/>
        </bean>
        <bean class=""io.netty.handler.codec.string.StringEncoder""/>
    </util:list>

    <bean id=""length-encoder"" class=""io.netty.handler.codec.LengthFieldPrepender"">
        <constructor-arg value=""4""/>
    </bean>
    <bean id=""string-encoder"" class=""io.netty.handler.codec.string.StringEncoder""/>

    <bean id=""length-decoder"" class=""org.apache.camel.component.netty.ChannelHandlerFactories"" factory-method=""newLengthFieldBasedFrameDecoder"">
        <constructor-arg value=""1048576""/>
        <constructor-arg value=""0""/>
        <constructor-arg value=""4""/>
        <constructor-arg value=""0""/>
        <constructor-arg value=""4""/>
    </bean>
    <bean id=""string-decoder"" class=""io.netty.handler.codec.string.StringDecoder""/>
----

The bean names can then be used in netty endpoint definitions either as
a comma separated list or contained in a List e.g.

[source,java]
----
 from(""direct:multiple-codec"").to(""netty:tcp://0.0.0.0:{{port}}?encoders=#encoders&sync=false"");

 from(""netty:tcp://0.0.0.0:{{port}}?decoders=#length-decoder,#string-decoder&sync=false"").to(""mock:multiple-codec"");
----

or via XML.

[source,xml]
----
<camelContext id=""multiple-netty-codecs-context"" xmlns=""http://camel.apache.org/schema/spring"">
    <route>
        <from uri=""direct:multiple-codec""/>
        <to uri=""netty:tcp://0.0.0.0:5150?encoders=#encoders&amp;sync=false""/>
    </route>
    <route>
        <from uri=""netty:tcp://0.0.0.0:5150?decoders=#length-decoder,#string-decoder&amp;sync=false""/>
        <to uri=""mock:multiple-codec""/>
    </route>
</camelContext>
----

== Closing Channel When Complete

When acting as a server you sometimes want to close the channel when,
for example, a client conversion is finished. +
 You can do this by simply setting the endpoint option
`disconnect=true`.

However you can also instruct Camel on a per message basis as follows. +
 To instruct Camel to close the channel, you should add a header with
the key `CamelNettyCloseChannelWhenComplete` set to a boolean `true`
value. +
 For instance, the example below will close the channel after it has
written the bye message back to the client:

[source,java]
----
from(""netty:tcp://0.0.0.0:8080"").process(new Processor() {
    public void process(Exchange exchange) throws Exception {
        String body = exchange.getIn().getBody(String.class);
        exchange.getOut().setBody(""Bye "" + body);
        // some condition which determines if we should close
        if (close) {
            exchange.getOut().setHeader(NettyConstants.NETTY_CLOSE_CHANNEL_WHEN_COMPLETE, true);
        }
    }
});
----

[[Netty-Addingcustomchannelpipelinefactoriestogaincompletecontroloveracreatedpipeline]]
Adding custom channel pipeline factories to gain complete control over a created pipeline

== Custom pipeline

Custom channel pipelines provide complete control to the user over the
handler/interceptor chain by inserting custom handler(s), encoder(s) &
decoder(s) without having to specify them in the Netty Endpoint URL in a
very simple way.

In order to add a custom pipeline, a custom channel pipeline factory
must be created and registered with the context via the context registry
(Registry, or the camel-spring ApplicationContextRegistry etc).

A custom pipeline factory must be constructed as follows

* A Producer linked channel pipeline factory must extend the abstract
class `ClientPipelineFactory`.
* A Consumer linked channel pipeline factory must extend the abstract
class `ServerInitializerFactory`.
* The classes should override the initChannel() method in order to
insert custom handler(s), encoder(s) and decoder(s). Not overriding the
`initChannel()` method creates a pipeline with no handlers, encoders or
decoders wired to the pipeline.

The example below shows how ServerInitializerFactory factory may be
created

=== Using custom pipeline factory

[source,java]
----
public class SampleServerInitializerFactory extends ServerInitializerFactory {
    private int maxLineSize = 1024;

    protected void initChannel(Channel ch) throws Exception {
        ChannelPipeline channelPipeline = ch.pipeline();

        channelPipeline.addLast(""encoder-SD"", new StringEncoder(CharsetUtil.UTF_8));
        channelPipeline.addLast(""decoder-DELIM"", new DelimiterBasedFrameDecoder(maxLineSize, true, Delimiters.lineDelimiter()));
        channelPipeline.addLast(""decoder-SD"", new StringDecoder(CharsetUtil.UTF_8));
        // here we add the default Camel ServerChannelHandler for the consumer, to allow Camel to route the message etc.
        channelPipeline.addLast(""handler"", new ServerChannelHandler(consumer));
    }
}
----

The custom channel pipeline factory can then be added to the registry
and instantiated/utilized on a camel route in the following way

[source,java]
----
Registry registry = camelContext.getRegistry();
ServerInitializerFactory factory = new TestServerInitializerFactory();
registry.bind(""spf"", factory);
context.addRoutes(new RouteBuilder() {
  public void configure() {
      String netty_ssl_endpoint =
         ""netty:tcp://0.0.0.0:5150?serverInitializerFactory=#spf""
      String return_string =
         ""When You Go Home, Tell Them Of Us And Say,""
         + ""For Your Tomorrow, We Gave Our Today."";

      from(netty_ssl_endpoint)
       .process(new Processor() {
          public void process(Exchange exchange) throws Exception {
            exchange.getOut().setBody(return_string);
          }
       }
  }
});
----

== Reusing Netty boss and worker thread pools

Netty has two kind of thread pools: boss and worker. By default each
Netty consumer and producer has their private thread pools. If you want
to reuse these thread pools among multiple consumers or producers then
the thread pools must be created and enlisted in the
Registry.

For example using Spring XML we can create a shared worker thread pool
using the `NettyWorkerPoolBuilder` with 2 worker threads as shown below:

[source,xml]
----
<!-- use the worker pool builder to help create the shared thread pool -->
<bean id=""poolBuilder"" class=""org.apache.camel.component.netty.NettyWorkerPoolBuilder"">
  <property name=""workerCount"" value=""2""/>
</bean>

<!-- the shared worker thread pool -->
<bean id=""sharedPool"" class=""org.jboss.netty.channel.socket.nio.WorkerPool""
      factory-bean=""poolBuilder"" factory-method=""build"" destroy-method=""shutdown"">
</bean>
----

TIP: For boss thread pool there is a
`org.apache.camel.component.netty.NettyServerBossPoolBuilder` builder
for Netty consumers, and a
`org.apache.camel.component.netty.NettyClientBossPoolBuilder` for the
Netty producers.

Then in the Camel routes we can refer to this worker pools by
configuring the `workerPool` option in the URI as shown below:

[source,xml]
----
<route>
  <from uri=""netty:tcp://0.0.0.0:5021?textline=true&amp;sync=true&amp;workerPool=#sharedPool&amp;usingExecutorService=false""/>
  <to uri=""log:result""/>
  ...
</route>
----

And if we have another route we can refer to the shared worker pool:

[source,xml]
----
<route>
  <from uri=""netty:tcp://0.0.0.0:5022?textline=true&amp;sync=true&amp;workerPool=#sharedPool&amp;usingExecutorService=false""/>
  <to uri=""log:result""/>
  ...
</route>
----

and so forth.

== Multiplexing concurrent messages over a single connection with request/reply

When using Netty for request/reply messaging via the netty producer then by default each
message is sent via a non-shared connection (pooled). This ensures that replies are
automatic being able to map to the correct request thread for further routing in Camel.
In other words correlation between request/reply messages happens out-of-the-box because
the replies comes back on the same connection that was used for sending the request;
and this connection is not shared with others. When the response comes back, the connection
is returned back to the connection pool, where it can be reused by others.

However if you want to multiplex concurrent request/responses on a single shared connection,
then you need to turn off the connection pooling by setting `producerPoolEnabled=false`.
Now this means there is a potential issue with interleaved responses if replies comes back out-of-order.
Therefore you need to have a correlation id in both the request and reply messages so you can properly
correlate the replies to the Camel callback that is responsible for continue processing the message in Camel.
To do this you need to implement `NettyCamelStateCorrelationManager` as correlation manager and configure
it via the `correlationManager=#myManager` option.

NOTE: We recommend extending the `TimeoutCorrelationManagerSupport` when you build custom correlation managers.
This provides support for timeout and other complexities you otherwise would need to implement as well.

You can find an example with the Apache Camel source code in the examples directory
under the `camel-example-netty-custom-correlation` directory.

",12488,False,2297.314746303054,median
"/*******************************************************************************
 * The MIT License (MIT)
 *
 * Copyright (c) 2015 Camilo Sanchez (Camiloasc1)
 *
 * 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.
 ******************************************************************************/
grammar CPP14;
/*Basic concepts*/


translationunit
   : declarationseq? EOF
   ;
/*Expressions*/


primaryexpression
   : literal
   | This
   | '(' expression ')'
   | idexpression
   | lambdaexpression
   ;

idexpression
   : unqualifiedid
   | qualifiedid
   ;

unqualifiedid
   : Identifier
   | operatorfunctionid
   | conversionfunctionid
   | literaloperatorid
   | '~' classname
   | '~' decltypespecifier
   | templateid
   ;

qualifiedid
   : nestednamespecifier Template? unqualifiedid
   ;

nestednamespecifier
   : '::'
   | thetypename '::'
   | namespacename '::'
   | decltypespecifier '::'
   | nestednamespecifier Identifier '::'
   | nestednamespecifier Template? simpletemplateid '::'
   ;

lambdaexpression
   : lambdaintroducer lambdadeclarator? compoundstatement
   ;

lambdaintroducer
   : '[' lambdacapture? ']'
   ;

lambdacapture
   : capturedefault
   | capturelist
   | capturedefault ',' capturelist
   ;

capturedefault
   : '&'
   | '='
   ;

capturelist
   : capture '...'?
   | capturelist ',' capture '...'?
   ;

capture
   : simplecapture
   | initcapture
   ;

simplecapture
   : Identifier
   | '&' Identifier
   | This
   ;

initcapture
   : Identifier initializer
   | '&' Identifier initializer
   ;

lambdadeclarator
   : '(' parameterdeclarationclause ')' Mutable? exceptionspecification? attributespecifierseq? trailingreturntype?
   ;

postfixexpression
   : primaryexpression
   | postfixexpression '[' expression ']'
   | postfixexpression '[' bracedinitlist ']'
   | postfixexpression '(' expressionlist? ')'
   | simpletypespecifier '(' expressionlist? ')'
   | typenamespecifier '(' expressionlist? ')'
   | simpletypespecifier bracedinitlist
   | typenamespecifier bracedinitlist
   | postfixexpression '.' Template? idexpression
   | postfixexpression '->' Template? idexpression
   | postfixexpression '.' pseudodestructorname
   | postfixexpression '->' pseudodestructorname
   | postfixexpression '++'
   | postfixexpression '--'
   | Dynamic_cast '<' thetypeid '>' '(' expression ')'
   | Static_cast '<' thetypeid '>' '(' expression ')'
   | Reinterpret_cast '<' thetypeid '>' '(' expression ')'
   | Const_cast '<' thetypeid '>' '(' expression ')'
   | typeidofthetypeid '(' expression ')'
   | typeidofthetypeid '(' thetypeid ')'
   ;
/*
add a middle layer to eliminate duplicated function declarations
*/


typeidofexpr
   : Typeid_
   ;

typeidofthetypeid
   : Typeid_
   ;

expressionlist
   : initializerlist
   ;

pseudodestructorname
   : nestednamespecifier? thetypename '::' '~' thetypename
   | nestednamespecifier Template simpletemplateid '::' '~' thetypename
   | nestednamespecifier? '~' thetypename
   | '~' decltypespecifier
   ;

unaryexpression
   : postfixexpression
   | '++' castexpression
   | '--' castexpression
   | unaryoperator castexpression
   | Sizeof unaryexpression
   | Sizeof '(' thetypeid ')'
   | Sizeof '...' '(' Identifier ')'
   | Alignof '(' thetypeid ')'
   | noexceptexpression
   | newexpression
   | deleteexpression
   ;

unaryoperator
   : '|'
   | '*'
   | '&'
   | '+'
   | '!'
   | '~'
   | '-'
   | 'not'
   ;

newexpression
   : '::'? New newplacement? newtypeid newinitializer?
   | '::'? New newplacement? '(' thetypeid ')' newinitializer?
   ;

newplacement
   : '(' expressionlist ')'
   ;

newtypeid
   : typespecifierseq newdeclarator?
   ;

newdeclarator
   : ptroperator newdeclarator?
   | noptrnewdeclarator
   ;

noptrnewdeclarator
   : '[' expression ']' attributespecifierseq?
   | noptrnewdeclarator '[' constantexpression ']' attributespecifierseq?
   ;

newinitializer
   : '(' expressionlist? ')'
   | bracedinitlist
   ;

deleteexpression
   : '::'? Delete castexpression
   | '::'? Delete '[' ']' castexpression
   ;

noexceptexpression
   : Noexcept '(' expression ')'
   ;

castexpression
   : unaryexpression
   | '(' thetypeid ')' castexpression
   ;

pmexpression
   : castexpression
   | pmexpression '.*' castexpression
   | pmexpression '->*' castexpression
   ;

multiplicativeexpression
   : pmexpression
   | multiplicativeexpression '*' pmexpression
   | multiplicativeexpression '/' pmexpression
   | multiplicativeexpression '%' pmexpression
   ;

additiveexpression
   : multiplicativeexpression
   | additiveexpression '+' multiplicativeexpression
   | additiveexpression '-' multiplicativeexpression
   ;

shiftexpression
   : additiveexpression
   | shiftexpression shiftoperator additiveexpression
   ;

shiftoperator
  : RightShift
  | LeftShift
  ;

relationalexpression
   : shiftexpression
   | relationalexpression '<' shiftexpression
   | relationalexpression '>' shiftexpression
   | relationalexpression '<=' shiftexpression
   | relationalexpression '>=' shiftexpression
   ;

equalityexpression
   : relationalexpression
   | equalityexpression '==' relationalexpression
   | equalityexpression '!=' relationalexpression
   ;

andexpression
   : equalityexpression
   | andexpression '&' equalityexpression
   ;

exclusiveorexpression
   : andexpression
   | exclusiveorexpression '^' andexpression
   ;

inclusiveorexpression
   : exclusiveorexpression
   | inclusiveorexpression '|' exclusiveorexpression
   ;

logicalandexpression
   : inclusiveorexpression
   | logicalandexpression '&&' inclusiveorexpression
   | logicalandexpression 'and' inclusiveorexpression
   ;

logicalorexpression
   : logicalandexpression
   | logicalorexpression '||' logicalandexpression
   | logicalorexpression 'or' logicalandexpression
   ;

conditionalexpression
   : logicalorexpression
   | logicalorexpression '?' expression ':' assignmentexpression
   ;

assignmentexpression
   : conditionalexpression
   | logicalorexpression assignmentoperator initializerclause
   | throwexpression
   ;

assignmentoperator
   : '='
   | '*='
   | '/='
   | '%='
   | '+='
   | '-='
   | RightShiftAssign
   | LeftShiftAssign
   | '&='
   | '^='
   | '|='
   ;

expression
   : assignmentexpression
   | expression ',' assignmentexpression
   ;

constantexpression
   : conditionalexpression
   ;
/*Statements*/


statement
   : labeledstatement
   | attributespecifierseq? expressionstatement
   | attributespecifierseq? compoundstatement
   | attributespecifierseq? selectionstatement
   | attributespecifierseq? iterationstatement
   | attributespecifierseq? jumpstatement
   | declarationstatement
   | attributespecifierseq? tryblock
   ;

labeledstatement
   : attributespecifierseq? Identifier ':' statement
   | attributespecifierseq? Case constantexpression ':' statement
   | attributespecifierseq? Default ':' statement
   ;

expressionstatement
   : expression? ';'
   ;

compoundstatement
   : '{' statementseq? '}'
   ;

statementseq
   : statement
   | statementseq statement
   ;

selectionstatement
   : If '(' condition ')' statement
   | If '(' condition ')' statement Else statement
   | Switch '(' condition ')' statement
   ;

condition
   : expression
   | attributespecifierseq? declspecifierseq declarator '=' initializerclause
   | attributespecifierseq? declspecifierseq declarator bracedinitlist
   ;

iterationstatement
   : While '(' condition ')' statement
   | Do statement While '(' expression ')' ';'
   | For '(' forinitstatement condition? ';' expression? ')' statement
   | For '(' forrangedeclaration ':' forrangeinitializer ')' statement
   ;

forinitstatement
   : expressionstatement
   | simpledeclaration
   ;

forrangedeclaration
   : attributespecifierseq? declspecifierseq declarator
   ;

forrangeinitializer
   : expression
   | bracedinitlist
   ;

jumpstatement
   : Break ';'
   | Continue ';'
   | Return expression? ';'
   | Return bracedinitlist ';'
   | Goto Identifier ';'
   ;

declarationstatement
   : blockdeclaration
   ;
/*Declarations*/


declarationseq
   : declaration
   | declarationseq declaration
   ;

declaration
   : blockdeclaration
   | functiondefinition
   | templatedeclaration
   | explicitinstantiation
   | explicitspecialization
   | linkagespecification
   | namespacedefinition
   | emptydeclaration
   | attributedeclaration
   ;

blockdeclaration
   : simpledeclaration
   | asmdefinition
   | namespacealiasdefinition
   | usingdeclaration
   | usingdirective
   | static_assertdeclaration
   | aliasdeclaration
   | opaqueenumdeclaration
   ;

aliasdeclaration
   : Using Identifier attributespecifierseq? '=' thetypeid ';'
   ;

simpledeclaration
   : declspecifierseq? initdeclaratorlist? ';'
   | attributespecifierseq declspecifierseq? initdeclaratorlist ';'
   ;

static_assertdeclaration
   : Static_assert '(' constantexpression ',' Stringliteral ')' ';'
   ;

emptydeclaration
   : ';'
   ;

attributedeclaration
   : attributespecifierseq ';'
   ;

declspecifier
   : storageclassspecifier
   | typespecifier
   | functionspecifier
   | Friend
   | Typedef
   | Constexpr
   ;

declspecifierseq
   : declspecifier attributespecifierseq?
   | declspecifier declspecifierseq
   ;

storageclassspecifier
   : Register
   | Static
   | Thread_local
   | Extern
   | Mutable
   ;

functionspecifier
   : Inline
   | Virtual
   | Explicit
   ;

typedefname
   : Identifier
   ;

typespecifier
   : trailingtypespecifier
   | classspecifier
   | enumspecifier
   ;

trailingtypespecifier
   : simpletypespecifier
   | elaboratedtypespecifier
   | typenamespecifier
   | cvqualifier
   ;

typespecifierseq
   : typespecifier attributespecifierseq?
   | typespecifier typespecifierseq
   ;

trailingtypespecifierseq
   : trailingtypespecifier attributespecifierseq?
   | trailingtypespecifier trailingtypespecifierseq
   ;

simpletypespecifier
   : nestednamespecifier? thetypename
   | nestednamespecifier Template simpletemplateid
   | Char
   | Char16
   | Char32
   | Wchar
   | Bool
   | Short
   | Int
   | Long
   | Signed
   | Unsigned
   | Float
   | Double
   | Void
   | Auto
   | decltypespecifier
   ;

thetypename
   : classname
   | enumname
   | typedefname
   | simpletemplateid
   ;

decltypespecifier
   : Decltype '(' expression ')'
   | Decltype '(' Auto ')'
   ;

elaboratedtypespecifier
   : classkey attributespecifierseq? nestednamespecifier? Identifier
   | classkey simpletemplateid
   | classkey nestednamespecifier Template? simpletemplateid
   | Enum nestednamespecifier? Identifier
   ;

enumname
   : Identifier
   ;

enumspecifier
   : enumhead '{' enumeratorlist? '}'
   | enumhead '{' enumeratorlist ',' '}'
   ;

enumhead
   : enumkey attributespecifierseq? Identifier? enumbase?
   | enumkey attributespecifierseq? nestednamespecifier Identifier enumbase?
   ;

opaqueenumdeclaration
   : enumkey attributespecifierseq? Identifier enumbase? ';'
   ;

enumkey
   : Enum
   | Enum Class
   | Enum Struct
   ;

enumbase
   : ':' typespecifierseq
   ;

enumeratorlist
   : enumeratordefinition
   | enumeratorlist ',' enumeratordefinition
   ;

enumeratordefinition
   : enumerator
   | enumerator '=' constantexpression
   ;

enumerator
   : Identifier
   ;

namespacename
   : originalnamespacename
   | namespacealias
   ;

originalnamespacename
   : Identifier
   ;

namespacedefinition
   : namednamespacedefinition
   | unnamednamespacedefinition
   ;

namednamespacedefinition
   : originalnamespacedefinition
   | extensionnamespacedefinition
   ;

originalnamespacedefinition
   : Inline? Namespace Identifier '{' namespacebody '}'
   ;

extensionnamespacedefinition
   : Inline? Namespace originalnamespacename '{' namespacebody '}'
   ;

unnamednamespacedefinition
   : Inline? Namespace '{' namespacebody '}'
   ;

namespacebody
   : declarationseq?
   ;

namespacealias
   : Identifier
   ;

namespacealiasdefinition
   : Namespace Identifier '=' qualifiednamespacespecifier ';'
   ;

qualifiednamespacespecifier
   : nestednamespecifier? namespacename
   ;

usingdeclaration
   : Using Typename_? nestednamespecifier unqualifiedid ';'
   | Using '::' unqualifiedid ';'
   ;

usingdirective
   : attributespecifierseq? Using Namespace nestednamespecifier? namespacename ';'
   ;

asmdefinition
   : Asm '(' Stringliteral ')' ';'
   ;

linkagespecification
   : Extern Stringliteral '{' declarationseq? '}'
   | Extern Stringliteral declaration
   ;

attributespecifierseq
   : attributespecifier
   | attributespecifierseq attributespecifier
   ;

attributespecifier
   : '[' '[' attributelist ']' ']'
   | alignmentspecifier
   ;

alignmentspecifier
   : Alignas '(' thetypeid '...'? ')'
   | Alignas '(' constantexpression '...'? ')'
   ;

attributelist
   : attribute?
   | attributelist ',' attribute?
   | attribute '...'
   | attributelist ',' attribute '...'
   ;

attribute
   : attributetoken attributeargumentclause?
   ;

attributetoken
   : Identifier
   | attributescopedtoken
   ;

attributescopedtoken
   : attributenamespace '::' Identifier
   ;

attributenamespace
   : Identifier
   ;

attributeargumentclause
   : '(' balancedtokenseq ')'
   ;

balancedtokenseq
   : balancedtoken?
   | balancedtokenseq balancedtoken
   ;

balancedtoken
   : '(' balancedtokenseq ')'
   | '[' balancedtokenseq ']'
   | '{' balancedtokenseq '}'
   | ~('('|')'|'{'|'}'|'['|']')+
   ;
/*Declarators*/


initdeclaratorlist
   : initdeclarator
   | initdeclaratorlist ',' initdeclarator
   ;

initdeclarator
   : declarator initializer?
   ;

declarator
   : ptrdeclarator
   | noptrdeclarator parametersandqualifiers trailingreturntype
   ;

ptrdeclarator
   : noptrdeclarator
   | ptroperator ptrdeclarator
   ;

noptrdeclarator
   : declaratorid attributespecifierseq?
   | noptrdeclarator parametersandqualifiers
   | noptrdeclarator '[' constantexpression? ']' attributespecifierseq?
   | '(' ptrdeclarator ')'
   ;

parametersandqualifiers
   : '(' parameterdeclarationclause ')' cvqualifierseq? refqualifier? exceptionspecification? attributespecifierseq?
   ;

trailingreturntype
   : '->' trailingtypespecifierseq abstractdeclarator?
   ;

ptroperator
   : '*' attributespecifierseq? cvqualifierseq?
   | '&' attributespecifierseq?
   | '&&' attributespecifierseq?
   | nestednamespecifier '*' attributespecifierseq? cvqualifierseq?
   ;

cvqualifierseq
   : cvqualifier cvqualifierseq?
   ;

cvqualifier
   : Const
   | Volatile
   ;

refqualifier
   : '&'
   | '&&'
   ;

declaratorid
   : '...'? idexpression
   ;

thetypeid
   : typespecifierseq abstractdeclarator?
   ;

abstractdeclarator
   : ptrabstractdeclarator
   | noptrabstractdeclarator? parametersandqualifiers trailingreturntype
   | abstractpackdeclarator
   ;

ptrabstractdeclarator
   : noptrabstractdeclarator
   | ptroperator ptrabstractdeclarator?
   ;

noptrabstractdeclarator
   : noptrabstractdeclarator parametersandqualifiers
   | parametersandqualifiers
   | noptrabstractdeclarator '[' constantexpression? ']' attributespecifierseq?
   | '[' constantexpression? ']' attributespecifierseq?
   | '(' ptrabstractdeclarator ')'
   ;

abstractpackdeclarator
   : noptrabstractpackdeclarator
   | ptroperator abstractpackdeclarator
   ;

noptrabstractpackdeclarator
   : noptrabstractpackdeclarator parametersandqualifiers
   | noptrabstractpackdeclarator '[' constantexpression? ']' attributespecifierseq?
   | '...'
   ;

parameterdeclarationclause
   : parameterdeclarationlist? '...'?
   | parameterdeclarationlist ',' '...'
   ;

parameterdeclarationlist
   : parameterdeclaration
   | parameterdeclarationlist ',' parameterdeclaration
   ;

parameterdeclaration
   : attributespecifierseq? declspecifierseq declarator
   | attributespecifierseq? declspecifierseq declarator '=' initializerclause
   | attributespecifierseq? declspecifierseq abstractdeclarator?
   | attributespecifierseq? declspecifierseq abstractdeclarator? '=' initializerclause
   ;

functiondefinition
   : attributespecifierseq? declspecifierseq? declarator virtspecifierseq? functionbody
   ;

functionbody
   : ctorinitializer? compoundstatement
   | functiontryblock
   | '=' Default ';'
   | '=' Delete ';'
   ;

initializer
   : braceorequalinitializer
   | '(' expressionlist ')'
   ;

braceorequalinitializer
   : '=' initializerclause
   | bracedinitlist
   ;

initializerclause
   : assignmentexpression
   | bracedinitlist
   ;

initializerlist
   : initializerclause '...'?
   | initializerlist ',' initializerclause '...'?
   ;

bracedinitlist
   : '{' initializerlist ','? '}'
   | '{' '}'
   ;
/*Classes*/


classname
   : Identifier
   | simpletemplateid
   ;

classspecifier
   : classhead '{' memberspecification? '}'
   ;

classhead
   : classkey attributespecifierseq? classheadname classvirtspecifier? baseclause?
   | classkey attributespecifierseq? baseclause?
   ;

classheadname
   : nestednamespecifier? classname
   ;

classvirtspecifier
   : Final
   ;

classkey
   : Class
   | Struct
   | Union
   ;

memberspecification
   : memberdeclaration memberspecification?
   | accessspecifier ':' memberspecification?
   ;

memberdeclaration
   : attributespecifierseq? declspecifierseq? memberdeclaratorlist? ';'
   | functiondefinition
   | usingdeclaration
   | static_assertdeclaration
   | templatedeclaration
   | aliasdeclaration
   | emptydeclaration
   ;

memberdeclaratorlist
   : memberdeclarator
   | memberdeclaratorlist ',' memberdeclarator
   ;

memberdeclarator
   : declarator virtspecifierseq? purespecifier?
   | declarator braceorequalinitializer?
   | Identifier? attributespecifierseq? ':' constantexpression
   ;

virtspecifierseq
   : virtspecifier
   | virtspecifierseq virtspecifier
   ;

virtspecifier
   : Override
   | Final
   ;
/*
purespecifier:
   '=' '0'//Conflicts with the lexer
 ;
 */


purespecifier
   : Assign val = Octalliteral
   {if($val.text.compareTo(""0"")!=0) throw new InputMismatchException(this);}
   ;
/*Derived classes*/


baseclause
   : ':' basespecifierlist
   ;

basespecifierlist
   : basespecifier '...'?
   | basespecifierlist ',' basespecifier '...'?
   ;

basespecifier
   : attributespecifierseq? basetypespecifier
   | attributespecifierseq? Virtual accessspecifier? basetypespecifier
   | attributespecifierseq? accessspecifier Virtual? basetypespecifier
   ;

classordecltype
   : nestednamespecifier? classname
   | decltypespecifier
   ;

basetypespecifier
   : classordecltype
   ;

accessspecifier
   : Private
   | Protected
   | Public
   ;
/*Special member functions*/


conversionfunctionid
   : Operator conversiontypeid
   ;

conversiontypeid
   : typespecifierseq conversiondeclarator?
   ;

conversiondeclarator
   : ptroperator conversiondeclarator?
   ;

ctorinitializer
   : ':' meminitializerlist
   ;

meminitializerlist
   : meminitializer '...'?
   | meminitializer '...'? ',' meminitializerlist
   ;

meminitializer
   : meminitializerid '(' expressionlist? ')'
   | meminitializerid bracedinitlist
   ;

meminitializerid
   : classordecltype
   | Identifier
   ;
/*Overloading*/


operatorfunctionid
   : Operator theoperator
   ;

literaloperatorid
   : Operator Stringliteral Identifier
   | Operator Userdefinedstringliteral
   ;
/*Templates*/


templatedeclaration
   : Template '<' templateparameterlist '>' declaration
   ;

templateparameterlist
   : templateparameter
   | templateparameterlist ',' templateparameter
   ;

templateparameter
   : typeparameter
   | parameterdeclaration
   ;

typeparameter
   : Class '...'? Identifier?
   | Class Identifier? '=' thetypeid
   | Typename_ '...'? Identifier?
   | Typename_ Identifier? '=' thetypeid
   | Template '<' templateparameterlist '>' Class '...'? Identifier?
   | Template '<' templateparameterlist '>' Class Identifier? '=' idexpression
   ;

simpletemplateid
   : templatename '<' templateargumentlist? '>'
   ;

templateid
   : simpletemplateid
   | operatorfunctionid '<' templateargumentlist? '>'
   | literaloperatorid '<' templateargumentlist? '>'
   ;

templatename
   : Identifier
   ;

templateargumentlist
   : templateargument '...'?
   | templateargumentlist ',' templateargument '...'?
   ;

templateargument
   : thetypeid
   | constantexpression
   | idexpression
   ;

typenamespecifier
   : Typename_ nestednamespecifier Identifier
   | Typename_ nestednamespecifier Template? simpletemplateid
   ;

explicitinstantiation
   : Extern? Template declaration
   ;

explicitspecialization
   : Template '<' '>' declaration
   ;
/*Exception handling*/


tryblock
   : Try compoundstatement handlerseq
   ;

functiontryblock
   : Try ctorinitializer? compoundstatement handlerseq
   ;

handlerseq
   : handler handlerseq?
   ;

handler
   : Catch '(' exceptiondeclaration ')' compoundstatement
   ;

exceptiondeclaration
   : attributespecifierseq? typespecifierseq declarator
   | attributespecifierseq? typespecifierseq abstractdeclarator?
   | '...'
   ;

throwexpression
   : Throw assignmentexpression?
   ;

exceptionspecification
   : dynamicexceptionspecification
   | noexceptspecification
   ;

dynamicexceptionspecification
   : Throw '(' typeidlist? ')'
   ;

typeidlist
   : thetypeid '...'?
   | typeidlist ',' thetypeid '...'?
   ;

noexceptspecification
   : Noexcept '(' constantexpression ')'
   | Noexcept
   ;
/*Preprocessing directives*/


MultiLineMacro
   : '#' (~ [\\n]*? '\\\\' '\\r'? '\\n')+ ~ [\\n]+ -> channel (HIDDEN)
   ;

Directive
   : '#' ~ [\\n]* -> channel (HIDDEN)
   ;
/*Lexer*/

/*Keywords*/


Alignas
   : 'alignas'
   ;

Alignof
   : 'alignof'
   ;

Asm
   : 'asm'
   ;

Auto
   : 'auto'
   ;

Bool
   : 'bool'
   ;

Break
   : 'break'
   ;

Case
   : 'case'
   ;

Catch
   : 'catch'
   ;

Char
   : 'char'
   ;

Char16
   : 'char16_t'
   ;

Char32
   : 'char32_t'
   ;

Class
   : 'class'
   ;

Const
   : 'const'
   ;

Constexpr
   : 'constexpr'
   ;

Const_cast
   : 'const_cast'
   ;

Continue
   : 'continue'
   ;

Decltype
   : 'decltype'
   ;

Default
   : 'default'
   ;

Delete
   : 'delete'
   ;

Do
   : 'do'
   ;

Double
   : 'double'
   ;

Dynamic_cast
   : 'dynamic_cast'
   ;

Else
   : 'else'
   ;

Enum
   : 'enum'
   ;

Explicit
   : 'explicit'
   ;

Export
   : 'export'
   ;

Extern
   : 'extern'
   ;

False
   : 'false'
   ;

Final
   : 'final'
   ;

Float
   : 'float'
   ;

For
   : 'for'
   ;

Friend
   : 'friend'
   ;

Goto
   : 'goto'
   ;

If
   : 'if'
   ;

Inline
   : 'inline'
   ;

Int
   : 'int'
   ;

Long
   : 'long'
   ;

Mutable
   : 'mutable'
   ;

Namespace
   : 'namespace'
   ;

New
   : 'new'
   ;

Noexcept
   : 'noexcept'
   ;

Nullptr
   : 'nullptr'
   ;

Operator
   : 'operator'
   ;

Override
   : 'override'
   ;

Private
   : 'private'
   ;

Protected
   : 'protected'
   ;

Public
   : 'public'
   ;

Register
   : 'register'
   ;

Reinterpret_cast
   : 'reinterpret_cast'
   ;

Return
   : 'return'
   ;

Short
   : 'short'
   ;

Signed
   : 'signed'
   ;

Sizeof
   : 'sizeof'
   ;

Static
   : 'static'
   ;

Static_assert
   : 'static_assert'
   ;

Static_cast
   : 'static_cast'
   ;

Struct
   : 'struct'
   ;

Switch
   : 'switch'
   ;

Template
   : 'template'
   ;

This
   : 'this'
   ;

Thread_local
   : 'thread_local'
   ;

Throw
   : 'throw'
   ;

True
   : 'true'
   ;

Try
   : 'try'
   ;

Typedef
   : 'typedef'
   ;

Typeid_
   : 'typeid'
   ;

Typename_
   : 'typename'
   ;

Union
   : 'union'
   ;

Unsigned
   : 'unsigned'
   ;

Using
   : 'using'
   ;

Virtual
   : 'virtual'
   ;

Void
   : 'void'
   ;

Volatile
   : 'volatile'
   ;

Wchar
   : 'wchar_t'
   ;

While
   : 'while'
   ;
/*Operators*/


LeftParen
   : '('
   ;

RightParen
   : ')'
   ;

LeftBracket
   : '['
   ;

RightBracket
   : ']'
   ;

LeftBrace
   : '{'
   ;

RightBrace
   : '}'
   ;

Plus
   : '+'
   ;

Minus
   : '-'
   ;

Star
   : '*'
   ;

Div
   : '/'
   ;

Mod
   : '%'
   ;

Caret
   : '^'
   ;

And
   : '&'
   ;

Or
   : '|'
   ;

Tilde
   : '~'
   ;

Not
   : '!'
   | 'not'
   ;

Assign
   : '='
   ;

Less
   : '<'
   ;

Greater
   : '>'
   ;

PlusAssign
   : '+='
   ;

MinusAssign
   : '-='
   ;

StarAssign
   : '*='
   ;

DivAssign
   : '/='
   ;

ModAssign
   : '%='
   ;

XorAssign
   : '^='
   ;

AndAssign
   : '&='
   ;

OrAssign
   : '|='
   ;

LeftShift
   : '<<'
   ;

RightShift
   :
   '>>'
   ;

LeftShiftAssign
   : '<<='
   ;

RightShiftAssign
   :
   '>>='
   ;

Equal
   : '=='
   ;

NotEqual
   : '!='
   ;

LessEqual
   : '<='
   ;

GreaterEqual
   : '>='
   ;

AndAnd
   : '&&'
   | 'and'
   ;

OrOr
   : '||'
   | 'or'
   ;

PlusPlus
   : '++'
   ;

MinusMinus
   : '--'
   ;

Comma
   : ','
   ;

ArrowStar
   : '->*'
   ;

Arrow
   : '->'
   ;

Question
   : '?'
   ;

Colon
   : ':'
   ;

Doublecolon
   : '::'
   ;

Semi
   : ';'
   ;

Dot
   : '.'
   ;

DotStar
   : '.*'
   ;

Ellipsis
   : '...'
   ;

theoperator
   : New
   | Delete
   | New '[' ']'
   | Delete '[' ']'
   | '+'
   | '-'
   | '*'
   | '/'
   | '%'
   | '^'
   | '&'
   | '|'
   | '~'
   | '!'
   | 'not'
   | '='
   | '<'
   | '>'
   | '+='
   | '-='
   | '*='
   | '/='
   | '%='
   | '^='
   | '&='
   | '|='
   | LeftShift
   | RightShift
   | RightShiftAssign
   | LeftShiftAssign
   | '=='
   | '!='
   | '<='
   | '>='
   | '&&'
   | 'and'
   | '||'
   | 'or'
   | '++'
   | '--'
   | ','
   | '->*'
   | '->'
   | '(' ')'
   | '[' ']'
   ;
/*Lexer*/


fragment Hexquad
   : HEXADECIMALDIGIT HEXADECIMALDIGIT HEXADECIMALDIGIT HEXADECIMALDIGIT
   ;

fragment Universalcharactername
   : '\\\\u' Hexquad
   | '\\\\U' Hexquad Hexquad
   ;

Identifier
   :
/*
   Identifiernondigit
   | Identifier Identifiernondigit
   | Identifier DIGIT
   */
   Identifiernondigit (Identifiernondigit | DIGIT)*
   ;

fragment Identifiernondigit
   : NONDIGIT
   | Universalcharactername
   ;

fragment NONDIGIT
   : [a-zA-Z_]
   ;

fragment DIGIT
   : [0-9]
   ;

literal
   : Integerliteral
   | Characterliteral
   | Floatingliteral
   | Stringliteral
   | booleanliteral
   | pointerliteral
   | userdefinedliteral
   ;

Integerliteral
   : Decimalliteral Integersuffix?
   | Octalliteral Integersuffix?
   | Hexadecimalliteral Integersuffix?
   | Binaryliteral Integersuffix?
   ;

Decimalliteral
   : NONZERODIGIT ('\\''? DIGIT)*
   ;

Octalliteral
   : '0' ('\\''? OCTALDIGIT)*
   ;

Hexadecimalliteral
   : ('0x' | '0X') HEXADECIMALDIGIT ('\\''? HEXADECIMALDIGIT)*
   ;

Binaryliteral
   : ('0b' | '0B') BINARYDIGIT ('\\''? BINARYDIGIT)*
   ;

fragment NONZERODIGIT
   : [1-9]
   ;

fragment OCTALDIGIT
   : [0-7]
   ;

fragment HEXADECIMALDIGIT
   : [0-9a-fA-F]
   ;

fragment BINARYDIGIT
   : [01]
   ;

Integersuffix
   : Unsignedsuffix Longsuffix?
   | Unsignedsuffix Longlongsuffix?
   | Longsuffix Unsignedsuffix?
   | Longlongsuffix Unsignedsuffix?
   ;

fragment Unsignedsuffix
   : [uU]
   ;

fragment Longsuffix
   : [lL]
   ;

fragment Longlongsuffix
   : 'll'
   | 'LL'
   ;

Characterliteral
   : '\\'' Cchar+ '\\''
   | 'u' '\\'' Cchar+ '\\''
   | 'U' '\\'' Cchar+ '\\''
   | 'L' '\\'' Cchar+ '\\''
   ;

fragment Cchar
   : ~ ['\\\\\\r\\n]
   | Escapesequence
   | Universalcharactername
   ;
fragment Escapesequence
   : Simpleescapesequence
   | Octalescapesequence
   | Hexadecimalescapesequence
   ;
fragment Simpleescapesequence
   : '\\\\\\''
   | '\\\\""'
   | '\\\\?'
   | '\\\\\\\\'
   | '\\\\a'
   | '\\\\b'
   | '\\\\f'
   | '\\\\n'
   | '\\\\r'
   | '\\\\t'
   | '\\\\v'
   ;

fragment Octalescapesequence
   : '\\\\' OCTALDIGIT
   | '\\\\' OCTALDIGIT OCTALDIGIT
   | '\\\\' OCTALDIGIT OCTALDIGIT OCTALDIGIT
   ;

fragment Hexadecimalescapesequence
   : '\\\\x' HEXADECIMALDIGIT+
   ;

Floatingliteral
   : Fractionalconstant Exponentpart? Floatingsuffix?
   | Digitsequence Exponentpart Floatingsuffix?
   ;

fragment Fractionalconstant
   : Digitsequence? '.' Digitsequence
   | Digitsequence '.'
   ;

fragment Exponentpart
   : 'e' SIGN? Digitsequence
   | 'E' SIGN? Digitsequence
   ;

fragment SIGN
   : [+-]
   ;

fragment Digitsequence
   : DIGIT ('\\''? DIGIT)*
   ;

fragment Floatingsuffix
   : [flFL]
   ;

Stringliteral
   : Encodingprefix? '""' Schar* '""'
   | Encodingprefix? 'R' Rawstring
   ;

fragment Encodingprefix
   : 'u8'
   | 'u'
   | 'U'
   | 'L'
   ;

fragment Schar
   : ~ [""\\\\\\r\\n]
   | Escapesequence
   | Universalcharactername
   ;
fragment Rawstring
   : '""' .*? '(' .*? ')' .*? '""'
   ;
booleanliteral
   : False
   | True
   ;
pointerliteral
   : Nullptr
   ;
userdefinedliteral
   : Userdefinedintegerliteral
   | Userdefinedfloatingliteral
   | Userdefinedstringliteral
   | Userdefinedcharacterliteral
   ;
Userdefinedintegerliteral
   : Decimalliteral Udsuffix
   | Octalliteral Udsuffix
   | Hexadecimalliteral Udsuffix
   | Binaryliteral Udsuffix
   ;
Userdefinedfloatingliteral
   : Fractionalconstant Exponentpart? Udsuffix
   | Digitsequence Exponentpart Udsuffix
   ;
Userdefinedstringliteral
   : Stringliteral Udsuffix
   ;
Userdefinedcharacterliteral
   : Characterliteral Udsuffix
   ;
fragment Udsuffix
   : Identifier
   ;
Whitespace
   : [ \\t]+ -> skip
   ;
Newline
   : ('\\r' '\\n'? | '\\n') -> skip
   ;
BlockComment
   : '/*' .*? '*/' -> skip
   ;
LineComment
   : '//' ~ [\\r\\n]* -> skip
   ;",8115,False,1549.6427023689455,median
"grammar Z80Asm;

options {
    superClass=Z80AsmBaseParser;
}

/*
 * Parser Rules
 */

compileUnit	
	:	EOF
	|	NEWLINE* asmline (NEWLINE+ asmline)* NEWLINE* EOF
	;

asmline
	:	label? lineBody? comment?
	|	directive comment?
	;

lineBody
	:	pragma 
	|	operation 
	|	macroParam 
	|	macroOrStructInvocation 
	|	statement
	|	fieldAssignment
	;

label
	:	IDENTIFIER COLON
	|	IDENTIFIER{!this.exprStart()}?
	;

comment
	:	COMMENT
	;

pragma
	:	orgPragma
	|	bankPragma
	|	xorgPragma
	|	entPragma
	|	xentPragma
	|	dispPragma
	|	equPragma
	|	varPragma
	|	defbPragma
	|	defwPragma
	|	defmPragma
	|	defcPragma
	|	defnPragma
	|	defhPragma
	|	skipPragma
	|	externPragma
	|	defsPragma
	|	fillbPragma
	|	fillwPragma
	|	modelPragma
	|	alignPragma
	|	tracePragma
	|	rndSeedPragma
	|   defgxPragma
	|	defgPragma
	|   errorPragma
	|	incBinPragma
	|	compareBinPragma
	|	zxBasicPragma
	|   injectOptPragma
	;

directive
	:	(IFDEF|IFNDEF|DEFINE|UNDEF|IFMOD|IFNMOD) IDENTIFIER
	|	ENDIF
	|	ELSE
	|	IF expr
	|	INCLUDE (STRING)
	|	LINEDIR expr (COMMA? STRING)?
	;	

statement
	:	iterationTest
	|	macroStatement
	|	macroEndMarker
	|	loopEndMarker
	|	whileEndMarker
	|	procStatement
	|	procEndMarker
	|	repeatStatement
	|	ifStatement
	|	elseStatement
	|	endifStatement
	|	forStatement
	|	nextStatement
	|	breakStatement
	|	continueStatement
	|	moduleStatement
	|	moduleEndMarker
	|	structStatement
	|	structEndMarker
	|	localStatement
	;

iterationTest: (LOOP | WHILE | UNTIL | ELIF | IDENTIFIER
	{this.p(""loop"", ""while"", ""until"", ""elif"")}?
	) expr;
macroStatement: MACRO LPAR (IDENTIFIER (COMMA IDENTIFIER)*)? RPAR SINGLETON? ;
macroEndMarker: ENDMACRO ;
procStatement: PROC;
procEndMarker: ENDPROC ;
loopEndMarker: ENDLOOP ;
repeatStatement: REPEAT ;
whileEndMarker: ENDWHILE ;
ifStatement: IFSTMT expr | IFUSED symbol | IFNUSED symbol ;
elseStatement: ELSESTMT ;
endifStatement: ENDIFSTMT ;
forStatement: FOR IDENTIFIER ASSIGN expr TO expr (STEP expr)? ;
nextStatement: (NEXT | FORNEXT) ;
breakStatement: BREAK ;
continueStatement: CONTINUE ;
moduleStatement: MODULE IDENTIFIER? ;
moduleEndMarker: ENDMOD ;
structStatement: STRUCT ;
structEndMarker: ENDST ;
localStatement: LOCAL IDENTIFIER (COMMA IDENTIFIER)* ;

macroOrStructInvocation: IDENTIFIER LPAR macroArgument (COMMA macroArgument)* RPAR	;
macroArgument: operand? ;

fieldAssignment: GOESTO byteEmPragma ;

orgPragma	: ORGPRAG expr ;
bankPragma	: BANKPRAG expr (COMMA expr)?;
xorgPragma	: XORGPR expr ;
entPragma	: ENTPRAG expr ;
xentPragma	: XENTPRAG expr ;
dispPragma	: DISPRAG expr ;
equPragma	: EQUPRAG expr ;
varPragma	: (VARPRAG | ASSIGN) expr ;
defbPragma	: DBPRAG expr (COMMA expr)* ;
defwPragma	: DWPRAG expr (COMMA expr)* ;
defcPragma	: DCPRAG expr ;
defmPragma	: DMPRAG expr ;
defnPragma	: DNPRAG expr ;
defhPragma	: DHPRAG expr ;
skipPragma	: SKIPRAG expr (COMMA expr)?;
externPragma: EXTPRAG ;
defsPragma	: DSPRAG expr (COMMA expr)?;
fillbPragma	: FBPRAG expr COMMA expr ;
fillwPragma : FWPRAG expr COMMA expr ;
modelPragma : MODPRAG (IDENTIFIER | NEXT) ;
alignPragma : ALGPRAG expr? ;
tracePragma : (TRACE | TRACEHEX) expr ( ',' expr)* ;
rndSeedPragma: RNDSEED expr? ;
defgxPragma	: DGXPRAG expr ;
defgPragma	: DGPRAG ;
errorPragma : ERRORPR expr ;
incBinPragma: INCBIN expr ( ',' expr ( ',' expr)? )? ;
compareBinPragma: COMPAREBIN expr ( ',' expr ( ',' expr)? )? ;
zxBasicPragma: ZXBPRAG ;
injectOptPragma: IOPTPRAG IDENTIFIER;

byteEmPragma
	:  defbPragma 
	| defwPragma 
	| defcPragma 
	| defmPragma
	| defnPragma
	| defhPragma
    | defsPragma
	| fillbPragma
	| fillwPragma
	| defgxPragma
    | defgPragma
	;


operation
	:	trivialOperation
	|	compoundOperation
	|	trivialNextOperation
	;

trivialOperation
	:	NOP
	|	RLCA
	|	RRCA
	|	RLA
	|	RRA
	|	DAA
	|	CPL
	|	SCF
	|	CCF
	|	HALT
	|	EXX
	|	DI
	|	EI
	|	NEG
	|	RETN
	|	RETI
	|	RLD
	|	RRD
	|	LDI
	|	CPI
	|	INI
	|	OUTI
	|	LDD
	|	CPD
	|	IND
	|	OUTD
	|	LDIR
	|	CPIR
	|	INIR
	|	OTIR
	|	LDDR
	|	CPDR
	|	INDR
	|	OTDR
	;

compoundOperation
	:	LD operand COMMA operand
	|	INC operand
	|	DEC operand
	|	EX operand COMMA operand
	|	ADD operand COMMA operand
	|	ADC operand COMMA operand
	|	SUB (operand COMMA)? operand
	|	SBC operand COMMA operand
	|	AND (operand COMMA)? operand
	|	XOR (operand COMMA)? operand
	|	OR (operand COMMA)? operand
	|	CP (operand COMMA)? operand
	|	DJNZ operand
	|	JR (operand COMMA)? operand
	|	JP (operand COMMA)? operand
	|	CALL (operand COMMA)? operand
	|	RET operand?
	|	RST operand
	|	PUSH operand
	|	POP operand
	|	IN (operand COMMA)? operand
	|	OUT (operand COMMA)? operand
	|	IM operand
	|	RLC (operand COMMA)? operand
	|	RRC (operand COMMA)? operand
	|	RL (operand COMMA)? operand
	|	RR (operand COMMA)? operand
	|	SLA (operand COMMA)? operand
	|	SRA (operand COMMA)? operand
	|	SLL (operand COMMA)? operand
	|	SRL (operand COMMA)? operand
	|	BIT operand COMMA operand
	|	RES operand COMMA (operand COMMA)? operand
	|	SET operand COMMA (operand COMMA)? operand
	// --- Next operation
	|	MIRROR operand
	|	TEST operand
	|	NEXTREG operand COMMA operand
	;

trivialNextOperation
	:	SWAPNIB
	|	MUL
	|	OUTINB
	|	LDIX
	|	LDIRX
	|	LDDX
	|	LDDRX
	|	PIXELDN
	|	PIXELAD
	|	SETAE
	|	LDPIRX
	|	LDIRSCALE
	;

// --- Operands
operand
	:	reg8
	|	reg8Idx
	|	reg8Spec
	|	reg16
	|	reg16Idx
	|	reg16Spec
	|	regIndirect
	|	cPort
	|	memIndirect
	|	indexedAddr
	|	expr
	|	condition
	|	(HREG | LREG) LPAR (reg16Std | macroParam | NONEARG) RPAR
	|	NONEARG
	;

reg8: A | B | C | D | E | H | L ;
reg8Idx: XL | XH | YL | YH ;
reg8Spec: I | R ;
reg16: BC | DE | HL | SP ;
reg16Idx: IX | IY ;
reg16Std: BC | DE | HL | IX | IY ;
reg16Spec: AF | AF_ ;
regIndirect: LPAR (reg16) RPAR ;
cPort: LPAR C RPAR ;
memIndirect: LPAR expr RPAR ;
indexedAddr: LPAR reg16Idx ((PLUS | MINUS) expr)? RPAR ;
condition: Z | NZ |	C | NC | PO | PE | P | M ;

// --- Expressions
expr
	: builtinFunctionInvocation                            #BuiltInFunctionExpr
	| functionInvocation                                   #FunctionInvocationExpr
	| macroParam                                           #MacroParamExpr
	| PLUS expr                                            #UnaryPlusExpr
	| MINUS expr                                           #UnaryMinusExpr
	| TILDE expr                                           #BinaryNotExpr
	| EXCLM expr                                           #LogicalNotExpr
	| LSBRAC expr RSBRAC                                   #BracketedExpr
	| LPAR expr RPAR                                       #ParenthesizedExpr
	| literal                                              #LiteralExpr
	| symbol                                               #SymbolExpr
	| expr op=(MINOP | MAXOP) expr                         #MinMaxExpr
	| expr op=(MULOP | DIVOP | MODOP | MINOP | MAXOP) expr #MultExpr
	| expr op=(PLUS | MINUS ) expr                         #AddExpr
	| expr op=(LSHOP | RSHOP) expr                         #ShiftExpr
	| expr op=(LTOP | LTEOP | GTOP | GTEOP) expr           #RelExpr
	| expr op=(EQOP | NEQOP | CIEQOP | CINEQOP) expr       #EquExpr
	| expr AMP expr                                        #AndExpr
	| expr UPARR expr                                      #XorExpr
	| expr VBAR expr                                       #OrExpr
	| expr QMARK expr COLON expr                           #TernaryExpr
	;

functionInvocation
	: IDENTIFIER LPAR RPAR
	| IDENTIFIER LPAR expr (COMMA expr)* RPAR
	;

builtinFunctionInvocation
	: (TEXTOF | LTEXTOF) LPAR 
		(mnemonic | regsAndConds | macroParam) RPAR        #TextOfInvoke
	| DEF LPAR operand? RPAR                               #DefInvoke
	| ISREG8 LPAR operand? RPAR                            #IsReg8Invoke
	| ISREG8STD LPAR operand? RPAR                         #IsReg8StdInvoke
	| ISREG8SPEC LPAR operand? RPAR                        #IsReg8StdSpecInvoke
	| ISREG8IDX LPAR operand? RPAR                         #IsReg8IdxInvoke
	| ISREG16 LPAR operand? RPAR                           #IsReg16Invoke
	| ISREG16STD LPAR operand? RPAR                        #IsReg16StdInvoke
	| ISREG16IDX LPAR operand? RPAR                        #IsReg16IdxInvoke
	| ISREGINDIRECT LPAR operand? RPAR                     #IsRegIndirectInvoke
	| ISCPORT LPAR operand? RPAR                           #IsCportInvoke
	| ISINDEXEDADDR LPAR operand? RPAR                     #IsIndexedAddrInvoke
	| ISCONDITION LPAR operand? RPAR                       #IsConditionInvoke
	| ISEXPR LPAR operand? RPAR                            #IsExprInvoke
	| ISREGA LPAR operand? RPAR                            #IsRegAInvoke
	| ISREGAF LPAR operand? RPAR                           #IsRegAfInvoke
	| ISREGB LPAR operand? RPAR                            #IsRegBInvoke
	| ISREGC LPAR operand? RPAR                            #IsRegCInvoke
	| ISREGBC LPAR operand? RPAR                           #IsRegBCInvoke
	| ISREGD LPAR operand? RPAR                            #IsRegDInvoke
	| ISREGE LPAR operand? RPAR                            #IsRegEInvoke
	| ISREGDE LPAR operand? RPAR                           #IsRegDEInvoke
	| ISREGH LPAR operand? RPAR                            #IsRegHInvoke
	| ISREGL LPAR operand? RPAR                            #IsRegLInvoke
	| ISREGHL LPAR operand? RPAR                           #IsRegHLInvoke
	| ISREGI LPAR operand? RPAR                            #IsRegIInvoke
	| ISREGR LPAR operand? RPAR                            #IsRegRInvoke
	| ISREGXH LPAR operand? RPAR                           #IsRegXHInvoke
	| ISREGXL LPAR operand? RPAR                           #IsRegXLInvoke
	| ISREGIX LPAR operand? RPAR                           #IsRegIXInvoke
	| ISREGYH LPAR operand? RPAR                           #IsRegYHInvoke
	| ISREGYL LPAR operand? RPAR                           #IsRegYLInvoke
	| ISREGIY LPAR operand? RPAR                           #IsRegIYInvoke
	| ISREGSP LPAR operand? RPAR                           #IsRegSPInvoke
	;

literal
	: HEXNUM                                               #HexLiteral
	| DECNUM                                               #DecimalLiteral
	| OCTNUM                                               #OctalLiteral
	| CHAR                                                 #CharLiteral
	| BINNUM                                               #BinLiteral
	| REALNUM                                              #RealLiteral
	| BOOLLIT                                              #BoolLiteral
	| STRING                                               #StringLiteral
	| (CURADDR | DOT | MULOP)                              #CurAddrLiteral
	| CURCNT                                               #CurCounterLiteral
	;

symbol
	: DCOLON? IDENTIFIER
	;

macroParam
	: LDBRAC IDENTIFIER RDBRAC
	;

regs
	: reg8
	| reg8Idx
	| reg8Spec
	| reg16
	| reg16Idx
	| reg16Spec
	;

regsAndConds
	: regs
	| regIndirect
	| cPort
	| condition
	;

mnemonic
	: NOP | RLCA | RRCA | RLA | RRA | DAA | CPL | SCF | CCF | HALT | RET
	| EXX | DI | EI | NEG | RETN | RETI | RLD | RRD | LDI | CPI | INI
	| OUTI | LDD | CPD | IND | OUTD | LDIR | CPIR | INIR | OTIR | LDDR
	| CPDR | INDR | OTDR | LD | INC | DEC | EX | ADD | ADC | SUB | SBC
	| AND | XOR | OR | CP | DJNZ | JR | JP | CALL | RST | PUSH | POP
	| IN | OUT | IM | RLC | RRC | RL | RR | SLA | SRA | SLL | SRL | BIT
	| RES | SET | SWAPNIB | MUL | POPX | MIRROR	| TEST | NEXTREG 
	| OUTINB | LDIX | LDIRX | LDDX | LDDRX | PIXELDN | PIXELAD | SETAE
	| LDPIRX
	;

/*
 * Lexer Rules
 */

WS
	:	('\\u0020' | '\\t')+ -> channel(HIDDEN)
	;

BLCOMMENT
	:	'/*'  ~('\\r' | '\\n')*? '*/' -> channel(HIDDEN)
	;

COMMENT
	:	(SCOLON | COMSEP) ~('\\r' | '\\n')*
	;

NEWLINE
	:	('\\r'? '\\n' | '\\r')+
	;

// --- Common tokens
// --- Other tokens
COLON	: ':' ;
DCOLON	: '::' ;
SCOLON	: ';' ;
COMSEP	: '//' ;
COMMA	: ',' ;
ASSIGN	: '=' ;
LPAR	: '(' ;
RPAR	: ')' ;
LSBRAC	: '[' ;
RSBRAC	: ']' ;
QMARK	: '?' ;
PLUS	: '+' ;
MINUS	: '-' ;
VBAR	: '|' ;
UPARR	: '^' ;
AMP		: '&' ;
EQOP	: '==' ;
CIEQOP	: '===' ;
NEQOP	: '!=' ;
CINEQOP	: '!==' ;
LTOP	: '<' ;
LTEOP	: '<=' ;
GTOP	: '>' ;
GTEOP	: '>=' ;
LSHOP	: '<<' ;
RSHOP	: '>>' ;
MULOP	: '*' ;
DIVOP	: '/' ;
MODOP	: '%' ;
MINOP	: '<?' ;
MAXOP	: '>?' ;
TILDE	: '~';
LDBRAC	: '{{' ;
RDBRAC	: '}}' ;
EXCLM	: '!' ;
DOT		: '.' ;
GOESTO	: '->' ;

// --- Register and flag tokens
A	: 'a'|'A' ;
B	: 'b'|'B' ;
C	: 'c'|'C' ;
D	: 'd'|'D' ;
E	: 'e'|'E' ;
H	: 'h'|'H' ;
L	: 'l'|'L' ;
I	: 'i'|'I' ;
R	: 'r'|'R' ;
XL	: 'xl'|'XL'|'ixl'|'IXL'|'IXl' ;
XH	: 'xh'|'XH'|'ixh'|'IXH'|'IXh' ;
YL	: 'yl'|'YL'|'iyl'|'IYL'|'IYl' ;
YH	: 'yh'|'YH'|'iyh'|'IYH'|'IYh' ;
BC	: 'bc'|'BC' ;
DE	: 'de'|'DE' ;
HL	: 'hl'|'HL' ;
SP	: 'sp'|'SP' ;
IX	: 'ix'|'IX' ;
IY	: 'iy'|'IY' ;
AF	: 'af'|'AF' ;
AF_	: 'af\\''|'AF\\'' ;
Z	: 'z'|'Z' ;
NZ	: 'nz'|'NZ' ;
NC	: 'nc'|'NC' ;
PO	: 'po'|'PO' ;
PE	: 'pe'|'PE' ;
P	: 'p'|'P' ;
M	: 'm'|'M' ;

// --- Trivial instruction tokens

NOP		: 'nop'|'NOP' ;
RLCA	: 'rlca'|'RLCA' ;
RRCA	: 'rrca'|'RRCA' ;
RLA		: 'rla'|'RLA' ;
RRA		: 'rra'|'RRA' ;
DAA		: 'daa'|'DAA' ;
CPL		: 'cpl'|'CPL' ;
SCF		: 'scf'|'SCF' ;
CCF		: 'ccf'|'CCF' ;
HALT	: 'halt'|'HALT' ;
RET		: 'ret'|'RET' ;
EXX		: 'exx'|'EXX' ;
DI		: 'di'|'DI' ;
EI		: 'ei'|'EI' ;
NEG		: 'neg'|'NEG' ;
RETN	: 'retn'|'RETN' ;
RETI	: 'reti'|'RETI' ;
RLD		: 'rld'|'RLD' ;
RRD		: 'rrd'|'RRD' ;
LDI		: 'ldi'|'LDI' ;
CPI		: 'cpi'|'CPI' ;
INI		: 'ini'|'INI' ;
OUTI	: 'outi'|'OUTI' ;
LDD		: 'ldd'|'LDD' ;
CPD		: 'cpd'|'CPD' ;
IND		: 'ind'|'IND' ;
OUTD	: 'outd'|'OUTD' ;
LDIR	: 'ldir'|'LDIR' ;
CPIR	: 'cpir'|'CPIR' ;
INIR	: 'inir'|'INIR' ;
OTIR	: 'otir'|'OTIR' ;
LDDR	: 'lddr'|'LDDR' ;
CPDR	: 'cpdr'|'CPDR' ;
INDR	: 'indr'|'INDR' ;
OTDR	: 'otdr'|'OTDR' ;

// --- Other instruction tokens
LD		: 'ld'|'LD' ;
INC		: 'inc'|'INC' ;
DEC		: 'dec'|'DEC' ;
EX		: 'ex'|'EX' ;
ADD		: 'add'|'ADD' ;
ADC		: 'adc'|'ADC' ;
SUB		: 'sub'|'SUB' ;
SBC		: 'sbc'|'SBC' ;
AND		: 'and'|'AND' ;
XOR		: 'xor'|'XOR' ;
OR		: 'or'|'OR' ;
CP		: 'cp'|'CP' ;
DJNZ	: 'djnz'|'DJNZ' ;
JR		: 'jr'|'JR' ;
JP		: 'jp'|'JP' ;
CALL	: 'call'|'CALL' ;
RST		: 'rst'|'RST' ;
PUSH	: 'push'|'PUSH' ;
POP		: 'pop'|'POP' ;
IN		: 'in'|'IN' ;
OUT		: 'out'|'OUT' ;
IM		: 'im'|'IM' ;
RLC		: 'rlc'|'RLC' ;
RRC		: 'rrc'|'RRC' ;
RL		: 'rl'|'RL' ;
RR		: 'rr'|'RR' ;
SLA		: 'sla'|'SLA' ;
SRA		: 'sra'|'SRA' ;
SLL		: 'sll'|'SLL' ;
SRL		: 'srl'|'SRL' ;
BIT		: 'bit'|'BIT' ;
RES		: 'res'|'RES' ;
SET		: 'set'|'SET' ;

// --- Next instruction tokens
SWAPNIB	: 'swapnib'|'SWAPNIB' ;
MUL		: 'mul'|'MUL' ;
POPX	: 'popx'|'POPX' ;
MIRROR	: 'mirror'|'MIRROR' ;
TEST	: 'test'|'TEST' ;
NEXTREG	: 'nextreg'|'NEXTREG' ;
OUTINB	: 'outinb'|'OUTINB' ;
LDIX	: 'ldix'|'LDIX' ;
LDIRX	: 'ldirx'|'LDIRX' ;
LDDX	: 'lddx'|'LDDX' ;
LDDRX	: 'lddrx'|'LDDRX' ;
PIXELDN	: 'pixeldn'|'PIXELDN' ;
PIXELAD	: 'pixelad'|'PIXELAD' ;
SETAE	: 'setae'|'SETAE' ;
LDPIRX	: 'ldpirx'|'LDPIRX' ;
LDIRSCALE: 'ldirscale'|'LDIRSCALE' ;

// --- Pre-processor tokens
IFDEF	: '#ifdef' ;
IFNDEF	: '#ifndef' ;
ENDIF	: '#endif' ;
ELSE	: '#else' ;
DEFINE	: '#define' ;
UNDEF	: '#undef' ;
INCLUDE	: '#include' ;
IF		: '#if' ;
IFMOD	: '#ifmod' ;
IFNMOD	: '#ifnmod' ;
LINEDIR	: '#line';

// --- Pragma tokens
ORGPRAG	: '.org' | '.ORG' | 'org' | 'ORG' ;
BANKPRAG: '.bank' | '.BANK' | 'bank' | 'BANK' ;
XORGPR	: '.xorg' | '.XORG' | 'xorg' | 'XORG' ;
ENTPRAG	: '.ent' | '.ENT' | 'ent' | 'ENT' ;
XENTPRAG: '.xent' | '.XENT' | 'xent' | 'XENT' ;
EQUPRAG	: '.equ' | '.EQU' | 'equ' | 'EQU' ;
VARPRAG	: '.var' | '.VAR' | 'var' | 'VAR' | ':=' ;
DISPRAG	: '.disp' | '.DISP' | 'disp' | 'DISP' ;
DBPRAG	: '.defb' | '.DEFB' | 'defb' | 'DEFB' | 'db' | '.db' | 'DB' | '.DB' ;
DWPRAG	: '.defw' | '.DEFW' | 'defw' | 'DEFW' | 'dw' | '.dw' | 'DW' | '.DW' ;
DMPRAG	: '.defm' | '.DEFM' | 'defm' | 'DEFM' | 'dm' | '.dm' | 'DM' | '.DM' ;
DNPRAG	: '.defn' | '.DEFN' | 'defn' | 'DEFN' | 'dn' | '.dn' | 'DN' | '.DN' ;
DHPRAG	: '.defh' | '.DEFH' | 'defh' | 'DEFH' | 'dh' | '.dh' | 'DH' | '.DH' ;
DGXPRAG	: '.defgx' | '.DEFGX' | 'defgx' | 'DEFGX' | 'dgx' | '.dgx' | 'DGX' | '.DGX' ;
DGPRAG	: ( '.defg' | '.DEFG' | 'defg' | 'DEFG' | 'dg' | '.dg' | 'DG' | '.DG' ) WS+ ~('\\r' | '\\n')+;
DCPRAG	: '.defc' | '.DEFC' | 'defc' | 'DEFC' | 'dc' | '.dc' | 'DC' | '.DC' ;
SKIPRAG	: '.skip' | '.SKIP' | 'skip' | 'SKIP' ;
EXTPRAG : '.extern'|'.EXTERN'|'extern'|'EXTERN' ;
DSPRAG	: '.defs' | '.DEFS' | 'defs' | 'DEFS' | '.ds' | '.DS' | 'ds' | 'DS' ;
FBPRAG	: '.fillb' | '.FILLB' | 'fillb' | 'FILLB' ;
FWPRAG	: '.fillw' | '.FILLW' | 'fillw' | 'FILLW' ;
MODPRAG : '.model' | '.MODEL' | 'model' | 'MODEL' ;
IOPTPRAG: '.injectopt' | '.INJECTOPT' | 'injectopt' | 'INJECTOPT';
ALGPRAG	: '.align' | '.ALIGN' | 'align' | 'ALIGN' ;
TRACE	: '.trace' | '.TRACE' | 'trace' | 'TRACE' ;
TRACEHEX: '.tracehex' | '.TRACEHEX' | 'tracehex' | 'TRACEHEX' ;
RNDSEED	: '.rndseed' | 'rndseed' | '.RNDSEED' | 'RNDSEED' ;
ERRORPR	: '.error' | '.ERROR' | 'error' | 'ERROR' ;
INCBIN	: '.includebin' | 'includebin' | '.INCLUDEBIN' | 'INCLUDEBIN' 
		  | '.include_bin' | 'include_bin' | '.INCLUDE_BIN' | 'INCLUDE_BIN' 
		  | '.incbin' | 'incbin' | '.INCBIN' | 'INCBIN' ;
COMPAREBIN
		: '.comparebin' | 'comparebin' | '.COMPAREBIN' | 'COMPAREBIN' ;
ZXBPRAG	: 'zxbasic' | 'ZXBASIC' | '.zxbasic' | '.ZXBASIC' ;

// --- Compiler statements
MACRO	: '.macro' | '.MACRO' | 'macro' | 'MACRO' ;
ENDMACRO: '.endm' | '.ENDM' | '.mend' | '.MEND' ;
PROC	: '.proc' | '.PROC' ;
ENDPROC	: '.endp' | '.ENDP' | '.pend' | '.PEND' ;
LOOP	: '.loop' | '.LOOP' ;
ENDLOOP	: '.endl' | '.ENDL' | '.lend' | '.LEND' ;
REPEAT	: '.repeat' | '.REPEAT' ;
UNTIL	: '.until' | '.UNTIL' ;
WHILE	: '.while' | '.WHILE' ;
ENDWHILE: '.endw' | '.ENDW' | '.wend' | '.WEND' ;
IFSTMT	: '.if' | '.IF' | 'if' | 'IF' ;
IFUSED	: '.ifused' | '.IFUSED' | 'ifused' | 'IFUSED' ;
IFNUSED	: '.ifnused' | '.IFNUSED' | 'ifnused' | 'IFNUSED' ;
ELIF	: '.elif' | '.ELIF' ;
ELSESTMT: '.else' | '.ELSE' ;
ENDIFSTMT: '.endif' | '.ENDIF' ;
FOR		: '.for' | '.FOR' | 'for' | 'FOR' ;
TO		: '.to' | '.TO' | 'to' | 'TO' ;
STEP	: '.step' | '.STEP' | 'step' | 'STEP' ;
FORNEXT	: '.next' | '.NEXT' ;
NEXT	: 'next' | 'NEXT' ;
BREAK	: '.break' | '.BREAK' ;
CONTINUE: '.continue' | '.CONTINUE' ;
MODULE	: '.module' | '.MODULE' | 'module' | 'MODULE' | '.scope' | '.SCOPE' | 'scope' | 'SCOPE' ;
ENDMOD	: '.endmodule' | '.ENDMODULE' | 'endmodule' | 'ENDMODULE' 
		  | '.endscope' | '.ENDSCOPE' | 'endscope' | 'ENDSCOPE'
		  | '.moduleend' | '.MODULEEND' | 'moduleend' | 'MODULEEND'
		  | '.scopeend' | '.SCOPEEND' | 'scopeend' | 'SCOPEEND' ;
STRUCT	: '.struct' | '.STRUCT' | 'struct' | 'STRUCT' ;
ENDST	: '.ends' | '.ENDS' ;
LOCAL	: '.local' | '.LOCAL' | 'local' | 'LOCAL' | 'Local' ;
SINGLETON: '.singleton' | '.SINGLETON' ;

// --- Built-in function names
TEXTOF	: 'textof' | 'TEXTOF' ;
LTEXTOF	: 'ltextof' | 'LTEXTOF' ;
HREG	: 'hreg' | 'HREG' ;
LREG	: 'lreg' | 'LREG' ;
DEF		: 'def' | 'DEF' ;
ISREG8	: 'isreg8' | 'ISREG8' ;
ISREG8STD: 'isreg8std' | 'ISREG8STD' ;
ISREG8SPEC: 'isreg8spec' | 'ISREG8SPEC' ;
ISREG8IDX: 'isreg8idx' | 'ISREG8IDX' ;
ISREG16: 'isreg16' | 'ISREG16' ;
ISREG16STD: 'isreg16std' | 'ISREG16STD' ;
ISREG16IDX: 'isreg16idx' | 'ISREG16IDX' ;
ISREGINDIRECT: 'isregindirect' | 'ISREGINDIRECT' ;
ISCPORT: 'iscport' | 'ISCPORT' ;
ISINDEXEDADDR: 'isindexedaddr' | 'ISINDEXEDADDR' ;
ISCONDITION: 'iscondition' | 'ISCONDITION' ;
ISEXPR: 'isexpr' | 'ISEXPR' ;
ISREGA: 'isrega' | 'ISREGA' ;
ISREGAF: 'isregaf' | 'ISREGAF' ;
ISREGB: 'isregb' | 'ISREGB' ;
ISREGC: 'isregc' | 'ISREGC' ;
ISREGBC: 'isregbc' | 'ISREGBC' ;
ISREGD: 'isregd' | 'ISREGD' ;
ISREGE: 'isrege' | 'ISREGE' ;
ISREGDE: 'isregde' | 'ISREGDE' ;
ISREGH: 'isregh' | 'ISREGH' ;
ISREGL: 'isregl' | 'ISREGL' ;
ISREGHL: 'isreghl' | 'ISREGHL' ;
ISREGI: 'isregi' | 'ISREGI' ;
ISREGR: 'isregr' | 'ISREGR' ;
ISREGSP: 'isregsp' | 'ISREGSP' ;
ISREGXH: 'isregxh' | 'ISREGXH' ;
ISREGXL: 'isregxl' | 'ISREGXL' ;
ISREGIX: 'isregix' | 'ISREGIX' ;
ISREGYH: 'isregyh' | 'ISREGYH' ;
ISREGYL: 'isregyl' | 'ISREGYL' ;
ISREGIY: 'isregiy' | 'ISREGIY' ;

// --- Basic literals
HEXNUM	: ('#'|'0x'|'$') HexDigit HexDigit? HexDigit? HexDigit?
		| Digit HexDigit? HexDigit? HexDigit? HexDigit? ('H' | 'h') ;

BINNUM	: ('%'|'0b') '_'? BinDigit BinDigit? BinDigit? BinDigit?
		  BinDigit? BinDigit? BinDigit? BinDigit?
		  BinDigit? BinDigit? BinDigit? BinDigit?
		  BinDigit? BinDigit? BinDigit? BinDigit?
		| '_'? BinDigit BinDigit? BinDigit? BinDigit?
		  BinDigit? BinDigit? BinDigit? BinDigit?
		  BinDigit? BinDigit? BinDigit? BinDigit?
		  BinDigit? BinDigit? BinDigit? BinDigit? ('B' | 'b')
		;

OCTNUM	: OctDigit OctDigit? OctDigit?
		  OctDigit? OctDigit? OctDigit? ('q' | 'Q' | 'o' | 'O' )
		;

DECNUM	: Digit Digit? Digit? Digit? Digit?;

CURADDR	: '$' ;

REALNUM	: [0-9]* DOT [0-9]+ ExponentPart? 
		| [0-9]+ ExponentPart;

CHAR	: '\\'' (~[""\\\\\\r\\n\\u0085\\u2028\\u2029] | CommonCharacter) '\\'' ;
STRING	: '""'  (~[""\\\\\\r\\n\\u0085\\u2028\\u2029] | CommonCharacter)* '""' ;

// --- Boolean literals;

BOOLLIT	: TRUE | FALSE ;
TRUE	: 'true' | '.true' | 'TRUE' | '.TRUE' ;
FALSE	: 'false' | '.false' | 'FALSE' | '.FALSE' ;

// --- Semi-identifiers
CURCNT	: '$cnt' | '$CNT' | '.cnt' | '.CNT' ;

// --- Identifiers
IDENTIFIER: IDSTART IDCONT*	;
IDSTART	: '.' | '_' | '@' | '`' | 'A'..'Z' | 'a'..'z'	;
IDCONT	: '_' | '@' | '!' | '?' | '#' | '0'..'9' | 'A'..'Z' | 'a'..'z' | '.' ;

NONEARG	: '$<none>$' ;

// --- Any invalid character should be converted into an ErrorCharacter token.
ErrorCharacter
    :   .
    ;

fragment CommonCharacter
	: SimpleEscapeSequence
	| HexEscapeSequence
	;

fragment SimpleEscapeSequence
	: '\\\\i'
	| '\\\\p'
	| '\\\\f'
	| '\\\\b'
	| '\\\\I'
	| '\\\\o'
	| '\\\\a'
	| '\\\\t'
	| '\\\\P'
	| '\\\\C'
	| '\\\\\\''
	| '\\\\""'
	| '\\\\\\\\'
	| '\\\\0'
	| '\\\\'
	;

fragment HexEscapeSequence
	: '\\\\x' HexDigit
	| '\\\\x' HexDigit HexDigit
	;

fragment HexDigit 
	: [0-9] 
	| [A-F] 
	| [a-f]
	;

fragment OctDigit
	: [0-7]
	;

fragment Digit 
	: OctDigit | '8' | '9'
	;

fragment BinDigit
	: ('0'|'1') '_'?
	;

fragment ExponentPart
	: [eE] (PLUS | MINUS)? [0-9]+
	;
",8397,False,1700.1593306067916,median
"---
title: Scripts rc.d práticos no BSD
authors:
  - author: Yar Tikhiy
    email: yar@FreeBSD.org
copyright: 2005-2006, 2012 The FreeBSD Project
releaseinfo: ""$FreeBSD: head/pt_BR.ISO8859-1/articles/rc-scripting/article.xml 52247 2018-09-12 00:52:17Z ebrandi $"" 
trademarks: [""freebsd"", ""netbsd"", ""general""]
---

= Scripts rc.d práticos no BSD
:doctype: article
:toc: macro
:toclevels: 1
:icons: font
:sectnums:
:source-highlighter: rouge
:experimental:
:figure-caption: Figure

include::share/br/urls.adoc[]

[.abstract-title]
Resumo

Os iniciantes podem achar difícil relacionar os fatos da documentação formal do framework [.filename]#rc.d# do BSD com as tarefas práticas do script [.filename]#rc.d#. Neste artigo, consideramos alguns casos típicos de complexidade crescente, vamos mostrar os recursos do [.filename]#rc.d# adequados para cada caso e vamos discutir como eles funcionam. Esse exame deve fornecer pontos de referência para um estudo mais aprofundado do design e da aplicação eficiente do [.filename]#rc.d#.

'''

toc::[]

[[rcng-intro]]
[.title]
== Introdução

Historicamente o BSD tinha um script de inicialização monolítico, o [.filename]#/etc/rc#. Ele era chamado pelo man:init[8] no momento da inicialização do sistema e executava todas as tarefas necessárias para a operação multi-usuário: verificação e montagem do sistemas de arquivos, configuração de rede, iniciava daemons e assim por diante. A lista precisa de tarefas não era a mesma em todos os sistemas; os administradores precisavam personalizá-lo. Com poucas exceções, o [.filename]#/etc/rc# teve que ser modificado, e os verdadeiros hackers gostaram disso.

O problema real com a abordagem monolítica era que ela não fornecia nenhum controle sobre os componentes individuais iniciados a partir do [.filename]#/etc/rc#. Por exemplo, o [.filename]#/etc/rc# não podia reiniciar um único daemon. O administrador do sistema tinha que encontrar o processo daemon manualmente, matá-lo, esperar até que ele realmente finalizasse, então procurar pelas flags no [.filename]#/etc/rc#, e finalmente digitar a linha de comando completa para iniciar o daemon novamente. A tarefa se tornaria ainda mais difícil e propensa a erros se o serviço de reinicialização consistisse em mais de um daemon ou exigisse ações adicionais. Em poucas palavras, o único script não cumpriu o objetivo dos scripts: tornar a vida do administrador do sistema mais fácil.

Mais tarde, houve uma tentativa de dividir algumas partes do [.filename]#/etc/rc# para iniciar os subsistemas mais importantes separadamente. O exemplo notório foi o [.filename]#/etc/netstart# para configurar a rede. Ele permitia acessar a rede a partir do modo single-user, mas não se integrou bem ao processo de inicialização automática porque partes de seu código precisavam intercalar com ações essencialmente não relacionadas à rede. Foi por isso que o [.filename]#/etc/netstart# mudou para [.filename]#/etc/rc.network#. Este último não era mais um script comum; ele era composto por um emaranhado de funções man:sh[1] chamadas pelo [.filename]#/etc/rc# em diferentes estágios da inicialização do sistema. No entanto, a medida que as tarefas de inicialização cresciam variadas e sofisticadas, a abordagem ""quase modular"" tornou-se ainda mais engessada do que o monolítico [.filename]#/etc/rc#.

Sem um framework limpo e bem projetado, os scripts de inicialização tiveram que se curvar para satisfazer as necessidades de desenvolvimento rápido dos sistemas operacionais baseados no BSD. Tornou-se óbvio, finalmente, que mais passos eram necessários no caminho para construção de um sistema [.filename]#rc# extensível e customizável. Assim nasceu o BSD [.filename]#rc.d#. Seus pais reconhecidos foram o Luke Mewburn e a comunidade do NetBSD. Mais tarde ele foi importado para o FreeBSD. Seu nome se refere à localização dos scripts do sistema para serviços individuais, que é o [.filename]#/etc/rc.d#. Em breve, vamos aprender sobre mais componentes do sistema [.filename]#rc.d# e vamos ver como os scripts individuais são invocados.

As idéias básicas por trás do BSD [.filename]#rc.d# são _modularidade fina_ e __reutilização de código__. _Modularidade fina_ significa que cada ""serviço básico"", como um daemon do sistema ou uma tarefa de inicialização primitiva, obtém seu próprio script man:sh[] capaz de iniciar o serviço, pará-lo, recarregá-lo e verificar seu status. Uma ação específica é escolhida pelo argumento da linha de comando para o script. O script [.filename]#/etc/rc# ainda comanda a inicialização do sistema, mas agora ele simplesmente invoca os scripts menores um por um com o argumento `start`. É fácil executar tarefas de desligamento executando o mesmo conjunto de scripts com o argumento `stop`, o que é feito pelo [.filename]#/etc/rc.shutdown#. Observe como isso segue de perto o modo Unix de ter um conjunto de pequenas ferramentas especializadas, cada uma cumprindo sua tarefa da melhor forma possível. _Reutilização de código_ significa que operações comuns são implementadas como funções man:sh[1] e coletadas em [.filename]#/etc/rc.subr#. Agora, um script típico pode conter apenas algumas linhas de código  man:sh[1]. Finalmente, uma parte importante do framework do [.filename]#rc.d# é  man:rcorder[8], o qual ajuda o [.filename]#/etc/rc# a executar os pequenos scripts ordenadamente em relação às dependências entre eles. Ele também pode ajudar o [.filename]#/etc/rc.shutdown#, porque a ordem apropriada para a sequência de encerramento é oposta à da inicialização.

O design do BSD [.filename]#rc.d# é descrito no <<lukem, the original article by Luke Mewburn>>, e os componentes do [.filename]#rc.d# são documentados em grande detalhe nas <<manpages, the respective manual pages>>. No entanto, pode não parecer óbvio para um novato em [.filename]#rc.d# como amarrar os inúmeros pedaços juntos para criar um script bem estilizado para uma tarefa específica. Portanto, este artigo tentará uma abordagem diferente para descrever o [.filename]#rc.d#. Ele mostrará quais recursos devem ser usados em vários casos típicos e por quê. Note que este não é um documento explicativo porque nosso objetivo não é fornecer receitas prontas, mas mostrar algumas entradas fáceis no domínio do [.filename]#rc.d#. Nem este artigo é um substituto para as páginas de manual relevantes. Não hesite em consultá-los para obter uma documentação mais formal e completa ao ler este artigo.

Existem pré-requisitos para entender este artigo. Primeiro de tudo, você deve estar familiarizado com a linguagem de script man:sh[1] para poder dominar o [.filename]#rc.d#. Além disso, você deve saber como o sistema executa as tarefas de inicialização e encerramento do userland, o que está descrito em man:rc[8].

Este artigo foca no branch [.filename]#rc.d# do FreeBSD. No entanto, ele também pode ser útil para os desenvolvedores do NetBSD, porque os dois branchs [.filename]#rc.d# do BSD não apenas compartilham o mesmo design, mas também permanecem similares em seus aspectos visíveis aos autores do script.

[[rcng-task]]
[.title]
== Esboçando a tarefa

Um pouco de consideração antes de iniciar o `$EDITOR` não irá prejudicar. Para escrever um script [.filename]#rc.d# corretamente customizado para um serviço do sistema, devemos poder responder as seguintes questões primeiro:

* O serviço é obrigatório ou opcional?
* O script servirá um único programa, por exemplo, um daemon, ou realizará ações mais complexas?
* De quais outros serviços nosso serviço dependerá e vice-versa?

A partir dos exemplos que se seguem, veremos o porque é importante conhecer as respostas a essas perguntas.

[[rcng-dummy]]
[.title]
== Um script fictício

O script a seguir apenas emite uma mensagem toda vez que o sistema é inicializado:

[.programlisting]
....
#!/bin/sh <.>

. /etc/rc.subr <.>

name=""dummy"" <.>
start_cmd=""${name}_start"" <.>
stop_cmd="":"" <.>

dummy_start() <.>
{
	echo ""Nothing started.""
}

load_rc_config $name <.>
run_rc_command ""$1"" <.>
....

Os pontos a serem observadas são:

&#10122; Um script interpretado deve começar com a linha mágica ""shebang"". Essa linha especifica o programa interpretador para o script. Devido a linha shebang, o script pode ser invocado exatamente como um programa binário, desde que tenha o bit de execução definido. (Veja man:chmod[1].) Por exemplo, um administrador do sistema pode executar nosso script manualmente, a partir da linha de comando:

[source,bash]
....
# /etc/rc.d/dummy start
....

[.note]
====
[.admontitle]*Nota:* +

Para ser adequadamente gerenciado pelo framework do [.filename]#rc.d#, seus scripts precisam ser escritos na linguagem man:sh[1]. Se você tiver um serviço ou port que use um utilitário de controle binário ou uma rotina de inicialização escrita em outra linguagem, instale este elemento em [.filename]#/usr/sbin# (para o sistema) ou em [.filename]#/usr/local/sbin# (para um port) e invoque-o por meio de um script man:sh[1] no diretório apropriado do [.filename]#rc.d#.
====

[.tip]
====
[.admontitle]*Dica:* +

Caso você queira aprender os detalhes do porque os scripts [.filename]#rc.d# devem ser escritos na linguagem man:sh[1], veja como o [.filename]#/etc/rc# invoca-os por meio de `run_rc_script`, e então estude a implementação de `run_rc_script` em [.filename]#/etc/rc. subr#.
====

&#10123; Em [.filename]#/etc/rc.subr#, várias funções man:sh[1] estão definidas para serem utilizadas por um script [.filename]#rc.d#. As funções estão documentadas em man:rc.subr[8]. Embora seja teoricamente possível escrever um script [.filename]#rc.d# sem usar o man:rc.subr[8], as suas funções são extremamente úteis e tornam o trabalho mais fácil. Portanto, não é de surpreender que todos recorram a scripts man:rc.subr[8] em [.filename]#rc.d#. Nós não vamos ser uma exceção.

Um script [.filename]#rc.d# deve ""incluir"" o [.filename]#/etc/rc.subr# (isto por ser feito usando o comando ""`.`"") _antes_ que ele chame as funções do man:rc.subr[8] para que o man:sh[1] tenha a oportunidade para aprender as funções. O estilo preferido é incluir o [.filename]#/etc/rc.subr# antes de tudo.

[.note]
====
[.admontitle]*Nota:* +

Algumas funções úteis relacionadas a rede são fornecidas por outro arquivo include, o [.filename]#/etc/network.subr#.
====

&#10124; [[name-var]]A variável obrigatória `name` especifica o nome do nosso script. Ela é exigida pelo man:rc.subr[8]. Ou seja, cada script [.filename]#rc.d# __deve__ definir a variável `name` antes de chamar funções do man:rc.subr[8].

Agora é o momento certo para escolher um nome exclusivo para o nosso script de uma vez por todas. Vamos usá-lo em vários lugares enquanto desenvolvemos o script. Para começar, também vamos dar o mesmo nome ao arquivo de script.

[.note]
====
[.admontitle]*Nota:* +

O estilo atual do script [.filename]#rc.d# é incluir valores atribuídos as variáveis entre aspas duplas. Tenha em mente que é apenas um problema de estilo que nem sempre pode ser aplicável. Você pode omitir com segurança as aspas das palavras simples sem os metacaracteres do man:sh[1] nelas, enquanto em certos casos você precisará de aspas simples para evitar qualquer interpretação do valor pelo man:sh[1]. Um programador deve ser capaz de dizer a sintaxe da linguagem a partir das convenções de estilo e bem como de usá-las sabiamente.
====

&#10125; A idéia principal por trás do man:rc.subr[8] é que um script [.filename]#rc.d# fornece manipuladores, ou métodos, para o man:rc.subr[8] invocar. Em particular, `start`, `stop` e outros argumentos para um script [.filename]#rc.d# são tratados desta maneira. Um método é uma expressão man:sh[1] armazenada em uma variável denominada `argument_cmd`, no qual _argument_ corresponde ao que pode ser especificado na linha de comando do script. Vamos ver mais adiante como o man:rc.subr[8] fornece métodos default para os argumentos padrão.

[.note]
====
[.admontitle]*Nota:* +

Para tornar o código em [.filename]#rc.d# mais uniforme, é comum usar `${name}` onde for apropriado. Assim, várias linhas podem ser copiadas de um script para outro.
====

&#10126; Devemos ter em mente que o man:rc.subr[8] fornece métodos default para os argumentos padrões. Consequentemente, devemos sobrescrever um método default com uma expressão no-op man:sh[] se desejarmos que ele não faça nada.

&#10127; O corpo de um método sofisticado pode ser implementado como uma função. É uma boa ideia tornar o nome da função significativo.

[.important]
====
[.admontitle]*Importante:* +

É altamente recomendado adicionar o prefixo `${name}` aos nomes de todas as funções definidas em nosso script, para que eles nunca entrem em conflito com as funções do man:rc.subr[8] ou outro arquivo de inclusão comum.
====

&#10128; Essa chamada ao man:rc.subr[8] carrega as variáveis do man:rc.conf[5]. Nosso script não faz uso delas ainda, mas ainda assim é recomendado carregar o man:rc.conf[5] pois podem haver variáveis man:rc.conf[5] controlando o man:rc.subr[8] propriamente dito.

&#10129; Geralmente este é o último comando em um script [.filename]#rc.d#. Ele invoca o maquinário man:rc.subr[8] para executar a ação solicitada usando as variáveis e métodos que nosso script forneceu.

[[rcng-confdummy]]
[.title]
== Um script fictício configurável

Agora vamos adicionar alguns controles ao nosso script fictício. Como você deve saber, os scripts [.filename]#rc.d# são controlados pelo man:rc.conf[5]. Felizmente, o man:rc.subr[8] esconde todas as complicações de nós. O script a seguir usa o man:rc.conf[5] via man:rc.subr[8] para ver se ele está habilitado em primeiro lugar, e buscar uma mensagem para mostrar no momento da inicialização. Estas duas tarefas são de fato independentes. Por um lado, um script [.filename]#rc.d# pode apenas suportar a ativação e desativação de seu serviço. Por outro lado, um script [.filename]#rc.d# obrigatório pode ter variáveis de configuração. Nós vamos fazer as duas coisas no mesmo script:

[.programlisting]
....
#!/bin/sh

. /etc/rc.subr

name=dummy
rcvar=dummy_enable <.>

start_cmd=""${name}_start""
stop_cmd="":""

load_rc_config $name <.>
: ${dummy_enable:=no} <.>
: ${dummy_msg=""Nothing started.""} <.>

dummy_start()
{
	echo ""$dummy_msg"" <.>
}

run_rc_command ""$1""
....

O que mudou neste exemplo?

&#10122; A variável `rcvar` especifica o nome da variável do botão ON/OFF.

&#10123; Agora o `load_rc_config` é invocado anteriormente no script, antes que qualquer variável do man:rc.conf[5] seja acessada.

[.note]
====
[.admontitle]*Nota:* +

Ao examinar os scripts [.filename]#rc.d#, tenha em mente que o man:sh[1] adia a avaliação de expressões em uma função até que a função seja chamada. Portanto, não é um erro invocar `load_rc_config` tão tarde quanto antes do `run_rc_comman` e ainda acessar as variáveis do man:rc.conf[5] a partir do método das funções exportadas para o `run_rc_command`. Isto ocorre porque as funções do método devem ser chamadas por `run_rc_command`, que é chamado _após_ o `load_rc_config`.
====

&#10124; Um aviso será emitido pelo `run_rc_command` se o próprio `rcvar` estiver definido, mas a variável de knob indicada não estiver definida. Se o seu script [.filename]#rc.d# for para o sistema base, você deve adicionar uma configuração padrão para o knob no [.filename]#/etc/defaults/rc.conf# e documentá-lo em man:rc.conf[5]. Caso contrário, será o seu script que deverá fornecer uma configuração padrão para o knob. A abordagem canônica para o último caso é mostrada no exemplo.

[.note]
====
[.admontitle]*Nota:* +

Você pode fazer o man:rc.subr[8] agir como se o knob fosse definido como `ON`, independentemente da sua configuração atual, prefixando o argumento para o script com `one` ou `force`, como em `onestart` ou `forcestop`. Tenha em mente que o `force` tem outros efeitos perigosos que mencionaremos abaixo, enquanto `one` apenas sobrescreve o knob ON/OFF. Por exemplo, suponha que `dummy_enable` seja `OFF`. O comando a seguir executará o método `start` apesar da configuração:

[source,bash]
....
# /etc/rc.d/dummy onestart
....

====

&#10125; Agora, a mensagem a ser mostrada no momento da inicialização não é mais codificada no script. Ela é especificada por uma variável do man:rc.conf[5] chamada `dummy_msg`. Este é um exemplo trivial de como as variáveis do man:rc.conf[5] podem controlar um script [.filename]#rc.d#.

[.important]
====
[.admontitle]*Importante:* +

Os nomes de todas as variáveis do man:rc.conf[5] usadas exclusivamente pelo nosso script _devem_ possuir o mesmo prefixo: `${name}_`. Por exemplo: `dummy_mode`, `dummy_state_file`, e assim por diante.
====

[.note]
====
[.admontitle]*Nota:* +

Embora seja possível usar um nome mais curto internamente, por exemplo, apenas `msg`, adicionar o prefixo exclusivo `${name}_` a todos os nomes globais introduzidos pelo nosso script nos salvará de possíveis colisões com o nome das funções existentes no man:rc.subr[8].

Como regra, os scripts [.filename]#rc.d# do sistema base não precisam fornecer valores padrões para as suas variáveis man:rc.conf[5] porque os padrões devem ser definidos em [.filename]#/etc/defaults/rc.conf#. Por outro lado, os scripts [.filename]#rc.d# para os ports devem fornecer os valores padrões, conforme mostrado no exemplo.
====

&#10126; Aqui usamos `dummy_msg` para realmente controlar nosso script, ou seja, para emitir uma mensagem variável. O uso de uma função de shell é um exagero aqui, já que ele só executa um único comando; uma alternativa igualmente válida seria:

[.programlisting]
....
start_cmd=""echo \\""$dummy_msg\\""""
....

[[rcng-daemon]]
[.title]
== Inicialização e desligamento de um daemon simples

Dissemos anteriormente que o man:rc.subr[8] poderia fornecer métodos padrão. Obviamente, estes padrões não podem ser muito gerais. Eles são adequados para o caso comum de iniciar e encerrar um programa daemon simples. Vamos supor agora que precisamos escrever um script [.filename]#rc.d# para um daemon chamado `mumbled`. Aqui está:

[.programlisting]
....
#!/bin/sh

. /etc/rc.subr

name=mumbled
rcvar=mumbled_enable

command=""/usr/sbin/${name}"" <.>

load_rc_config $name
run_rc_command ""$1""
....

Agradavelmente simples, não é? Vamos examinar nosso pequeno script. A única coisa nova a observar é o seguinte:

&#10122; A variável `command` é significativa para o man:rc.subr[8]. Se estiver definido, o man:rc.subr[8] agirá de acordo com o cenário de servir um daemon convencional. Em particular, os métodos padrão serão fornecidos para tais argumentos: `start`, `stop`, `restart`, `poll`, e `status`.

O daemon será iniciado executando `$command` com os sinalizadores de linha de comando especificados por `$mumbled_flags`. Assim, todos os dados de entrada para o método padrão `start` estão disponíveis nas variáveis configuradas pelo nosso script. Ao contrário do `start`, outros métodos podem requerer informações adicionais sobre o processo iniciado. Por exemplo, `stop` deve conhecer o PID do processo para terminá-lo. No presente caso, man:rc.subr[8]varrerá a lista de todos os processos, procurando por um processo com seu nome igual a `$procname`. Esta última é outra variável de significado para man:rc.subr[8], e seu valor é padronizado para `command`. Em outras palavras, quando definimos o `command`, `procname` é efetivamente definido para o mesmo valor. Isso permite que nosso script mate o daemon e verifique se ele está sendo executado em primeiro lugar.

[.note]
====
[.admontitle]*Nota:* +

Alguns programas são, na verdade, scripts executáveis. O sistema executa esse script iniciando seu interpretador e passando o nome do script para ele como um argumento de linha de comando. Isso é refletido na lista de processos, que podem confundir o man:rc.subr[8]. Você também deve definir o `command_interpreter` para permitir que o man:rc.subr[8] saiba o nome real do processo se o `$command` é um script.

Para cada script [.filename]#rc.d#, existe uma variável man:rc.conf[] que tem precedência sobre `command`. Seu nome é construído da seguinte forma: `${name}_program`, onde `name` é a variável obrigatória que discutimos <<name-var, earlier>>. Por exemplo, neste caso, será `mumbled_program`. É man:rc.subr[8] que organiza `${name}_program` para substituir o comando.

Obviamente, o man:sh[1] permitirá que você defina `${name}_program` a partir do man:rc.conf[5] ou o próprio script, mesmo que o `command` esteja indefinido. Nesse caso, as propriedades especiais de `${name}_program` são perdidas e se tornam uma variável comum que seu script pode usar para seus próprios propósitos. No entanto, o uso exclusivo de `${name}_program` é desencorajado porque usá-lo junto com o `command` tornou-se um idioma na escrita de scripts [.filename]#rc.d#.
====

Para obter informações mais detalhadas sobre métodos padrões, consulte man:rc.subr[8].

[[rcng-daemon-adv]]
[.title]
== Inicialização e desligamento de um daemon avançado

Vamos adicionar um pouco de carne aos ossos do script anterior e torná-lo mais complexo e cheio de funcionalidades. Os métodos padrões podem fazer um bom trabalho para nós, mas podemos precisar ajustar alguns dos seus aspectos. Agora vamos aprender como ajustar os métodos padrões para as nossas necessidades.

[.programlisting]
....
#!/bin/sh

. /etc/rc.subr

name=mumbled
rcvar=mumbled_enable

command=""/usr/sbin/${name}""
command_args=""mock arguments > /dev/null 2>&1"" <.>

pidfile=""/var/run/${name}.pid"" <.>

required_files=""/etc/${name}.conf /usr/share/misc/${name}.rules"" <.>

sig_reload=""USR1"" <.>

start_precmd=""${name}_prestart"" <.>
stop_postcmd=""echo Bye-bye"" <.>

extra_commands=""reload plugh xyzzy"" <.>

plugh_cmd=""mumbled_plugh"" <.>
xyzzy_cmd=""echo 'Nothing happens.'""

mumbled_prestart()
{
	if checkyesno mumbled_smart; then <.>
		rc_flags=""-o smart ${rc_flags}"" <.>
	fi
	case ""$mumbled_mode"" in
	foo)
		rc_flags=""-frotz ${rc_flags}""
		;;
	bar)
		rc_flags=""-baz ${rc_flags}""
		;;
	*)
		warn ""Invalid value for mumbled_mode"" <.>
		return 1 <.>
		;;
	esac
	run_rc_command xyzzy <.>
	return 0
}

mumbled_plugh() <.>
{
	echo 'A hollow voice says ""plugh"".'
}

load_rc_config $name
run_rc_command ""$1""
....

&#10122; Argumentos adicionais para `$command` podem ser passados em `command_args`. Eles serão adicionados a linha de comando após `$mumbled_flags`. Como a linha de comando final é passada para `eval` para sua execução real, os redirecionamentos de entrada e saída podem ser especificados em `command_args`.

[.note]
====
[.admontitle]*Nota:* +

_Nunca_ inclua opções tracejadas, como `-X` ou `--foo`, em `command_args`. O conteúdo de `command_args` aparecerá no final da linha de comando final, portanto é provável que eles sigam os argumentos presentes em `${name}_flags`; mas a maioria dos comandos não reconhecerá opções tracejadas após argumentos comuns. Uma maneira melhor de passar opções adicionais para `$command` é adicioná-las ao início de `${name}_flags`. Outra maneira é modificar `rc_flags` <<rc-flags, as shown later>>.
====

&#10123; Um daemon de boas maneiras deve criar um _pidfile_ para que seu processo possa ser encontrado com mais facilidade e confiabilidade. A variável `pidfile`, se configurada, informa ao man:rc.subr[8] onde pode encontrar o pidfile para seus métodos padrão possam usar.

[.note]
====
[.admontitle]*Nota:* +

De fato, o man:rc.subr[8] também usará o pidfile para ver se o daemon já está em execução antes de iniciá-lo. Esta verificação pode ser ignorada usando o argumento `faststart`.
====

&#10124; Se o daemon não puder ser executado a menos que existam certos arquivos, apenas liste-os em `required_files`, e man:rc.subr[8] irá verificar se esses arquivos existem antes de iniciar o daemon. Também existem `required_dirs` e `required_vars` para diretórios e variáveis de ambiente, respectivamente. Todos eles são descritos em detalhes em man:rc.subr[8].

[.note]
====
[.admontitle]*Nota:* +

O método padrão de man:rc.subr[8] pode ser forçado a ignorar as verificações de pré-requisitos usando `forcestart` como o argumento para o script.
====

&#10125; Podemos personalizar sinais para enviar para o daemon caso eles sejam diferentes dos mais conhecidos. Em particular, `sig_reload` especifica o sinal que faz o daemon recarregar sua configuração; é `SIGHUP` por padrão. Outro sinal é enviado para parar o processo do daemon; o padrão é `SIGTERM`, mas isso pode ser alterado definindo `sig_stop` apropriadamente.

[.note]
====
[.admontitle]*Nota:* +

Os nomes dos sinais devem ser especificados para o man:rc.subr[8] sem o prefixo `SIG`, como é mostrado no exemplo. A versão do FreeBSD do man:kill[1] pode reconhecer o prefixo `SIG`, mas as versões de outros tipos de sistema operacional não.
====

&#10126;&#10127; Realizar tarefas adicionais antes ou depois dos métodos padrão é fácil. Para cada argumento de comando suportado pelo nosso script, podemos definir o argumento `_precmd` e `_postcmd`. Esses comandos no man:sh[1] são invocados antes e depois do respectivo método, como é evidente em seus nomes.

[.note]
====
[.admontitle]*Nota:* +

Sobrescrever um método padrão com um `argumento _cmd` personalizado ainda não nos impede de fazer uso do `argumento _precmd` ou `argumento _postcmd` se precisarmos. Em particular, o primeiro é bom para verificar condições personalizadas e sofisticadas que devem ser atendidas antes de executar o comando em si. Usar o `argumento _precmd` junto com o `argumento _cmd` nos permite separar logicamente as verificações da ação.

Não se esqueça de que você pode amontoar qualquer expressão válida do man:sh[1] nos métodos, pré e pós-comandos definidos por você. Apenas invocar uma função que faz com que o trabalho real seja um bom estilo na maioria dos casos, mas nunca deixe o estilo limitar sua compreensão do que está acontecendo por trás da cortina.
====

&#10128; Se quisermos implementar argumentos customizados, que também podem ser considerados como _comandos_ para o nosso script, precisamos listá-los em `extra_commands` e fornecer métodos para manipulá-los.

[.note]
====
[.admontitle]*Nota:* +

O comando `reload` é especial. Por um lado, tem um método predefinido em man:rc.subr[8]. Por outro lado, `reload` não é oferecido por padrão. A razão é que nem todos os daemons usam o mesmo mecanismo de recarga e alguns não têm nada para recarregar. Portanto, precisamos solicitar explicitamente que a funcionalidade incorporada seja fornecida. Podemos fazer isso via `extra_commands`.

O que obtemos do método padrão para `reload`? Muitas vezes, os daemons recarregam sua configuração na recepção de um sinal - normalmente, `SIGHUP`. Portanto, o man:rc.subr[8] tenta recarregar o daemon enviando um sinal para ele. O sinal é predefinido para `SIGHUP`, mas pode ser personalizado via `sig_reload`, caso necessário.
====

&#10129;&#9454; Nosso script suporta dois comandos não padrão, `plugh` e `xyzzy`. Nós os vimos listados em `extra_commands`, e agora é hora de fornecer métodos para eles. O método para `xyzzy` é apenas embutido, enquanto que para `plugh` é implementado como a função `mumbled_plugh`.

Comandos não padrão não são chamados durante a inicialização ou o desligamento. Geralmente eles são para a conveniência do administrador do sistema. Eles também podem ser usados de outros subsistemas, por exemplo, man:devd[8] se especificado em man:devd.conf[5].

A lista completa de comandos disponíveis pode ser encontrada na linha de uso impressa por man:rc.subr[8] quando o script é invocado sem argumentos. Por exemplo, aqui está a linha de uso do script em estudo:

[source,bash]
....
# /etc/rc.d/mumbled
Uso: /etc/rc.d/mumbled [fast|force|one](start|stop|restart|rcvar|reload|plugh|xyzzy|status|poll)
....

&#9453; Um script pode invocar seus próprios comandos padrão ou não padrão, se necessário. Isto pode parecer semelhante as funções de chamada, mas sabemos que comandos e funções de shell nem sempre são a mesma coisa. Por exemplo, `xyzzy` não é implementado como uma função aqui. Além disso, pode haver um pré-comando e um pós-comando, que devem ser chamados ordenadamente. Portanto, a maneira correta de um script executar seu próprio comando é por meio de man:rc.subr[8], conforme mostrado no exemplo.

&#10130; Uma função útil chamada `checkyesno` é fornecida por man:rc.subr[8]. Ele usa um nome de variável como argumento e retorna um código de saída zero se, e somente se, a variável estiver configurada como `YES`, ou `TRUE`, ou `ON`, ou `1`, sem distinção entre maiúsculas e minúsculas; um código de saída diferente de zero é retornado de outra forma. No último caso, a função testa a variável como sendo definida como `NO`,`FALSE`,`OFF` ou `0` insensível a maiúsculas e minúsculas; imprime uma mensagem de aviso se a variável contiver qualquer outra coisa, ou seja, lixo.

Tenha em mente que para o man:sh[1] um código de saída zero significa verdadeiro e um código de saída diferente de zero significa falso.

[.important]
====
[.admontitle]*Importante:* +

A função `checkyesno` recebe um __nome da variável__. Não passe o _valor_ expandido de uma variável para ele; não funcionará como esperado.

O uso correto de `checkyesno` é:

[.programlisting]
....
if checkyesno mumbled_enable; then
        foo
fi
....

Pelo contrário, chamar `checkyesno` como mostrado abaixo não funcionará - pelo menos não como esperado:

[.programlisting]
....
if checkyesno ""${mumbled_enable}""; then
        foo
fi
....

====

&#10131; [[rc-flags]] Podemos afetar os sinalizadores a serem passados para `$command` modificando `rc_flags` em `$start_precmd`.

&#9451; Em certos casos, podemos precisar emitir uma mensagem importante que também deve ser enviada para o `syslog`. Isto pode ser feito facilmente com as seguintes funções man:rc.subr[8]: `debug`, `info`, `warn` e `err`. A última função, em seguida, sai do script com o código especificado.

&#9452; Os códigos de saída dos métodos e seus pré-comandos não são apenas ignorados por padrão. Se o argumento `_precmd` retornar um código de saída diferente de zero, o método principal não será executado. Por sua vez, o `argumento_postcmd` não será invocado a menos que o método principal retorne um código de saída zero.

[.note]
====
[.admontitle]*Nota:* +

No entanto, o man:rc.subr[8] pode ser instruído a partir da linha de comando para ignorar esses códigos de saída e invocar todos os comandos, prefixando um argumento com `force`, como em `forcestart`.
====

[[rcng-hookup]]
[.title]
== Conectando um script ao framework rc.d

Depois que um script foi escrito, ele precisa ser integrado em [.filename]#rc.d>#. O passo crucial é instalar o script em [.filename]#/etc/rc.d# (para o sistema base) ou [.filename]#/usr/local/etc/rc.d# (para ports). Ambos [.filename]#bsd.prog.mk# e [.filename]#bsd.port.mk# fornecer ganchos convenientes para isso, e geralmente você não precisa se preocupar com a propriedade e o modo adequado. Os scripts do sistema devem ser instalados a partir do [.filename]#src /etc/rc.d# através do [.filename]#Makefile# encontrado lá. Os scripts de porta podem ser instalados usando `USE_RC_SUBR` conforme descrito em link:{porters-handbook}#rc-scripts[no Manual do Porter].

No entanto, devemos considerar antecipadamente o local do nosso script na sequência de inicialização do sistema. O serviço manipulado pelo nosso script provavelmente depende de outros serviços. Por exemplo, um daemon de rede não pode funcionar sem as interfaces de rede e o roteamento em funcionamento. Mesmo que um serviço pareça não exigir nada, dificilmente pode ser iniciado antes que os sistemas de arquivos básicos tenham sido verificados e montados.

Nós já mencionamos o man:rcorder[8]. Agora é hora de dar uma olhada de perto. Em poucas palavras, o man:rcorder[8] pega um conjunto de arquivos, examina seu conteúdo e imprime uma lista ordenada por dependência de arquivos do conjunto para `stdout`. O objetivo é manter as informações de dependência _dentro_ dos arquivos para que cada arquivo possa falar por si só. Um arquivo pode especificar as seguintes informações:

* os nomes das ""condições"" (o que significa serviços para nós) que ele __fornece__;
* os nomes das ""condições"" que ele __requer__;
* os nomes das ""condições"" deste arquivo devem ser executados __antes__;
* _palavras-chave adicionais_ que podem ser usadas para selecionar um subconjunto de todo o conjunto de arquivos (man:rcorder[8] podem ser instruídos através de opções para incluir ou omitir os arquivos com determinadas palavras-chave listadas.)

Não é surpresa que man:rcorder[8] possa manipular apenas arquivos de texto com uma sintaxe próxima a de man:sh[1]. Ou seja, linhas especiais compreendidas por man:rcorder[8] se parecem com comentários man:sh[1]. A sintaxe de tais linhas especiais é bastante rígida para simplificar seu processamento. Veja man:rcorder[8] para detalhes.

Além de usar linhas especiais do man:rcorder[8], um script pode insistir em sua dependência de outro serviço apenas iniciando-o forçadamente. Isso pode ser necessário quando o outro serviço é opcional e não será iniciado automaticamente porque o administrador do sistema o desativou por engano no man:rc.conf[5].

Com este conhecimento geral em mente, vamos considerar o simples script daemon aprimorado com coisas de dependência:

[.programlisting]
....
#!/bin/sh

# PROVIDE: mumbled oldmumble <.>
# REQUIRE: DAEMON cleanvar frotz <.>
# BEFORE:  LOGIN <.>
# KEYWORD: nojail shutdown <.>

. /etc/rc.subr

name=mumbled
rcvar=mumbled_enable

command=""/usr/sbin/${name}""
start_precmd=""${name}_prestart""

mumbled_prestart()
{
	if ! checkyesno frotz_enable && \\
	    ! /etc/rc.d/frotz forcestatus 1>/dev/null 2>&1; then
		force_depend frotz || return 1 <.>
	fi
	return 0
}

load_rc_config $name
run_rc_command ""$1""
....

Como antes, a análise detalhada segue:

&#10122; Esta linha declara os nomes das ""condições"" que nosso script fornece. Agora, outros scripts podem registrar uma dependência em nosso script por estes nomes.

[.note]
====
[.admontitle]*Nota:* +

Geralmente, um script especifica uma única condição fornecida. No entanto, nada nos impede de listar várias condições, por exemplo, por razões de compatibilidade.

Em qualquer caso, o nome da condição principal, ou a única, `PROVIDE:` deve ser o mesmo que `${name}`.
====

&#10123;&#10124; Portanto, nosso script indica quais condições """" são fornecidas por outros scripts dos quais depende. De acordo com as linhas, nosso script pede ao man:rcorder[8] para colocá-lo após o(s) script(s) fornecendo [.filename]#DAEMON# e [.filename]#cleanvar#, mas antes disso prover [.filename]#LOGIN#.

[.note]
====
[.admontitle]*Nota:* +

A linha `BEFORE:` não deve ser abusada para contornar uma lista de dependências incompleta no outro script. O caso apropriado para usar o `BEFORE:` é quando o outro script não se importa com o nosso, mas nosso script pode fazer sua tarefa melhor se for executado antes do outro. Um típico exemplo da vida real são as interfaces de rede versus o firewall: embora as interfaces não dependam do firewall em realizar seu trabalho, a segurança do sistema se beneficiará do firewall estar pronto antes que haja qualquer tráfego de rede.

Além das condições correspondentes a um único serviço, existem meta-condições e seus scripts ""placeholder"" usados para garantir que determinados grupos de operações sejam executados antes dos outros. Estes são denotados pelos nomes [.filename]#UPPERCASE#. Sua lista e finalidades podem ser encontradas em man:rc[8].

Tenha em mente que colocar um nome de serviço na linha `REQUIRE:` não garante que o serviço estará realmente em execução no momento em que nosso script for iniciado. O serviço necessário pode falhar ao iniciar ou simplesmente ser desativado em man:rc.conf[5]. Obviamente, o man:rcorder[8] não pode controlar tais detalhes, e o man:rc[8] também não fará isso. Consequentemente, o aplicativo iniciado por nosso script deve ser capaz de lidar com quaisquer serviços necessários indisponíveis. Em certos casos, podemos ajudá-lo conforme discutido <<forcedep, below>>
====

&#10125; [[keywords]] Como lembramos do texto acima, as palavras-chave do man:rcorder[8] podem ser usadas para selecionar ou deixar alguns scripts. Ou seja, qualquer consumidor man:rcorder[8] pode especificar através das opções `-k` e `-s` que as palavras-chave estão na ""keep list"" e na ""skip list"", respectivamente. De todos os arquivos a serem classificados, o man:rcorder[8] selecionará apenas aqueles que tiverem uma palavra-chave da lista de manutenção (a menos que vazia) e não uma palavra-chave da lista de itens ignorados.

No FreeBSD, o man:rcorder[8] é usado por [.filename]#/etc/rc# e [.filename]#/etc/rc.shutdown#. Esses dois scripts definem a lista padrão de palavras-chave do [.filename]#rc.d# do FreeBSD e seus significados da seguinte forma:

&#10126; [[forcedep]] Para começar, `force_depend` deve ser usado com muito cuidado. Geralmente é melhor revisar a hierarquia de variáveis de configuração para seus scripts [.filename]#rc.# se eles forem interdependentes.

Se você ainda não pode fazer sem `force_depend`, o exemplo oferece uma expressão de como invocá-lo condicionalmente. No exemplo, nosso daemon `mumbled` requer que outro, `frotz`, seja iniciado antecipadamente. No entanto, `frotz` é opcional também; e man:rcorder[8] não sabe nada sobre esses detalhes. Felizmente, nosso script tem acesso a todas as variáveis man:rc.conf[5]. Se `frotz_enable` estiver como true, esperamos pelo melhor e dependemos de [.filename]#rc.d# para iniciar `frotz`. Caso contrário, nós forçadamente verificaremos o status de `frotz`. Finalmente, impomos nossa dependência ao `frotz` se ele não estiver sendo executado. Uma mensagem de aviso será emitida por `force_depend` porque ele deve ser chamado apenas se um erro de configuração for detectado.

[[rcng-args]]
[.title]
== Dando mais flexibilidade a um script rc.d

Quando chamado durante a inicialização ou desligamento, um script [.filename]#rc.d# deve agir em todo o subsistema pelo qual é responsável. Por exemplo, [.filename]#/etc/rc.d/netif# deve iniciar ou parar todas as interfaces de rede descritas por man:rc.conf[5]. Qualquer tarefa pode ser indicada exclusivamente por um único argumento de comando, como `start` ou `stop`. Entre a inicialização e o desligamento, os scripts [.filename]#rc.d# ajudam o administrador a controlar o sistema em execução, e é quando surge a necessidade de mais flexibilidade e precisão. Por exemplo, o administrador pode querer adicionar as configurações de uma nova interface de rede ao man:rc.conf[5] e então iniciá-lo sem interferir o funcionamento das interfaces existentes. Da próxima vez, o administrador pode precisar desligar uma única interface de rede. No espírito da linha de comando, o respectivo script [.filename]#rc.d# solicita um argumento extra, o nome da interface.

Felizmente, man:rc.subr[8] permite passar qualquer número de argumentos para os métodos do script (dentro dos limites do sistema). Devido a isso, as alterações no próprio script podem ser mínimas.

Como o man:rc.subr[8] pode obter acesso aos argumentos de linha de comando extra. Deveria pegá-los diretamente? Não por qualquer meio. Primeiro, uma função man:sh"" ""1"" >}} não tem acesso aos parâmetros posicionais de seu chamador, mas o man:rc.subr[8] é apenas uma despedida de tais funções. Em segundo lugar, a boa maneira de [.filename]#rc.d# determina que é para o script principal decidir quais argumentos devem ser passados para seus métodos.

Portanto, a abordagem adotada por man:rc.subr[8] é a seguinte: `run_rc_command` transmite todos os seus argumentos, mas o primeiro um para o respectivo método na íntegra. O primeiro, omitido, argumento é o nome do próprio método: `start`,`stop`, etc. Ele será deslocado por `run_rc_command`, então o que é `$2` na linha de comando original será apresentado como `$1` ao método, e assim por diante.

Para ilustrar essa oportunidade, vamos modificar o script fictício primitivo para que suas mensagens dependam dos argumentos adicionais fornecidos. Aqui vamos nós:

[.programlisting]
....
#!/bin/sh

. /etc/rc.subr

name=""dummy""
start_cmd=""${name}_start""
stop_cmd="":""
kiss_cmd=""${name}_kiss""
extra_commands=""kiss""

dummy_start()
{
        if [ $# -gt 0 ]; then <.>
                echo ""Greeting message: $*""
        else
                echo ""Nothing started.""
        fi
}

dummy_kiss()
{
        echo -n ""A ghost gives you a kiss""
        if [ $# -gt 0 ]; then <.>
                echo -n "" and whispers: $*""
        fi
        case ""$*"" in
        *[.!?])
                echo
                ;;
        *)
                echo .
                ;;
        esac
}

load_rc_config $name
run_rc_command ""$@"" <.>
....

Quais mudanças essenciais podemos notar no script?

&#10122; Todos os argumentos digitados após `start` podem terminar como parâmetros posicionais para o respectivo método. Podemos usá-los de qualquer maneira de acordo com nossa tarefa, habilidades e fantasia. No exemplo atual, apenas passamos todos eles para man:echo[1] como uma cadeia na linha seguinte - note `$*` entre aspas duplas. Aqui está como o script pode ser chamado agora:

[source,bash]
....
# /etc/rc.d/dummy start
Nothing started.
# /etc/rc.d/dummy start Hello world!
Greeting message: Hello world!
....

&#10123; O mesmo se aplica a qualquer método que nosso script forneça, não apenas a um método padrão. Nós adicionamos um método customizado chamado `kiss`, e ele pode tirar proveito dos argumentos extras da mesma forma que o `start` tira. Por exemplo:

[source,bash]
....
# /etc/rc.d/dummy kiss
A ghost gives you a kiss.
# /etc/rc.d/dummy kiss Once I was Etaoin Shrdlu...
A ghost gives you a kiss and whispers: Once I was Etaoin Shrdlu...
....

&#10124; Se quisermos apenas passar todos os argumentos extras para qualquer método, podemos simplesmente substituir `""$@""` por `""$ 1""` na última linha do nosso script, onde invocamos o `run_rc_command`.

[.important]
====
[.admontitle]*Importante:* +

Um programador man:sh[1] deve entender a diferença sutil entre `$*` e `$@` como as formas de designar todos os parâmetros posicionais. Para sua discussão aprofundada, consulte um bom manual sobre programação de scripts man:sh[1]. _Não_ use estas expressões até que você as compreenda completamente, porque o uso incorreto delas resultará em scripts inseguros e contendo bugs.
====

[.note]
====
[.admontitle]*Nota:* +

Atualmente, o `run_rc_command` pode ter um bug que o impede de manter os limites originais entre os argumentos. Ou seja, argumentos com espaços em branco incorporados podem não ser processados corretamente. O bug deriva do uso inadequado de `$*`.
====

[[rcng-furthur]]
[.title]
== Leitura adicional

[[lukem]]http://www.mewburn.net/luke/papers/rc.d.pdf[O artigo original de Luke Mewburn] oferece uma visão geral do [.filename]#rc.d# e o raciocínio detalhado que o levou a suas decisões de design. Ele fornece informações sobre toda o framework do [.filename]#rc.d# e o seu lugar em um moderno sistema operacional BSD.

[[manpages]]As páginas de manual man:rc[8], man:rc.subr[8] e man:rcorder[8] documentam os componentes do [.filename]#rc.d# com grande detalhe. Você não pode usar totalmente o poder do [.filename]#rc.d# sem estudar as páginas de manual e se referir a elas enquanto escreve seus próprios scripts.

A sua principal fonte de inspiração são os exemplos da vida real, existentes em no [.filename]#/etc/rc.d# de um sistema vivo. Seu conteúdo é fácil e agradável de ler, porque a maioria dos cantos ásperos estão escondidos fundo no man:rc.subr[8]. Tenha em mente que os scripts [.filename]#/etc/rc.d# não foram escritos por anjos, então eles podem sofrer de bugs e decisões sub-ótimas de design. Agora você pode melhorá-los!
",12120,False,2378.846675807375,median
"/***
*
*	Copyright (c) 1996-2001, Valve LLC. All rights reserved.
*
*	This product contains software technology licensed from Id
*	Software, Inc. (""Id Technology"").  Id Technology (c) 1996 Id Software, Inc.
*	All Rights Reserved.
*
*   Use, distribution, and modification of this source code and/or resulting
*   object code is restricted to non-commercial enhancements to products from
*   Valve LLC.  All other use, distribution, or modification is prohibited
*   without written permission from Valve LLC.
*
****/
#include <algorithm>
#include <array>

#include ""extdll.h""
#include ""util.h""
#include ""client.h""
#include ""cbase.h""
#include ""basemonster.h""
#include ""player.h""
#include ""weapons.h""
#include ""game.h""
#include ""gamerules.h""
#include ""UserMessages.h""

#include ""ctfplay_gamerules.h""
#include ""CTFGoalFlag.h""
#include ""CItemCTF.h""
#include ""CTFGoalBase.h""

#include ""CItemAcceleratorCTF.h""
#include ""CItemBackpackCTF.h""
#include ""CItemLongJumpCTF.h""
#include ""CItemPortableHEVCTF.h""
#include ""CItemRegenerationCTF.h""

#include ""pm_shared.h""

extern DLL_GLOBAL BOOL		g_fGameOver;

const int MaxTeamNameLength = 16;
const int MaxTeamCharacters = 12;
const int MaxTeamCharacterNameLength = 16;

char g_szScoreIconNameBM[ 40 ] = ""item_ctfflagh"";
char g_szScoreIconNameOF[ 40 ] = ""item_ctfflagh"";

float g_flFlagReturnTime = 30;
float g_flBaseDefendDist = 192;
float g_flDefendCarrierTime = 10;
float g_flCaptureAssistTime = 10;
float g_flPowerupRespawnTime = 30;
int g_iMapScoreMax = 0;

char* pszPlayerIPs[ SV_MAX_PLAYERS * 2 ];

static int team_scores[ MaxTeams ];
int teamscores[ MaxTeams ];
static int team_count[ MaxTeams ];

static const char team_names[ MaxTeams ][ MaxTeamNameLength ] =
{
	{ ""Black Mesa"" },
	{ ""Opposing Force"" }
};

//First half are first team, second half are second team
//TODO: rework so it's 2 separate lists
static const std::array<const char*, MaxTeamCharacters> team_chars =
{
	""ctf_barney"",
	""cl_suit"",
	""ctf_gina"",
	""ctf_gordon"",
	""otis"",
	""ctf_scientist"",
	""beret"",
	""drill"",
	""grunt"",
	""recruit"",
	""shepard"",
	""tower"",
};

int ToTeamIndex( const CTFTeam team )
{
	return static_cast<int>( team ) - 1;
}

const char* GetTeamName( edict_t *pEntity )
{
	if( g_pGameRules->IsCTF() )
	{
		auto pPlayer = static_cast<CBasePlayer*>( CBaseEntity::Instance( pEntity ) );

		return team_names[ ( int ) pPlayer->m_iTeamNum - 1 ];
	}
	else
	{
		//A bit counterintuitive, this basically means each player model is a team
		if( g_pGameRules->IsDeathmatch() && g_pGameRules->IsTeamplay() )
		{
			return g_engfuncs.pfnInfoKeyValue( g_engfuncs.pfnGetInfoKeyBuffer( pEntity ), ""model"" );
		}
		else
		{
			static char szTmp[ 256 ];

			snprintf( szTmp, sizeof( szTmp ), ""%i"", g_engfuncs.pfnGetPlayerUserId( pEntity ) );
			return szTmp;
		}
	}
}

CTFTeam GetWinningTeam()
{
	if( teamscores[ 0 ] != teamscores[ 1 ] )
		return ( teamscores[ 0 ] <= teamscores[ 1 ] ) ? CTFTeam::BlackMesa : CTFTeam::OpposingForce;
	return CTFTeam::None;
}

void GetLosingTeam( int& iTeamNum, int& iScoreDiff )
{
	iTeamNum = 0;
	iScoreDiff = 0;

	//TODO: doesn't really make sense, if team 0 is losing the score difference is 0
	if( teamscores[ 1 ] < teamscores[ 0 ] )
	{
		iTeamNum = 1;

		const auto difference = teamscores[ 0 ] - teamscores[ 1 ];

		if( iScoreDiff < difference )
			iScoreDiff = difference;
	}
}

static void SendFlagIcon(CBasePlayer* player, bool isActive, const char* flagName, int teamIndex)
{
	g_engfuncs.pfnMessageBegin(MSG_ONE, gmsgFlagIcon, nullptr, player->edict());
	g_engfuncs.pfnWriteByte(isActive ? 1 : 0);
	g_engfuncs.pfnWriteString(flagName);
	g_engfuncs.pfnWriteByte(teamIndex);

	int r, g, b;

	if (teamIndex == 0)
	{
		UnpackRGB(r, g, b, RGB_YELLOWISH);
	}
	else
	{
		UnpackRGB(r, g, b, RGB_HUD_COLOR);
	}

	g_engfuncs.pfnWriteByte(r);
	g_engfuncs.pfnWriteByte(g);
	g_engfuncs.pfnWriteByte(b);
	
	g_engfuncs.pfnWriteByte(teamscores[teamIndex]);
	g_engfuncs.pfnMessageEnd();
}

static void SendFlagIcons(CBasePlayer* player, CTFGoalFlag* team1Flag, CTFGoalFlag* team2Flag)
{
	if (team1Flag || team2Flag)
	{
		auto pMyFlag = static_cast<CTFGoalFlag*>(static_cast<CBaseEntity*>(player->m_pFlag));

		if (team1Flag)
		{
			const char* flagName = """";

			switch (team1Flag->m_iGoalState)
			{
			case 1:
				flagName = ""item_ctfflagh"";
				break;
			case 2:
				if (pMyFlag == team1Flag && pMyFlag)
				{
					flagName = ""item_ctfflagg"";
				}
				else
				{
					flagName = ""item_ctfflagc"";
				}
				break;
			case 3:
				flagName = ""item_ctfflagd"";
				break;
			}

			SendFlagIcon(player, true, flagName, 0);
		}

		if (team2Flag)
		{
			const char* flagName = """";

			switch (team2Flag->m_iGoalState)
			{
			case 1:
				flagName = ""item_ctfflagh"";
				break;
			case 2:
				if (pMyFlag == team2Flag && pMyFlag)
				{
					flagName = ""item_ctfflagg"";
				}
				else
				{
					flagName = ""item_ctfflagc"";
				}
				break;
			case 3:
				flagName = ""item_ctfflagd"";
				break;
			}

			SendFlagIcon(player, true, flagName, 1);
		}
	}
	else
	{
		SendFlagIcon(player, true, g_szScoreIconNameBM, 0);
		SendFlagIcon(player, true, g_szScoreIconNameOF, 1);
	}
}

void DisplayTeamFlags(CBasePlayer* pPlayer)
{
	if (!gmsgFlagIcon)
		return;

	CTFGoalFlag* team1Flag = nullptr;

	while ((team1Flag = static_cast<CTFGoalFlag*>(UTIL_FindEntityByClassname(team1Flag, ""item_ctfflag""))) && team1Flag->m_iGoalNum != 1)
	{
	}

	CTFGoalFlag* team2Flag = nullptr;

	while ((team2Flag = static_cast<CTFGoalFlag*>(UTIL_FindEntityByClassname(team2Flag, ""item_ctfflag""))) && team2Flag->m_iGoalNum != 2)
	{
	}

	if (pPlayer)
	{
		SendFlagIcons(pPlayer, team1Flag, team2Flag);
	}
	else
	{
		for (int i = 1; i <= gpGlobals->maxClients; ++i)
		{
			auto player = static_cast<CBasePlayer*>(UTIL_PlayerByIndex(i));

			if (player)
			{
				SendFlagIcons(player, team1Flag, team2Flag);
			}
		}
	}
}

bool CheckForLevelEnd( int iMaxScore )
{
	if( iMaxScore == 0 )
	{
		iMaxScore = 255;
	}

	if( g_iMapScoreMax > 0 && iMaxScore > g_iMapScoreMax )
		iMaxScore = g_iMapScoreMax;

	return teamscores[ 0 ] >= iMaxScore || teamscores[ 1 ] >= iMaxScore;
}

void ResetTeamScores()
{
	teamscores[ 0 ] = 0;
	teamscores[ 1 ] = 0;
}

struct ItemData
{
	using CleanupCallback_t = void( * )( CBasePlayer* pPlayer );

	const CTFItem::CTFItem Mask;
	const char* const Name;

	const color24 IconColor;

	const bool RespawnOrScatter;

	const CleanupCallback_t CleanupCallback;
};

const ItemData CTFItems[] =
{
	{ CTFItem::BlackMesaFlag, """", { 1, 1, 1 }, false, nullptr },
	{ CTFItem::OpposingForceFlag, """", { 1, 1, 2 }, false, nullptr },

	{ CTFItem::LongJump, ""item_ctflongjump"", { 1, 0, 4 }, true, nullptr },
	{ CTFItem::PortableHEV, ""item_ctfportablehev"", { 1, 0, 8 }, true, []( auto pPlayer )
		{
			if( pPlayer->m_fPlayingAChargeSound )
			{
				STOP_SOUND( pPlayer->edict(), CHAN_STATIC, ""ctf/pow_armor_charge.wav"" );
				pPlayer->m_fPlayingAChargeSound = false;
			}
		}
	},
	{ CTFItem::Backpack, ""item_ctfbackpack"", { 1, 0, 16 }, true, nullptr },
	{ CTFItem::Acceleration, ""item_ctfaccelerator"", { 1, 0, 32 }, true, nullptr },
	{ CTFItem::Regeneration, ""item_ctfregeneration"", { 1, 0, 128 }, true, []( auto pPlayer )
		{
			if( pPlayer->m_fPlayingHChargeSound )
			{
				STOP_SOUND( pPlayer->edict(), CHAN_STATIC, ""ctf/pow_health_charge.wav"" );
				pPlayer->m_fPlayingHChargeSound = false;
			}
		}
	},
};

template<typename ItemCallback>
static void ForEachPlayerCTFPowerup( CBasePlayer* pPlayer, ItemCallback callback )
{
	if( !pPlayer || !( pPlayer->m_iItems & CTFItem::ItemsMask ) )
	{
		return;
	}

	for( const auto& item : CTFItems )
	{
		if( item.RespawnOrScatter && ( pPlayer->m_iItems & item.Mask ) )
		{
			for( CItemCTF* pItem = nullptr; ( pItem = static_cast<CItemCTF* >( UTIL_FindEntityByClassname( pItem, item.Name ) ) ); )
			{
				if( pItem->team_no == CTFTeam::None || pItem->team_no == pPlayer->m_iTeamNum )
				{
					callback( pPlayer, pItem );
					break;
				}
			}

			if( item.CleanupCallback )
			{
				item.CleanupCallback( pPlayer );
			}

			pPlayer->m_iItems = (CTFItem::CTFItem ) ( pPlayer->m_iItems & ~item.Mask );
		}
	}
}

void RespawnPlayerCTFPowerups( CBasePlayer* pPlayer, bool bForceRespawn )
{
	ForEachPlayerCTFPowerup( pPlayer, [ = ]( auto pPlayer, auto pItem )
		{
			pItem->DropItem( pPlayer, bForceRespawn );
		}
	);
}

void ScatterPlayerCTFPowerups( CBasePlayer* pPlayer )
{
	ForEachPlayerCTFPowerup( pPlayer, [ = ]( auto pPlayer, auto pItem )
		{
			pItem->ScatterItem( pPlayer );
		}
	);
}

void DropPlayerCTFPowerup( CBasePlayer* pPlayer )
{
	ForEachPlayerCTFPowerup( pPlayer, [ = ]( auto pPlayer, auto pItem )
		{
			pItem->ThrowItem( pPlayer );
		}
	);
}

void FlushCTFPowerupTimes()
{
	for( auto pItem : UTIL_FindEntitiesByClassname<CItemCTF>( ""item_ctflongjump"" ) )
	{
		auto pPlayer = GET_PRIVATE<CBasePlayer>( pItem->pev->owner );

		if( pPlayer && pPlayer->IsPlayer() )
		{
			pPlayer->m_flJumpTime += gpGlobals->time - pItem->m_flPickupTime;
		}
	}

	for( auto pItem : UTIL_FindEntitiesByClassname<CItemPortableHEVCTF>( ""item_ctfportablehev"" ) )
	{
		auto pPlayer = GET_PRIVATE<CBasePlayer>( pItem->pev->owner );

		if( pPlayer && pPlayer->IsPlayer() )
		{
			pPlayer->m_flShieldTime += gpGlobals->time - pItem->m_flPickupTime;
		}
	}

	for( auto pItem : UTIL_FindEntitiesByClassname<CItemRegenerationCTF>( ""item_ctfregeneration"" ) )
	{
		auto pPlayer = GET_PRIVATE<CBasePlayer>( pItem->pev->owner );

		if( pPlayer && pPlayer->IsPlayer() )
		{
			pPlayer->m_flHealthTime += gpGlobals->time - pItem->m_flPickupTime;
		}
	}

	for( auto pItem : UTIL_FindEntitiesByClassname<CItemBackpackCTF>( ""item_ctfbackpack"" ) )
	{
		auto pPlayer = GET_PRIVATE<CBasePlayer>( pItem->pev->owner );

		if( pPlayer && pPlayer->IsPlayer() )
		{
			pPlayer->m_flBackpackTime += gpGlobals->time - pItem->m_flPickupTime;
		}
	}

	for( auto pItem : UTIL_FindEntitiesByClassname<CItemAcceleratorCTF>( ""item_ctfaccelerator"" ) )
	{
		auto pPlayer = GET_PRIVATE<CBasePlayer>( pItem->pev->owner );

		if( pPlayer && pPlayer->IsPlayer() )
		{
			pPlayer->m_flAccelTime += gpGlobals->time - pItem->m_flPickupTime;
		}
	}
}

void InitItemsForPlayer( CBasePlayer* pPlayer )
{
	if( gmsgPlayerIcon )
	{
		for( auto pOther : UTIL_FindPlayers() )
		{
			for( const auto& item : CTFItems )
			{
				//TODO: this can probably be optimized by finding the last item that the player is carrying and only sending that
				if( pOther->m_iItems & item.Mask )
				{
					g_engfuncs.pfnMessageBegin( MSG_ONE, gmsgPlayerIcon, nullptr, pPlayer->edict() );
					g_engfuncs.pfnWriteByte( pOther->entindex() );
					g_engfuncs.pfnWriteByte( item.IconColor.r );
					g_engfuncs.pfnWriteByte( item.IconColor.g );
					g_engfuncs.pfnWriteByte( item.IconColor.b );
					g_engfuncs.pfnMessageEnd();
				}
			}
		}
	}
}

CHalfLifeCTFplay::CHalfLifeCTFplay()
{
	memset( team_scores, 0, sizeof( team_scores ) );
	memset( team_count, 0, sizeof( team_count ) );

	for( int i = 1; i <= gpGlobals->maxClients; ++i )
	{
		auto pPlayer = UTIL_PlayerByIndex( i );

		if( pPlayer )
		{
			auto pszTeam = pPlayer->TeamID();

			auto teamIndex = GetTeamIndex( pszTeam );

			if( teamIndex >= 0 )
			{
				++team_count[ teamIndex ];
			}
		}
	}
}

void CHalfLifeCTFplay::Think()
{
	if( m_iStatsPhase != StatsPhase::Nothing && gpGlobals->time >= m_flNextStatsSend )
	{
		switch( m_iStatsPhase )
		{
		default:
			break;
		case StatsPhase::OpenMenu:
			MESSAGE_BEGIN( MSG_ALL, gmsgVGUIMenu );
			g_engfuncs.pfnWriteByte( 9 );
			MESSAGE_END();
			m_iStatsPhase = StatsPhase::Nothing;
			break;
		case StatsPhase::SendPlayers:
			for( int iStat = 0; iStat <= 5 && m_iStatsPlayer <= gpGlobals->maxClients; ++m_iStatsPlayer )
			{
				auto pPlayer = UTIL_PlayerByIndex( m_iStatsPlayer );

				if( pPlayer && pPlayer->IsPlayer() )
				{
					++iStat;
					SendPlayerStatInfo( static_cast<CBasePlayer*>( pPlayer ) );
				}
			}

			--m_iStatsPlayer;

			//TODO: checks against an index that may not have been sent
			if( gpGlobals->maxClients <= ( m_iStatsPlayer + 1 ) )
				m_iStatsPhase = StatsPhase::OpenMenu;
			break;
		case StatsPhase::SendTeam2:
			SendTeamStatInfo( CTFTeam::OpposingForce );
			m_iStatsPhase = StatsPhase::SendPlayers;
			break;
		case StatsPhase::SendTeam1:
			SendTeamStatInfo( CTFTeam::BlackMesa );
			m_iStatsPhase = StatsPhase::SendTeam2;
			break;
		case StatsPhase::SendTeam0:
			SendTeamStatInfo( CTFTeam::None );
			m_iStatsPhase = StatsPhase::SendTeam1;
			break;
		}

		m_flNextStatsSend = gpGlobals->time + 0.2;
	}

	if( m_fRefreshScores )
	{
		DisplayTeamFlags( nullptr );

		m_fRefreshScores = false;
	}

	if( g_fGameOver )
	{
		CHalfLifeMultiplay::Think();
		return;
	}

	const auto timeLimit = 60.0 * timelimit.value;
	if( timeLimit != 0.0 && gpGlobals->time >= timeLimit )
	{
		GoToIntermission();
		return;
	}

	const auto flFragLimit = fraglimit.value;

	if( flFragLimit != 0.0 )
	{
		for( int iPlayer = 1; iPlayer <= gpGlobals->maxClients; ++iPlayer )
		{
			auto pPlayer = UTIL_PlayerByIndex( iPlayer );

			if( pPlayer )
			{
				if( pPlayer->pev->frags >= flFragLimit )
				{
					GoToIntermission();
					return;
				}
			}
		}
	}

	if( CheckForLevelEnd( static_cast<int>( ctf_capture.value ) ) )
	{
		GoToIntermission();
	}
}

BOOL CHalfLifeCTFplay::ClientConnected( edict_t* pEntity, const char* pszName, const char* pszAddress, char* szRejectReason )
{
	m_fRefreshScores = true;

	int playersInTeamsCount = 0;

	for( int iPlayer = 1; iPlayer <= gpGlobals->maxClients; ++iPlayer )
	{
		auto pPlayer = static_cast<CBasePlayer*>( UTIL_PlayerByIndex( iPlayer ) );

		if( pPlayer )
		{
			if( pPlayer->IsPlayer() )
			{
				playersInTeamsCount += ( pPlayer->m_iTeamNum > CTFTeam::None ) ? 1 : 0;
			}
		}
	}

	if( playersInTeamsCount <= 1 )
	{
		for( int iPlayer = 1; iPlayer <= gpGlobals->maxClients; ++iPlayer )
		{
			auto pPlayer = static_cast< CBasePlayer* >( UTIL_PlayerByIndex( iPlayer ) );

			if( pPlayer && pPlayer->m_iItems != CTFItem::None )
			{
				auto pFlag = static_cast<CTFGoalFlag*>( pPlayer->m_pFlag.operator CBaseEntity *() );

				if( pFlag )
				{
					pFlag->ReturnFlag();
				}

				if( pPlayer->m_iItems & CTFItem::ItemsMask )
				{
					RespawnPlayerCTFPowerups( pPlayer, true );
				}

				ClientPrint( pPlayer->pev, HUD_PRINTCENTER, ""#CTFGameReset"" );
			}
		}

		ResetTeamScores();
	}

	return CHalfLifeMultiplay::ClientConnected( pEntity, pszName, pszAddress, szRejectReason );
}

void CHalfLifeCTFplay::InitHUD( CBasePlayer* pPlayer )
{
	CHalfLifeMultiplay::InitHUD( pPlayer );

	DisplayTeamFlags( pPlayer );

	auto v2 = 60.0f * timelimit.value;
	auto v25 = pPlayer->edict();
	if( v2 == 0 )
	{
		g_engfuncs.pfnMessageBegin( MSG_ONE, gmsgFlagTimer, 0, v25 );
		g_engfuncs.pfnWriteByte( 0 );
		g_engfuncs.pfnMessageEnd();
	}
	else
	{
		g_engfuncs.pfnMessageBegin( MSG_ONE, gmsgFlagTimer, 0, v25 );
		g_engfuncs.pfnWriteByte( 1 );
		g_engfuncs.pfnWriteShort( ( int ) ( v2 - gpGlobals->time ) );
		g_engfuncs.pfnMessageEnd();
	}

	RecountTeams();

	if( pPlayer->m_iTeamNum > CTFTeam::None && !pPlayer->pev->iuser1 )
	{
		char text[ 1024 ];
		sprintf( text, ""* you are on team '%s'\\n"", team_names[ ( int ) pPlayer->m_iTeamNum - 1 ] );
		UTIL_SayText( text, pPlayer );
		ChangePlayerTeam( pPlayer, pPlayer->m_szTeamName, false, false );
	}

	RecountTeams();

	for( int iPlayer = 1; iPlayer <= gpGlobals->maxClients; ++iPlayer )
	{
		auto pPlayer = static_cast<CBasePlayer*>( UTIL_PlayerByIndex( iPlayer ) );

		if( pPlayer )
		{
			if( IsValidTeam( pPlayer->TeamID() ) )
			{
				MESSAGE_BEGIN( MSG_ONE, gmsgTeamInfo, nullptr, pPlayer->edict() );
				g_engfuncs.pfnWriteByte( pPlayer->entindex() );
				g_engfuncs.pfnWriteString( pPlayer->TeamID() );
				g_engfuncs.pfnWriteByte( ( int ) pPlayer->m_iTeamNum );
				g_engfuncs.pfnMessageEnd();
			}
		}
	}
}

void CHalfLifeCTFplay::ClientDisconnected( edict_t* pClient )
{
	if( pClient )
	{
		auto v2 = ( CBasePlayer * ) GET_PRIVATE( pClient );
		if( v2 )
		{
			if( !g_fGameOver )
			{
				auto pFlag = static_cast<CTFGoalFlag*>( v2->m_pFlag.operator CBaseEntity *() );

				if( pFlag )
				{
					pFlag->DropFlag( v2 );
				}

				if( v2->m_iItems & CTFItem::ItemsMask )
					ScatterPlayerCTFPowerups( v2 );
			}
			v2->m_iTeamNum = CTFTeam::None;
			v2->m_iNewTeamNum = CTFTeam::None;
			FireTargets( ""game_playerleave"", v2, v2, USE_TOGGLE, 0.0 );

			UTIL_LogPrintf(
				""\\""%s<%i><%u><%s>\\"" disconnected\\n"",
				STRING( v2->pev->netname ),
				g_engfuncs.pfnGetPlayerUserId( v2->edict() ),
				g_engfuncs.pfnGetPlayerWONId( v2->edict() ),
				GetTeamName( v2->edict() ) );

			//TODO: doesn't seem to be used
			//free( v2->ip );
			//v2->ip = nullptr;

			free( pszPlayerIPs[ g_engfuncs.pfnIndexOfEdict( pClient ) ] );

			pszPlayerIPs[ g_engfuncs.pfnIndexOfEdict( pClient ) ] = nullptr;

			v2->RemoveAllItems( true );

			g_engfuncs.pfnMessageBegin( 2, gmsgSpectator, 0, 0 );
			g_engfuncs.pfnWriteByte( g_engfuncs.pfnIndexOfEdict( pClient ) );
			g_engfuncs.pfnWriteByte( 0 );
			g_engfuncs.pfnMessageEnd();

			for( CBasePlayer* pPlayer = nullptr; ( pPlayer = static_cast<CBasePlayer*>( UTIL_FindEntityByClassname( pPlayer, ""player"" ) ) ); )
			{
				if( FNullEnt( pPlayer->pev ) )
					break;

				if( pPlayer != v2 && pPlayer->m_hObserverTarget == v2 )
				{
					const auto oldMode = pPlayer->pev->iuser1;

					pPlayer->pev->iuser1 = 0;

					pPlayer->m_hObserverTarget = nullptr;

					pPlayer->Observer_SetMode( oldMode );
				}
			}
		}
	}
}

void CHalfLifeCTFplay::UpdateGameMode( CBasePlayer* pPlayer )
{
	g_engfuncs.pfnMessageBegin( MSG_ONE, gmsgGameMode, nullptr, pPlayer->edict() );
	g_engfuncs.pfnWriteByte( 2 );
	g_engfuncs.pfnMessageEnd();
}

BOOL CHalfLifeCTFplay::FPlayerCanTakeDamage( CBasePlayer* pPlayer, CBaseEntity* pAttacker )
{
	if( pAttacker
		&& PlayerRelationship( pPlayer, pAttacker ) == GR_TEAMMATE
		&& pAttacker != pPlayer
		&& friendlyfire.value == 0 )
		return FALSE;

	return CHalfLifeMultiplay::FPlayerCanTakeDamage( pPlayer, pAttacker );
}

BOOL CHalfLifeCTFplay::ShouldAutoAim( CBasePlayer* pPlayer, edict_t* target )
{
	auto v4 = CBaseEntity::Instance( target );

	if( v4 && v4->IsPlayer() )
	{
		return PlayerRelationship( pPlayer, v4 ) != GR_TEAMMATE;
	}

	return true;
}

void CHalfLifeCTFplay::PlayerSpawn( CBasePlayer* pPlayer )
{
	if( pPlayer->m_iTeamNum != CTFTeam::None )
	{
		if( !pPlayer->pev->iuser1 )
		{
			const int savedAutoWepSwitch = pPlayer->m_iAutoWepSwitch;
			pPlayer->m_iAutoWepSwitch = 1;
			pPlayer->pev->weapons |= 1 << WEAPON_SUIT;

			auto useDefault = true;

			for( auto pEquip : UTIL_FindEntitiesByClassname( ""game_player_equip"" ) )
			{
				useDefault = false;

				pEquip->Touch( pPlayer );
			}

			MESSAGE_BEGIN( MSG_ONE, gmsgOldWeapon, nullptr, pPlayer->edict() );

			g_engfuncs.pfnWriteByte( 1.0 == oldweapons.value );
			g_engfuncs.pfnMessageEnd();

			if( useDefault )
			{
				pPlayer->GiveNamedItem( ""weapon_pipewrench"" );
				pPlayer->GiveNamedItem( ""weapon_eagle"" );
				pPlayer->GiveNamedItem( ""weapon_grapple"" );
				pPlayer->GiveAmmo( DEAGLE_DEFAULT_GIVE * 3, ""357"", _357_MAX_CARRY );
			}

			for( auto pFlag : UTIL_FindEntitiesByClassname<CTFGoalFlag>( ""item_ctfflag"" ) )
			{
				if( pFlag->m_iGoalState == 2 )
				{
					pFlag->TurnOnLight( pPlayer );
				}
			}

			for( auto pBase : UTIL_FindEntitiesByClassname<CTFGoalBase>( ""item_ctfbase"" ) )
			{
				pBase->TurnOnLight( pPlayer );
			}

			int r = 128;
			int g = 128;
			int b = 128;

			switch (pPlayer->m_iTeamNum)
			{
			case CTFTeam::BlackMesa:
				UnpackRGB(r, g, b, RGB_YELLOWISH);
				break;
				
			case CTFTeam::OpposingForce:
				UnpackRGB(r, g, b, RGB_HUD_COLOR);
				break;
			}

			g_engfuncs.pfnMessageBegin( MSG_ONE, gmsgHudColor, nullptr, pPlayer->edict() );
			g_engfuncs.pfnWriteByte(r);
			g_engfuncs.pfnWriteByte(g);
			g_engfuncs.pfnWriteByte(b);
			g_engfuncs.pfnMessageEnd();

			InitItemsForPlayer( pPlayer );
			DisplayTeamFlags( pPlayer );

			pPlayer->m_iAutoWepSwitch = savedAutoWepSwitch;
		}
	}
}

void CHalfLifeCTFplay::PlayerThink( CBasePlayer* pPlayer )
{
	const auto vecSrc = pPlayer->GetGunPosition();

	UTIL_MakeVectors( pPlayer->pev->v_angle );

	TraceResult tr;

	if( pPlayer->m_iFOV )
	{
		UTIL_TraceLine( vecSrc, vecSrc + 4096 * gpGlobals->v_forward, dont_ignore_monsters, pPlayer->edict(), &tr );
	}
	else
	{
		UTIL_TraceLine( vecSrc, vecSrc + 1280.0 * gpGlobals->v_forward, dont_ignore_monsters, pPlayer->edict(), &tr );
	}

	if( gmsgPlayerBrowse && tr.flFraction < 1.0 && pPlayer->m_iLastPlayerTrace != g_engfuncs.pfnIndexOfEdict( tr.pHit ) )
	{
		auto pOther = CBaseEntity::Instance( tr.pHit );

		if( !pOther->IsPlayer() )
		{
			g_engfuncs.pfnMessageBegin( MSG_ONE, gmsgPlayerBrowse, nullptr, pPlayer->edict() );
			g_engfuncs.pfnWriteByte( 0 );
			g_engfuncs.pfnWriteByte( 0 );
			g_engfuncs.pfnWriteString( """" );
			g_engfuncs.pfnMessageEnd();
		}
		else
		{
			auto pOtherPlayer = static_cast<CBasePlayer*>(pOther);

			g_engfuncs.pfnMessageBegin( MSG_ONE, gmsgPlayerBrowse, nullptr, pPlayer->edict() );
			g_engfuncs.pfnWriteByte( pOtherPlayer->m_iTeamNum == pPlayer->m_iTeamNum );

			const auto v11 = !pPlayer->pev->iuser1 ? pOtherPlayer->m_iTeamNum : CTFTeam::None;

			g_engfuncs.pfnWriteByte( ( int ) v11 );
			g_engfuncs.pfnWriteString( STRING( pOtherPlayer->pev->netname ) );
			g_engfuncs.pfnWriteByte( ( byte ) pOtherPlayer->m_iItems );
			g_engfuncs.pfnWriteByte( ( byte ) pOtherPlayer->pev->health );
			g_engfuncs.pfnWriteByte( ( byte ) pOtherPlayer->pev->armorvalue );
			g_engfuncs.pfnMessageEnd();
		}

		pPlayer->m_iLastPlayerTrace = g_engfuncs.pfnIndexOfEdict( tr.pHit );
	}
	CHalfLifeMultiplay::PlayerThink( pPlayer );
}

BOOL CHalfLifeCTFplay::ClientCommand( CBasePlayer* pPlayer, const char* pcmd )
{
	if( !strcmp( ""cancelmenu"", pcmd ) )
	{
		if(pPlayer->m_iCurrentMenu == MENU_CLASS)
		{
			pPlayer->m_iCurrentMenu = MENU_TEAM;
			g_engfuncs.pfnMessageBegin( MSG_ONE, gmsgTeamFull, nullptr, pPlayer->edict() );
			g_engfuncs.pfnWriteByte( 0 );
			g_engfuncs.pfnMessageEnd();
			pPlayer->m_iNewTeamNum = CTFTeam::None;
			pPlayer->Player_Menu();
		}
		else if( pPlayer->m_iCurrentMenu == MENU_TEAM)
		{
			if( pPlayer->m_iNewTeamNum != CTFTeam::None || pPlayer->m_iTeamNum != CTFTeam::None )
			{
				pPlayer->m_iCurrentMenu = MENU_NONE;
			}
			else
			{
				pPlayer->Menu_Team_Input( -1 );
			}
		}

		return true;
	}
	else if( !strcmp( ""endmotd"", pcmd ) )
	{
		pPlayer->m_iCurrentMenu = MENU_TEAM;
		pPlayer->Player_Menu();
		return true;
	}
	else if( !strcmp( ""jointeam"", pcmd ) )
	{
		pPlayer->Menu_Team_Input( atoi( CMD_ARGV( 1 ) ) );
		return true;
	}
	else if( !strcmp( ""spectate"", pcmd ) )
	{
		pPlayer->Menu_Team_Input( -1 );
		return true;
	}
	else if( !strcmp( ""selectchar"", pcmd ) )
	{
		if( g_engfuncs.pfnCmd_Argc() > 1 )
		{
			pPlayer->Menu_Char_Input( atoi( CMD_ARGV( 1 ) ) );
		}

		return true;
	}

	return false;
}

void CHalfLifeCTFplay::ClientUserInfoChanged( CBasePlayer* pPlayer, char* infobuffer )
{
	pPlayer->SetPrefsFromUserinfo(infobuffer);

	if( pPlayer->m_szTeamModel )
	{
		auto pszNewModel = g_engfuncs.pfnInfoKeyValue( infobuffer, ""model"" );
		if( *pszNewModel != '=' )
		{
			if( strcmp( pszNewModel, pPlayer->m_szTeamModel ) )
			{
				if( std::any_of( team_chars.begin(), team_chars.end(), [ = ]( auto pszChar )
					{
						return !strcmp( pPlayer->m_szTeamModel, pszChar );
					}))
				{
					auto pszPlayerName = STRING( pPlayer->pev->netname );
					if( pszPlayerName && *pszPlayerName )
					{
						UTIL_LogPrintf( ""\\""%s<%i><%u><%s>\\"" changed role to \\""%s\\""\\n"",
							pszPlayerName,
							g_engfuncs.pfnGetPlayerUserId( pPlayer->edict() ),
							g_engfuncs.pfnGetPlayerWONId( pPlayer->edict() ),
							GetTeamName( pPlayer->edict() ),
							pPlayer->m_szTeamModel );
					}

					g_engfuncs.pfnSetClientKeyValue( pPlayer->entindex(), g_engfuncs.pfnGetInfoKeyBuffer( pPlayer->edict() ), ""model"", pPlayer->m_szTeamModel );
					UTIL_SayText( ""* Not allowed to change player model through the console in CTF!\\n"", pPlayer );
				}
			}
		}
	}
}

int CHalfLifeCTFplay::IPointsForKill( CBasePlayer* pAttacker, CBasePlayer* pKilled )
{
	if( pKilled )
	{
		if( pAttacker )
		{
			if( pAttacker != pKilled )
				return 2 * ( PlayerRelationship( pAttacker, pKilled ) != GR_TEAMMATE ) - 1;
		}

		return 1;
	}

	return 0;
}

void CHalfLifeCTFplay::PlayerKilled( CBasePlayer* pVictim, entvars_t* pKiller, entvars_t* pInflictor )
{
	if( !pVictim || pVictim->pev->iuser1 )
		return;

	if( !m_DisableDeathPenalty && !g_fGameOver )
	{
		auto v5 = pKiller ? CBaseEntity::Instance<CBasePlayer>( pKiller ) : nullptr;

		if( pVictim->m_pFlag )
		{
			if( v5
				&& v5->IsPlayer()
				&& pVictim->m_iTeamNum != v5->m_iTeamNum )
			{
				++v5->m_iCTFScore;
				++v5->m_iDefense;

				MESSAGE_BEGIN( MSG_ALL, gmsgCTFScore );
				g_engfuncs.pfnWriteByte( v5->entindex() );
				g_engfuncs.pfnWriteByte( v5->m_iCTFScore );
				g_engfuncs.pfnMessageEnd();

				++v5->m_iCTFScore;

				ClientPrint( v5->pev, HUD_PRINTTALK, ""#CTFScorePoint"" );

				UTIL_ClientPrintAll( HUD_PRINTNOTIFY, UTIL_VarArgs( ""%s"", STRING( v5->pev->netname ) ) );

				if( pVictim->m_iTeamNum == CTFTeam::BlackMesa )
				{
					UTIL_ClientPrintAll( HUD_PRINTNOTIFY, ""#CTFFlagKilledBM"" );
				}
				else if( pVictim->m_iTeamNum == CTFTeam::OpposingForce )
				{
					UTIL_ClientPrintAll( HUD_PRINTNOTIFY, ""#CTFFlagKilledOF"" );
				}

				char szTeamName1[ 256 ];
				char szTeamName2[ 256 ];

				strncpy( szTeamName1, GetTeamName( pKiller->pContainingEntity ), sizeof( szTeamName1 ) );
				strncpy( szTeamName2, GetTeamName( pVictim->edict() ), sizeof( szTeamName2 ) );

				szTeamName1[ sizeof( szTeamName1 ) - 1 ] = 0;
				szTeamName2[ sizeof( szTeamName2 ) - 1 ] = 0;

				UTIL_LogPrintf(
					""\\""%s<%i><%u><%s>\\"" triggered \\""FlagDefense\\"" against \\""%s<%i><%u><%s>\\""\\n"",
					STRING( pKiller->netname ),
					g_engfuncs.pfnGetPlayerUserId( pKiller->pContainingEntity ),
					g_engfuncs.pfnGetPlayerWONId( pKiller->pContainingEntity ),
					szTeamName1,
					STRING( pVictim->pev->netname ),
					g_engfuncs.pfnGetPlayerUserId( pVictim->edict() ),
					g_engfuncs.pfnGetPlayerWONId( pVictim->edict() ),
					szTeamName2 );
			}

			UTIL_LogPrintf(
				""\\""%s<%i><%u><%s>\\"" triggered \\""LostFlag\\""\\n"",
				STRING( pVictim->pev->netname ),
				g_engfuncs.pfnGetPlayerUserId( pVictim->edict() ),
				g_engfuncs.pfnGetPlayerWONId( pVictim->edict() ),
				GetTeamName( pVictim->edict() ) );
		}

		if( v5 && v5->IsPlayer() )
		{
			const char* pszInflictorName = nullptr;

			if( pKiller == pInflictor )
			{
				if( v5->m_pActiveItem )
					pszInflictorName = CBasePlayerItem::ItemInfoArray[ v5->m_pActiveItem->m_iId ].pszName;
			}
			else if( pInflictor && pInflictor->classname )
			{
				pszInflictorName = STRING( pInflictor->classname );
			}

			if( pszInflictorName )
			{
				if( !strcmp( ""weapon_sniperrifle"", pszInflictorName )
					|| !strcmp( ""weapon_crossbow"", pszInflictorName ) )
				{
					++v5->m_iSnipeKills;
				}
				else if( !strcmp( ""weapon_grapple"", pszInflictorName ) )
				{
					++v5->m_iBarnacleKills;
				}
			}

			if( pKiller == pVictim->pev )
				++v5->m_iSuicides;

			for( auto pBase : UTIL_FindEntitiesByClassname<CTFGoalBase>( ""item_ctfbase"" ) )
			{
				if( pKiller != pVictim->pev && pBase->m_iGoalNum == ( int ) v5->m_iTeamNum )
				{
					if( g_flBaseDefendDist >= ( pVictim->pev->origin - pBase->pev->origin ).Length() )
					{
						++v5->m_iCTFScore;
						++v5->m_iDefense;

						MESSAGE_BEGIN( MSG_ALL, gmsgCTFScore );
						g_engfuncs.pfnWriteByte( v5->entindex() );
						g_engfuncs.pfnWriteByte( v5->m_iCTFScore );
						g_engfuncs.pfnMessageEnd();

						ClientPrint( v5->pev, HUD_PRINTTALK, ""#CTFScorePoint"" );

						UTIL_ClientPrintAll( HUD_PRINTNOTIFY, UTIL_VarArgs( ""%s"", STRING( v5->pev->netname ) ) );

						if( v5->m_iTeamNum == CTFTeam::BlackMesa )
						{
							UTIL_ClientPrintAll( HUD_PRINTNOTIFY, ""#CTFFlagDefendedBM"" );
						}
						else if( v5->m_iTeamNum == CTFTeam::OpposingForce )
						{
							UTIL_ClientPrintAll( HUD_PRINTNOTIFY, ""#CTFFlagDefendedOF"" );
						}
						break;
					}
				}
			}

			if( pKiller != pVictim->pev && gpGlobals->maxClients > 0 )
			{
				for( auto pPlayer : UTIL_FindPlayers() )
				{
					auto pFlag = pPlayer->m_pFlag.Entity<CTFGoalFlag>();

					if( pFlag )
					{
						if( pPlayer->m_nLastShotBy == pVictim->entindex() && g_flDefendCarrierTime > gpGlobals->time - pPlayer->m_flLastShotTime )
						{
							++pPlayer->m_iCTFScore;
							++pPlayer->m_iDefense;

							MESSAGE_BEGIN( MSG_ALL, gmsgCTFScore );
							g_engfuncs.pfnWriteByte( pPlayer->entindex() );
							g_engfuncs.pfnWriteByte( pPlayer->m_iCTFScore );
							g_engfuncs.pfnMessageEnd();

							ClientPrint( pPlayer->pev, HUD_PRINTTALK, ""#CTFScorePoint"" );
							UTIL_ClientPrintAll( HUD_PRINTNOTIFY, UTIL_VarArgs( ""%s"", STRING( pPlayer->pev->netname ) ) );

							if( pVictim->m_iTeamNum == CTFTeam::BlackMesa )
							{
								UTIL_ClientPrintAll( 1, ""#CTFCarrierDefendedOF"" );
							}
							else if( pVictim->m_iTeamNum == CTFTeam::OpposingForce )
							{
								UTIL_ClientPrintAll( 1, ""#CTFCarrierDefendedBM"" );
							}
						}
					}
				}
			}
		}
	}

	CHalfLifeMultiplay::PlayerKilled( pVictim, pKiller, pInflictor );

	if( pVictim->IsPlayer() && !g_fGameOver )
	{
		auto pFlag = pVictim->m_pFlag.Entity<CTFGoalFlag>();

		if( pFlag )
		{
			pFlag->DropFlag( pVictim );
		}

		if( pVictim->m_iItems & CTFItem::ItemsMask )
			ScatterPlayerCTFPowerups( pVictim );
	}
}

void CHalfLifeCTFplay::DeathNotice( CBasePlayer* pVictim, entvars_t* pKiller, entvars_t* pevInflictor )
{
	if( !m_DisableDeathMessages )
	{
		if( pKiller
			&& pVictim
			&& pKiller->flags & FL_CLIENT )
		{
			auto pEntKiller = CBaseEntity::Instance<CBasePlayer>( pKiller );

			if( pEntKiller
				&& pVictim != pEntKiller
				&& ( PlayerRelationship( pVictim, pEntKiller ) == GR_TEAMMATE ) )
			{
				MESSAGE_BEGIN( MSG_ALL, gmsgDeathMsg );
				g_engfuncs.pfnWriteByte( pEntKiller->entindex() );
				g_engfuncs.pfnWriteByte( pVictim->entindex() );
				g_engfuncs.pfnWriteString( ""teammate"" );
				g_engfuncs.pfnMessageEnd();
				return;
			}
		}

		CHalfLifeMultiplay::DeathNotice( pVictim, pKiller, pevInflictor );
	}
}

BOOL CHalfLifeCTFplay::CanHaveAmmo( CBasePlayer* pPlayer, const char* pszAmmoName, int iMaxCarry )
{
	if( pszAmmoName )
	{
		const auto ammoIndex = CBasePlayer::GetAmmoIndex( pszAmmoName );

		if( ammoIndex >= 0 )
			return pPlayer->AmmoInventory( ammoIndex ) < iMaxCarry;
	}

	return false;
}

const char* CHalfLifeCTFplay::GetTeamID( CBaseEntity* pEntity )
{
	if( pEntity && pEntity->pev )
		return pEntity->TeamID();
	
	return """";
}

int CHalfLifeCTFplay::PlayerRelationship( CBaseEntity* pPlayer, CBaseEntity* pTarget )
{
	if( pTarget && pPlayer )
	{
		if( pTarget->IsPlayer() )
			return static_cast<CBasePlayer*>( pPlayer )->m_iTeamNum == static_cast<CBasePlayer*>( pTarget )->m_iTeamNum;
	}

	return GR_NOTTEAMMATE;
}

int CHalfLifeCTFplay::GetTeamIndex( const char* pTeamName )
{
	if( pTeamName && *pTeamName )
	{
		for( int i = 0; i < MaxTeams; ++i )
		{
			if( !stricmp( team_names[ i ], pTeamName ) )
			{
				return i;
			}
		}
	}

	return -1;
}

const char* CHalfLifeCTFplay::GetIndexedTeamName( int teamIndex )
{
	if( teamIndex >= 0 && teamIndex < MaxTeams )
		return team_names[ teamIndex ];

	return """";
}

BOOL CHalfLifeCTFplay::IsValidTeam( const char* pTeamName )
{
	return GetTeamIndex( pTeamName ) != -1;
}

void CHalfLifeCTFplay::ChangePlayerTeam( CBasePlayer* pPlayer, const char* pCharName, BOOL bKill, BOOL bGib )
{
	auto v5 = pPlayer->entindex();

	if( pCharName )
	{
		auto team = CTFTeam::None;

		if( std::any_of( team_chars.begin(), team_chars.begin() + team_chars.size() / 2, [ = ]( auto pszChar )
			{
				return !strcmp( pCharName, pszChar );
			} ) )
		{
			team = CTFTeam::BlackMesa;
		}
		else if( std::any_of( team_chars.begin() + team_chars.size() / 2, team_chars.end(), [ = ]( auto pszChar )
			{
				return !strcmp( pCharName, pszChar );
			} ) )
		{
			team = CTFTeam::OpposingForce;
		}

		if( pPlayer->m_iTeamNum != team )
		{
			if( bKill )
			{
				m_DisableDeathMessages = true;
				m_DisableDeathPenalty = true;

				if( !g_fGameOver )
				{
					if( pPlayer->m_pFlag )
					{
						pPlayer->m_pFlag.Entity<CTFGoalFlag>()->DropFlag( pPlayer );
					}

					if( pPlayer->m_iItems & CTFItem::ItemsMask )
					{
						ScatterPlayerCTFPowerups( pPlayer );
					}
				}

				const auto v7 = bGib ? DMG_ALWAYSGIB : DMG_NEVERGIB;

				auto pKiller = INDEXENT( 0 );

				auto pEntKiller = pKiller ? &pKiller->v : nullptr;

				pPlayer->TakeDamage( pEntKiller, pEntKiller, 900, v7 );

				m_DisableDeathMessages = false;
				m_DisableDeathPenalty = false;
			}
			pPlayer->m_iTeamNum = team;
		}

		pPlayer->m_afPhysicsFlags &= ~PFLAG_OBSERVER;
		strncpy( pPlayer->m_szTeamName, team_names[ ( int ) team - 1 ], sizeof( pPlayer->m_szTeamName ) );

		pPlayer->m_szTeamModel = ( char * ) pCharName;

		g_engfuncs.pfnSetClientKeyValue( v5, g_engfuncs.pfnGetInfoKeyBuffer( pPlayer->edict() ), ""model"", ( char * ) pCharName );
		g_engfuncs.pfnSetClientKeyValue( v5, g_engfuncs.pfnGetInfoKeyBuffer( pPlayer->edict() ), ""team"", pPlayer->m_szTeamName );

		MESSAGE_BEGIN( MSG_ALL, gmsgTeamInfo );
		g_engfuncs.pfnWriteByte( v5 );
		g_engfuncs.pfnWriteString( pPlayer->m_szTeamName );
		g_engfuncs.pfnWriteByte( ( int ) pPlayer->m_iTeamNum );
		g_engfuncs.pfnMessageEnd();

		const auto pszTeamName = GetTeamName( pPlayer->edict() );

		UTIL_LogPrintf(
			""\\""%s<%i><%u><%s>\\"" joined team \\""%s\\""\\n"",
			STRING( pPlayer->pev->netname ),
			g_engfuncs.pfnGetPlayerUserId( pPlayer->edict() ),
			g_engfuncs.pfnGetPlayerWONId( pPlayer->edict() ),
			pszTeamName,
			pszTeamName );

		const auto v19 = STRING( pPlayer->pev->netname );

		if( v19 && *v19 )
		{
			UTIL_LogPrintf( ""\\""%s<%i><%u><%s>\\"" changed role to \\""%s\\""\\n"",
				v19,
				g_engfuncs.pfnGetPlayerUserId( pPlayer->edict() ),
				g_engfuncs.pfnGetPlayerWONId( pPlayer->edict() ),
				pszTeamName,
				pCharName );
		}
	}
	else
	{
		if( pPlayer->pev->health <= 0.0 )
		{
			respawn( pPlayer->pev, 0 );
		}

		pPlayer->pev->effects |= EF_NODRAW;
		pPlayer->pev->flags |= FL_SPECTATOR;
		pPlayer->pev->solid = SOLID_NOT;
		pPlayer->pev->movetype = MOVETYPE_NOCLIP;
		pPlayer->pev->takedamage = DAMAGE_NO;
		pPlayer->m_iHideHUD |= HIDEHUD_HEALTH | HIDEHUD_WEAPONS;
		pPlayer->m_afPhysicsFlags |= PFLAG_OBSERVER;
		pPlayer->m_iNewTeamNum = CTFTeam::None;
		pPlayer->m_iCurrentMenu = MENU_NONE;
		pPlayer->m_iTeamNum = CTFTeam::None;
		pPlayer->SetSuitUpdate( nullptr, FALSE, SUIT_REPEAT_OK );
		pPlayer->m_iClientHealth = 100;

		g_engfuncs.pfnMessageBegin( MSG_ONE, gmsgHealth, nullptr, pPlayer->edict() );
		g_engfuncs.pfnWriteByte( pPlayer->m_iClientHealth );
		g_engfuncs.pfnMessageEnd();

		g_engfuncs.pfnMessageBegin( MSG_ONE, gmsgCurWeapon, nullptr, pPlayer->edict() );
		g_engfuncs.pfnWriteByte( 0 );
		g_engfuncs.pfnWriteByte( 255 );
		g_engfuncs.pfnWriteByte( 255 );
		g_engfuncs.pfnMessageEnd();

		pPlayer->m_iClientFOV = 0;
		pPlayer->m_iFOV = 0;

		g_engfuncs.pfnMessageBegin( MSG_ONE, gmsgSetFOV, nullptr, pPlayer->edict() );
		g_engfuncs.pfnWriteByte( 0 );
		g_engfuncs.pfnMessageEnd();

		if( pPlayer->m_pTank )
		{
			auto v42 = pPlayer->m_pTank.operator CBaseEntity *();

			v42->Use( pPlayer, pPlayer, USE_OFF, 0 );

			pPlayer->m_pTank = nullptr;
		}

		pPlayer->m_afPhysicsFlags &= ~PFLAG_DUCKING;
		pPlayer->pev->flags &= ~FL_DUCKING;
		pPlayer->Observer_SetMode( OBS_CHASE_FREE );
		pPlayer->pev->deadflag = DEAD_RESPAWNABLE;

		if( pPlayer->HasNamedPlayerItem( ""weapon_satchel"" ) )
			DeactivateSatchels( pPlayer );

		pPlayer->RemoveAllItems( false );

		if( !g_fGameOver )
		{
			if( pPlayer->m_pFlag )
			{
				pPlayer->m_pFlag.Entity<CTFGoalFlag>()->DropFlag( pPlayer );
			}

			if( pPlayer->m_iItems & CTFItem::ItemsMask )
			{
				ScatterPlayerCTFPowerups( pPlayer );
			}
		}

		pPlayer->m_iDeaths = 0;
		pPlayer->m_iFlagCaptures = 0;
		pPlayer->pev->frags = 0;

		MESSAGE_BEGIN( MSG_ALL, gmsgScoreInfo );
		g_engfuncs.pfnWriteByte( pPlayer->entindex() );
		g_engfuncs.pfnWriteShort( ( int ) pPlayer->pev->frags );
		g_engfuncs.pfnWriteShort( pPlayer->m_iDeaths );
		g_engfuncs.pfnMessageEnd();

		pPlayer->m_szTeamName[ 0 ] = 0;

		g_engfuncs.pfnSetClientKeyValue( v5, g_engfuncs.pfnGetInfoKeyBuffer( pPlayer->edict() ), ""team"", pPlayer->m_szTeamName );

		MESSAGE_BEGIN( MSG_ALL, gmsgTeamInfo );
		g_engfuncs.pfnWriteByte( v5 );
		g_engfuncs.pfnWriteString( pPlayer->m_szTeamName );
		g_engfuncs.pfnWriteByte( ( int ) pPlayer->m_iTeamNum );
		g_engfuncs.pfnMessageEnd();

		MESSAGE_BEGIN( MSG_ALL, gmsgSpectator );
		g_engfuncs.pfnWriteByte( pPlayer->entindex() );
		g_engfuncs.pfnWriteByte( 1 );
		g_engfuncs.pfnMessageEnd();

		UTIL_LogPrintf(
			""\\""%s<%i><%u><spectator>\\"" joined team \\""spectator\\""\\n"",
			STRING( pPlayer->pev->netname ),
			g_engfuncs.pfnGetPlayerUserId( pPlayer->edict() ),
			g_engfuncs.pfnGetPlayerWONId( pPlayer->edict() ) );
	}
}

const char* CHalfLifeCTFplay::SetDefaultPlayerTeam( CBasePlayer* pPlayer )
{
	auto pszTeamName = TeamWithFewestPlayers();
	auto teamIndex = GetTeamIndex( pszTeamName );

	const auto character = g_engfuncs.pfnRandomLong( 0, team_chars.size() / 2 );

	auto pszCharacter = team_chars[ ( character + team_chars.size() / 2 * teamIndex ) ];

	const auto killPlayer = pPlayer->pev->iuser1 == 0;

	ChangePlayerTeam( pPlayer, pszCharacter, killPlayer, killPlayer );

	return pszTeamName;
}

const char* CHalfLifeCTFplay::GetCharacterType( int iTeamNum, int iCharNum )
{
	if( iCharNum < ( int ) ( team_chars.size() / 2 ) )
		return team_chars[ iCharNum + ( team_chars.size() / 2 * iTeamNum ) ];

	return """";
}

int CHalfLifeCTFplay::GetNumTeams()
{
	return MaxTeams;
}

const char* CHalfLifeCTFplay::TeamWithFewestPlayers()
{
	int teamCount[ MaxTeams ] = {};

	for( auto pPlayer : UTIL_FindPlayers() )
	{
		if( pPlayer->m_iTeamNum != CTFTeam::None )
		{
			++teamCount[ ( ( int ) pPlayer->m_iTeamNum ) - 1 ];
		}
	}

	if( teamCount[ 0 ] > 99 )
	{
		teamCount[ 0 ] = 100;
	}

	if( teamCount[ 1 ] < teamCount[ 0 ] )
	{
		return team_names[ 1 ];
	}

	return team_names[ 0 ];
}

BOOL CHalfLifeCTFplay::TeamsBalanced()
{
	int teamCount[ MaxTeams ] = {};

	for( auto pPlayer : UTIL_FindPlayers() )
	{
		if( pPlayer->m_iTeamNum != CTFTeam::None )
		{
			++teamCount[ ( ( int ) pPlayer->m_iTeamNum ) - 1 ];
		}
	}

	return teamCount[ 0 ] == teamCount[ 1 ];
}

void CHalfLifeCTFplay::GoToIntermission()
{
	m_iStatsPhase = StatsPhase::SendTeam0;
	m_iStatsPlayer = 1;
	m_flNextStatsSend = gpGlobals->time + 0.2;

	CHalfLifeMultiplay::GoToIntermission();
}

template<typename... ARGS>
static void InternalSendTeamStat( int playerIndex, char* pszPlayerFormat, char* pszNobodyFormat, const char* pszStatName, const int value, ARGS&&... args )
{
	auto pPlayer = UTIL_PlayerByIndex( playerIndex );

	if( pPlayer && !FStringNull( pPlayer->pev->netname ) && STRING( pPlayer->pev->netname ) )
	{
		char szBuf[ 21 ];

		strncpy( szBuf, STRING( pPlayer->pev->netname ), sizeof( szBuf ) - 1 );
		szBuf[ sizeof( szBuf ) - 1 ] = 0;

		g_engfuncs.pfnWriteString( szBuf );

		auto pEdict = pPlayer->edict();

		UTIL_LogPrintf(
			pszPlayerFormat,
			pszStatName,
			STRING( pPlayer->pev->netname ),
			g_engfuncs.pfnGetPlayerUserId( pEdict ),
			g_engfuncs.pfnGetPlayerWONId( pEdict ),
			GetTeamName( pEdict ),
			args... );
	}
	else
	{
		g_engfuncs.pfnWriteString( ""*Nobody*"" );
		UTIL_LogPrintf( pszNobodyFormat, pszStatName, args... );
	}

	g_engfuncs.pfnWriteShort( value );
}

/**
*	@brief Send a team statistic
*	Was probably a variadic macro in the original
*/
static void SendTeamStat( int playerIndex, const char* pszStatName, const int value )
{
	InternalSendTeamStat( playerIndex, ""// %-20s : \\""%s<%i><%u><%s>\\"" for %d\\n"", ""// %-20s : *Nobody* for %d\\n"", pszStatName, value, value );
}

/**
*	@brief Send a team time statistic
*	Was probably a variadic macro in the original
*/
static void SendTeamTimeStat( int playerIndex, const char* pszStatName, const float value )
{
	const auto time = SecondsToTime( value );

	InternalSendTeamStat( playerIndex, ""// %-40s : \\""%s<%i><%u><%s>\\"" for %d:%02d\\n"", ""// %-40s : *Nobody* for %d:%02d\\n"", pszStatName, static_cast<short>( value ), time.Minutes, time.Seconds );
}

void CHalfLifeCTFplay::SendTeamStatInfo( CTFTeam iTeamNum )
{
	auto iDamageVal = 0;
	auto iSuicidesVal = 0;
	auto iDeathsVal = 0;
	auto iBarnacleVal = 0;
	auto iSnipeVal = 0;
	auto iMostJump = 0;
	auto iMostDamage = 0;
	auto iMostBarnacle = 0;
	auto iMostSuicides = 0;
	auto iMostDeaths = 0;
	auto iMostSnipe = 0;
	auto iMostDef = 0;
	auto iFrags = 0;
	auto flJumpVal = 0.0f;
	auto iPts = 0;
	auto flShieldVal = 0.0f;
	auto iMostCTFPts = 0;
	auto flHealthVal = 0.0f;
	auto iMostFrags = 0;
	auto flBackpackVal = 0.0f;
	auto iMostShield = 0;
	auto iMostHealth = 0;
	auto iMostBackpack = 0;
	auto iMostAccel = 0;
	auto iMostPts = 0;
	auto flAccelVal = 0.0f;
	auto iMostOff = 0;
	auto iDefPts = 0;
	auto iOffPts = 0;
	auto iCTFPts = 0;
	auto iNumPlayers = 0;

	for( int iPlayer = 1; iPlayer <= gpGlobals->maxClients; ++iPlayer )
	{
		auto pPlayer = ( CBasePlayer * ) UTIL_PlayerByIndex( iPlayer );
		if( pPlayer
			&& pPlayer->IsPlayer()
			&& ( iTeamNum == CTFTeam::None || pPlayer->m_iTeamNum == iTeamNum ) )
		{
			if( FStringNull( pPlayer->pev->netname ) || !STRING( pPlayer->pev->netname ) )
				continue;

			auto totalScore = pPlayer->m_iCTFScore + pPlayer->pev->frags;

			if( totalScore > iPts )
			{
				iMostPts = iPlayer;
				iPts = totalScore;
			}
			if( pPlayer->pev->frags > iFrags )
			{
				iMostFrags = iPlayer;
				iFrags = pPlayer->pev->frags;
			}
			if( pPlayer->m_iCTFScore > iCTFPts )
			{
				iCTFPts = pPlayer->m_iCTFScore;
				iMostCTFPts = iPlayer;
			}

			if( pPlayer->m_iOffense > iOffPts )
			{
				iMostOff = iPlayer;
				iOffPts = pPlayer->m_iOffense;
			}

			if( pPlayer->m_iDefense > iDefPts )
			{
				iMostDef = iPlayer;
				iDefPts = pPlayer->m_iDefense;
			}

			if( pPlayer->m_iSnipeKills > iSnipeVal )
			{
				iMostSnipe = iPlayer;
				iSnipeVal = pPlayer->m_iSnipeKills;
			}

			if( pPlayer->m_iBarnacleKills > iBarnacleVal )
			{
				iMostBarnacle = iPlayer;
				iBarnacleVal = pPlayer->m_iBarnacleKills;
			}
			if( pPlayer->m_iDeaths > iDeathsVal )
			{
				iMostDeaths = iPlayer;
				iDeathsVal = pPlayer->m_iDeaths;
			}

			if( pPlayer->m_iSuicides > iSuicidesVal )
			{
				iMostSuicides = iPlayer;
				iSuicidesVal = pPlayer->m_iSuicides;
			}

			if( pPlayer->m_iMostDamage > iDamageVal )
			{
				iMostDamage = iPlayer;
				iDamageVal = pPlayer->m_iMostDamage;
			}
			if( pPlayer->m_flAccelTime > flAccelVal )
			{
				flAccelVal = pPlayer->m_flAccelTime;
				iMostAccel = iPlayer;
			}
			if( pPlayer->m_flBackpackTime > flBackpackVal )
			{
				flBackpackVal = pPlayer->m_flBackpackTime;
				iMostBackpack = iPlayer;
			}
			if( pPlayer->m_flHealthTime > flHealthVal )
			{
				flHealthVal = pPlayer->m_flHealthTime;
				iMostHealth = iPlayer;
			}
			if( pPlayer->m_flShieldTime > flShieldVal )
			{
				flShieldVal = pPlayer->m_flShieldTime;
				iMostShield = iPlayer;
			}
			if( pPlayer->m_flJumpTime > flJumpVal )
			{
				flJumpVal = pPlayer->m_flJumpTime;
				iMostJump = iPlayer;
			}

			++iNumPlayers;

			if( iTeamNum != CTFTeam::None )
				continue;

			const auto accelTime = SecondsToTime( static_cast<int>( pPlayer->m_flAccelTime ) );
			const auto backpackTime = SecondsToTime( static_cast<int>( pPlayer->m_flBackpackTime ) );
			const auto healthTime = SecondsToTime( static_cast<int>( pPlayer->m_flHealthTime ) );
			const auto shieldTime = SecondsToTime( static_cast<int>( pPlayer->m_flShieldTime ) );
			const auto jumpTime = SecondsToTime( static_cast<int>( pPlayer->m_flJumpTime ) );

			UTIL_LogPrintf(
				""\\""%s<%i><%u><%s>\\"" scored \\""%d\\"" (kills \\""%d\\"") (deaths \\""%d\\"") (suicides \\""%d\\"") (ctf_points \\""%d\\"") (ctf_offense \\""%d\\"") (ctf_defense \\""%d\\"") (snipe_kills \\""%d\\"") (barnacle_kills \\""%d\\"") (best_damage \\""%d\\"") (accel_time \\""%0d:%02d\\"") (ammo_time \\""%0d:%02d\\"") (health_time \\""%0d:%02d\\"") (shield_time \\""%0d:%02d\\"") (jump_time \\""%0d:%02d\\"")\\n"",
				STRING( pPlayer->pev->netname ),
				g_engfuncs.pfnGetPlayerUserId( pPlayer->edict() ),
				g_engfuncs.pfnGetPlayerWONId( pPlayer->edict() ),
				GetTeamName( pPlayer->edict() ),
				( int ) totalScore,
				( int ) pPlayer->pev->frags,
				pPlayer->m_iDeaths,
				pPlayer->m_iSuicides,
				pPlayer->m_iCTFScore,
				pPlayer->m_iOffense,
				pPlayer->m_iDefense,
				pPlayer->m_iSnipeKills,
				pPlayer->m_iBarnacleKills,
				pPlayer->m_iMostDamage,
				accelTime.Minutes,
				accelTime.Seconds,
				backpackTime.Minutes,
				backpackTime.Seconds,
				healthTime.Minutes,
				healthTime.Seconds,
				shieldTime.Minutes,
				shieldTime.Seconds,
				jumpTime.Minutes,
				jumpTime.Seconds );
		}
	}

	if( ( ToTeamIndex( iTeamNum ) ) < MaxTeams )
	{
		UTIL_LogPrintf( ""// === Team %s Statistics ===\\n"", team_names[ ToTeamIndex( iTeamNum ) ] );
	}
	else
	{
		//TODO: player count is always 0
		for( auto i = 0; i < MaxTeams; ++i )
		{
			UTIL_LogPrintf( ""Team \\""%s\\"" scored \\""%d\\"" with \\""%d\\"" players\\n"", team_names[ i ], teamscores[ i ], 0 );
		}

		UTIL_LogPrintf( ""// === End-Game Overall Statistics ===\\n"" );

		auto winningTeam = GetWinningTeam();

		if( CTFTeam::None == winningTeam )
		{
			UTIL_LogPrintf( ""// %-25s : %s\\n"", ""Winning Team"", ""Draw"" );
			UTIL_LogPrintf( ""World triggered \\""Draw\\""\\n"" );
		}
		else
		{
			auto pszTeam = team_names[ ToTeamIndex( winningTeam ) ];

			UTIL_LogPrintf( ""// %-25s : %s\\n"", ""Winning Team"", pszTeam );
			UTIL_LogPrintf( ""Team \\""%s\\"" triggered \\""Victory\\""\\n"", pszTeam );
		}
	}

	g_engfuncs.pfnMessageBegin( 2, gmsgStatsInfo, 0, 0 );
	g_engfuncs.pfnWriteByte( static_cast<int>( iTeamNum ) );

	g_engfuncs.pfnWriteByte( ( int ) GetWinningTeam() );
	g_engfuncs.pfnWriteByte( iNumPlayers );
	g_engfuncs.pfnWriteByte( 0 );

	SendTeamStat( iMostPts, ""Most Points"", iPts );
	SendTeamStat( iMostFrags, ""Most Frags"", iFrags );
	SendTeamStat( iMostCTFPts, ""Most CTF Points"", iCTFPts );
	SendTeamStat( iMostOff, ""Most Offense"", iOffPts );
	SendTeamStat( iMostDef, ""Most Defense"", iDefPts );
	SendTeamStat( iMostSnipe, ""Most Sniper Kills"", iSnipeVal );
	SendTeamStat( iMostBarnacle, ""Most Barnacle Kills"", iBarnacleVal );
	g_engfuncs.pfnMessageEnd();

	g_engfuncs.pfnMessageBegin( 2, gmsgStatsInfo, 0, 0 );
	g_engfuncs.pfnWriteByte( static_cast<int>( iTeamNum ) );

	g_engfuncs.pfnWriteByte( ( int ) GetWinningTeam() );
	g_engfuncs.pfnWriteByte( iNumPlayers );
	g_engfuncs.pfnWriteByte( 1 );

	SendTeamStat( iMostDeaths, ""Most Deaths"", iDeathsVal );
	SendTeamStat( iMostSuicides, ""Most Suicides"", iSuicidesVal );
	SendTeamStat( iMostDamage, ""Most Damage"", iDamageVal );
	SendTeamTimeStat( iMostAccel, ""Most Damage Powerup Time"", flAccelVal );
	SendTeamTimeStat( iMostBackpack, ""Most Backpack Powerup Time"", flBackpackVal );
	SendTeamTimeStat( iMostHealth, ""Most Health Powerup Time"", flHealthVal );
	SendTeamTimeStat( iMostShield, ""Most Shield Powerup Time"", flShieldVal );
	SendTeamTimeStat( iMostJump, ""Most Jumppack Powerup Time"", flJumpVal );
	g_engfuncs.pfnMessageEnd();
}

void CHalfLifeCTFplay::SendPlayerStatInfo( CBasePlayer* pPlayer )
{
	g_engfuncs.pfnMessageBegin(
		MSG_ONE,
		gmsgStatsPlayer,
		0,
		pPlayer->edict() );

	g_engfuncs.pfnWriteByte( pPlayer->entindex() );

	g_engfuncs.pfnWriteShort( ( int ) ( pPlayer->m_iCTFScore + pPlayer->pev->frags ) );
	g_engfuncs.pfnWriteShort( ( int ) pPlayer->pev->frags );
	g_engfuncs.pfnWriteShort( pPlayer->m_iCTFScore );
	g_engfuncs.pfnWriteShort( pPlayer->m_iOffense );
	g_engfuncs.pfnWriteShort( pPlayer->m_iDefense );
	g_engfuncs.pfnWriteShort( pPlayer->m_iSnipeKills );
	g_engfuncs.pfnWriteShort( pPlayer->m_iBarnacleKills );
	g_engfuncs.pfnWriteShort( pPlayer->m_iDeaths );
	g_engfuncs.pfnWriteShort( pPlayer->m_iSuicides );
	g_engfuncs.pfnWriteShort( pPlayer->m_iMostDamage );
	g_engfuncs.pfnWriteShort( ( short ) pPlayer->m_flAccelTime );
	g_engfuncs.pfnWriteShort( ( short ) pPlayer->m_flBackpackTime );
	g_engfuncs.pfnWriteShort( ( short ) pPlayer->m_flHealthTime );
	g_engfuncs.pfnWriteShort( ( short ) pPlayer->m_flShieldTime );
	g_engfuncs.pfnWriteShort( ( short ) pPlayer->m_flJumpTime );
	g_engfuncs.pfnMessageEnd();
}

void CHalfLifeCTFplay::RecountTeams()
{
	team_count[ 1 ] = 0;
	team_count[ 0 ] = 0;

	for( int iPlayer = 1; iPlayer <= gpGlobals->maxClients; ++iPlayer )
	{
		auto pPlayer = UTIL_PlayerByIndex( iPlayer );

		if( pPlayer )
		{
			auto pszTeam = pPlayer->TeamID();

			auto teamIndex = GetTeamIndex( pszTeam );

			if( teamIndex >= 0 )
			{
				++team_count[ teamIndex ];
			}
		}
	}
}
",16362,True,3218.6302051770876,median
"/*
 *
 *    Copyright (c) 2013-2017 Nest Labs, Inc.
 *    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.
 *    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
 *      This file implements the WeaveExchangeManager class.
 *
 */


#ifndef __STDC_FORMAT_MACROS
#define __STDC_FORMAT_MACROS
#endif

#ifndef __STDC_LIMIT_MACROS
#define __STDC_LIMIT_MACROS
#endif

#include <Weave/Core/WeaveCore.h>
#include <Weave/Profiles/WeaveProfiles.h>
#include <Weave/Profiles/common/CommonProfile.h>
#include <Weave/Profiles/security/WeaveSecurity.h>
#include <Weave/Core/WeaveEncoding.h>
#include <Weave/Support/CodeUtils.h>
#include <Weave/Support/RandUtils.h>
#include <Weave/Support/logging/WeaveLogging.h>
#include <Weave/Support/WeaveFaultInjection.h>
#include <SystemLayer/SystemTimer.h>
#include <SystemLayer/SystemStats.h>

namespace nl {
namespace Weave {

using namespace nl::Weave::Profiles;
using namespace nl::Weave::Encoding;

/**
 *  Constructor for the WeaveExchangeManager class.
 *  It sets the state to kState_NotInitialized.
 *
 *  @note
 *    The class must be initialized via WeaveExchangeManager::Init()
 *    prior to use.
 *
 */
WeaveExchangeManager::WeaveExchangeManager()
{
    State = kState_NotInitialized;
}

/**
 *  Initialize the WeaveExchangeManager object. Within the lifetime
 *  of this instance, this method is invoked once after object
 *  construction until a call to Shutdown is made to terminate the
 *  instance.
 *
 *  @param[in]    msgLayer    A pointer to the WeaveMessageLayer object.
 *
 *  @retval #WEAVE_ERROR_INCORRECT_STATE If the state is not equal to
 *          kState_NotInitialized.
 *  @retval #WEAVE_NO_ERROR On success.
 *
 */
WEAVE_ERROR WeaveExchangeManager::Init(WeaveMessageLayer *msgLayer)
{
    if (State != kState_NotInitialized)
        return WEAVE_ERROR_INCORRECT_STATE;

    MessageLayer = msgLayer;
    FabricState = msgLayer->FabricState;

    NextExchangeId = GetRandU16();

    memset(ContextPool, 0, sizeof(ContextPool));
    mContextsInUse = 0;

    InitBindingPool();

    memset(UMHandlerPool, 0, sizeof(UMHandlerPool));
    OnExchangeContextChanged = NULL;

    msgLayer->ExchangeMgr = this;
    msgLayer->OnMessageReceived = HandleMessageReceived;
    msgLayer->OnAcceptError = HandleAcceptError;

#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
    mWRMPTimerInterval  = WEAVE_CONFIG_WRMP_TIMER_DEFAULT_PERIOD;       //WRMP Timer tick period

    memset(RetransTable, 0, sizeof(RetransTable));

    mWRMPTimeStampBase = System::Timer::GetCurrentEpoch();
#endif

    State = kState_Initialized;

    return WEAVE_NO_ERROR;
}

/**
 *  Shutdown the WeaveExchangeManager. This terminates this instance
 *  of the object and releases all held resources.
 *
 *  @note
 *     The application should only call this function after ensuring that
 *     there are no active ExchangeContext objects. Furthermore, it is the
 *     onus of the application to de-allocate the WeaveExchangeManager
 *     object after calling WeaveExchangeManager::Shutdown().
 *
 *  @return #WEAVE_NO_ERROR unconditionally.
 *
 */
WEAVE_ERROR WeaveExchangeManager::Shutdown()
{
    if (MessageLayer != NULL)
    {
        if (MessageLayer->ExchangeMgr == this)
        {
            MessageLayer->ExchangeMgr = NULL;
            MessageLayer->OnMessageReceived = NULL;
            MessageLayer->OnAcceptError = NULL;
        }
#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
        WRMPStopTimer();

        //Clear the retransmit table
        for (int i = 0; i < WEAVE_CONFIG_WRMP_RETRANS_TABLE_SIZE; i++)
        {
            ClearRetransmitTable(RetransTable[i]);
        }
#endif
        MessageLayer = NULL;
    }

    OnExchangeContextChanged = NULL;

    FabricState = NULL;

    State = kState_NotInitialized;

    return WEAVE_NO_ERROR;
}

/**
 *  Creates a new ExchangeContext with a given peer Weave node specified by the peer node identifier.
 *
 *  @param[in]    peerNodeId    The node identifier of the peer with which the ExchangeContext is being set up.
 *
 *  @param[in]    appState      A pointer to a higher layer object that holds context state.
 *
 *  @return   A pointer to the created ExchangeContext object On success. Otherwise NULL if no object
 *            can be allocated or is available.
 *
 */
ExchangeContext *WeaveExchangeManager::NewContext(const uint64_t &peerNodeId, void *appState)
{
    return NewContext(peerNodeId, FabricState->SelectNodeAddress(peerNodeId), WEAVE_PORT, INET_NULL_INTERFACEID, appState);
}

/**
 *  Creates a new ExchangeContext with a given peer Weave node specified by the peer node identifier
 *  and peer IP address.
 *
 *  @param[in]    peerNodeId    The node identifier of the peer with which the ExchangeContext is being set up.
 *
 *  @param[in]    peerAddr      The IP address of the peer node.
 *
 *  @param[in]    appState      A pointer to a higher layer object that holds context state.
 *
 *  @return   A pointer to the created ExchangeContext object On success. Otherwise, NULL if no object
 *            can be allocated or is available.
 *
 */
ExchangeContext *WeaveExchangeManager::NewContext(const uint64_t &peerNodeId, const IPAddress &peerAddr, void *appState)
{
    return NewContext(peerNodeId, peerAddr, WEAVE_PORT, INET_NULL_INTERFACEID, appState);
}

/**
 *  Creates a new ExchangeContext with a given peer Weave node specified by the peer node identifier, peer IP address,
 *  and destination port on a specified interface.
 *
 *  @param[in]    peerNodeId    The node identifier of the peer with which the ExchangeContext is being set up.
 *
 *  @param[in]    peerAddr      The IP address of the peer node.
 *
 *  @param[in]    peerPort      The port of the peer node.
 *
 *  @param[in]    sendIntfId    The interface to use for sending Weave messages on this exchange.
 *
 *  @param[in]    appState      A pointer to a higher layer object that holds context state.
 *
 *  @return   A pointer to the created ExchangeContext object On success. Otherwise, NULL if no object
 *            can be allocated or is available.
 *
 */
ExchangeContext *WeaveExchangeManager::NewContext(const uint64_t &peerNodeId, const IPAddress &peerAddr, uint16_t peerPort, InterfaceId sendIntfId, void *appState)
{
    ExchangeContext *ec = AllocContext();
    if (ec != NULL)
    {
        ec->ExchangeId = NextExchangeId++;
        ec->PeerNodeId = peerNodeId;
        ec->PeerAddr = peerAddr;
        ec->PeerPort = (peerPort != 0) ? peerPort : WEAVE_PORT;
        ec->PeerIntf = sendIntfId;
        ec->AppState = appState;
        ec->SetInitiator(true);
        //Initialize WRMP variables
        ec->mMsgProtocolVersion = 0;
#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
        // No need to set WRMP timer, this will be done when we add to retrans table
        ec->mWRMPNextAckTime = 0;
        ec->SetAckPending(false);
        ec->SetMsgRcvdFromPeer(false);
        ec->mWRMPConfig = gDefaultWRMPConfig;
        ec->mWRMPThrottleTimeout = 0;
        //Internal and for Debug Only; When set, Exchange Layer does not send Ack.
        ec->SetDropAck(false);
        //Initialize the App callbacks to NULL
        ec->OnThrottleRcvd = NULL;
        ec->OnDDRcvd = NULL;
        ec->OnAckRcvd = NULL;
        ec->OnSendError = NULL;
#endif
        WeaveLogProgress(ExchangeManager, ""ec id: %d, AppState: 0x%x"", EXCHANGE_CONTEXT_ID(ec - ContextPool), ec->AppState);
    }
    return ec;
}

/**
 *  Creates a new ExchangeContext with a given peer Weave node over a specified WeaveConnection.
 *
 *  @param[in]    con           A pointer to the WeaveConnection object representing the TCP connection
 *                              with the peer.
 *
 *  @param[in]    appState      A pointer to a higher layer object that holds context state.
 *
 *  @return   A pointer to the created ExchangeContext object On success. Otherwise, NULL if no object
 *            can be allocated or is available.
 *
 */
ExchangeContext *WeaveExchangeManager::NewContext(WeaveConnection *con, void *appState)
{
    ExchangeContext *ec = NewContext(con->PeerNodeId, con->PeerAddr, con->PeerPort, INET_NULL_INTERFACEID, appState);
    if (ec != NULL)
    {
        ec->Con = con;
        ec->KeyId = con->DefaultKeyId;
        ec->EncryptionType = con->DefaultEncryptionType;
    }
    return ec;
}

/**
 *  Find the ExchangeContext from a pool matching a given set of parameters.
 *
 *  @param[in]    peerNodeId    The node identifier of the peer with which the ExchangeContext has been set up.
 *
 *  @param[in]    con           A pointer to the WeaveConnection object representing the TCP connection
 *                              with the peer.
 *
 *  @param[in]    appState      A pointer to a higher layer object that holds context state.
 *
 *  @param[in]    isInitiator   Boolean indicator of whether the local node is the initiator of the exchange.
 *
 *  @return   A pointer to the ExchangeContext object matching the provided parameters On success, NULL on no match.
 *
 */
ExchangeContext *WeaveExchangeManager::FindContext(uint64_t peerNodeId, WeaveConnection *con, void *appState, bool isInitiator)
{
    ExchangeContext *ec = (ExchangeContext *) ContextPool;
    for (int i = 0; i < WEAVE_CONFIG_MAX_EXCHANGE_CONTEXTS; i++, ec++)
        if (ec->ExchangeMgr != NULL && ec->PeerNodeId == peerNodeId &&
            ec->Con == con && ec->AppState == appState &&
            ec->IsInitiator() == isInitiator)
            return ec;
    return NULL;
}

/**
 *  Register an unsolicited message handler for a given profile identifier. This handler would be
 *  invoked for all messages of the given profile.
 *
 *  @param[in]    profileId     The profile identifier of the received message.
 *
 *  @param[in]    handler       The unsolicited message handler.
 *
 *  @param[in]    appState      A pointer to a higher layer object that holds context state.
 *
 *  @retval #WEAVE_ERROR_TOO_MANY_UNSOLICITED_MESSAGE_HANDLERS If the unsolicited message handler pool
 *                                                             is full and a new one cannot be allocated.
 *  @retval #WEAVE_NO_ERROR On success.
 */
WEAVE_ERROR WeaveExchangeManager::RegisterUnsolicitedMessageHandler(uint32_t profileId,
        ExchangeContext::MessageReceiveFunct handler, void *appState)
{
    return RegisterUMH(profileId, (int16_t) -1, NULL, false, handler, appState);
}

/**
 *  Register an unsolicited message handler for a given profile identifier. This handler would be invoked for all messages of the given profile.
 *
 *  @param[in]    profileId     The profile identifier of the received message.
 *
 *  @param[in]    handler       The unsolicited message handler.
 *
 *  @param[in]    allowDups     Boolean indicator of whether duplicate messages are allowed for a given profile.
 *
 *  @param[in]    appState      A pointer to a higher layer object that holds context state.
 *
 *  @retval #WEAVE_ERROR_TOO_MANY_UNSOLICITED_MESSAGE_HANDLERS If the unsolicited message handler pool
 *                                                             is full and a new one cannot be allocated.
 *  @retval #WEAVE_NO_ERROR On success.
 */
WEAVE_ERROR WeaveExchangeManager::RegisterUnsolicitedMessageHandler(uint32_t profileId,
        ExchangeContext::MessageReceiveFunct handler, bool allowDups, void *appState)
{
    return RegisterUMH(profileId, (int16_t) -1, NULL, allowDups, handler, appState);
}

/**
 *  Register an unsolicited message handler for a given profile identifier and message type.
 *
 *  @param[in]    profileId     The profile identifier of the received message.
 *
 *  @param[in]    msgType       The message type of the corresponding profile.
 *
 *  @param[in]    handler       The unsolicited message handler.
 *
 *  @param[in]    appState      A pointer to a higher layer object that holds context state.
 *
 *  @retval #WEAVE_ERROR_TOO_MANY_UNSOLICITED_MESSAGE_HANDLERS If the unsolicited message handler pool
 *                                                             is full and a new one cannot be allocated.
 *  @retval #WEAVE_NO_ERROR On success.
 */
WEAVE_ERROR WeaveExchangeManager::RegisterUnsolicitedMessageHandler(uint32_t profileId, uint8_t msgType,
        ExchangeContext::MessageReceiveFunct handler, void *appState)
{
    return RegisterUMH(profileId, (int16_t) msgType, NULL, false, handler, appState);
}

/**
 *  Register an unsolicited message handler for a given profile identifier and message type.
 *
 *  @param[in]    profileId     The profile identifier of the received message.
 *
 *  @param[in]    msgType       The message type of the corresponding profile.
 *
 *  @param[in]    handler       The unsolicited message handler.
 *
 *  @param[in]    allowDups     Boolean indicator of whether duplicate messages are allowed for a given
 *                              profile identifier and message type.
 *
 *  @param[in]    appState      A pointer to a higher layer object that holds context state.
 *
 *  @retval #WEAVE_ERROR_TOO_MANY_UNSOLICITED_MESSAGE_HANDLERS If the unsolicited message handler pool
 *                                                             is full and a new one cannot be allocated.
 *  @retval #WEAVE_NO_ERROR On success.
 */
WEAVE_ERROR WeaveExchangeManager::RegisterUnsolicitedMessageHandler(uint32_t profileId, uint8_t msgType,
        ExchangeContext::MessageReceiveFunct handler, bool allowDups, void *appState)
{
    return RegisterUMH(profileId, (int16_t) msgType, NULL, allowDups, handler, appState);
}

/**
 *  Register an unsolicited message handler for a given profile identifier, message type on a specified Weave
 *  connection.
 *
 *  @param[in]    profileId     The profile identifier of the received message.
 *
 *  @param[in]    msgType       The message type of the corresponding profile.
 *
 *  @param[in]    con           A pointer to the WeaveConnection object representing the TCP connection
 *                              with the peer.
 *
 *  @param[in]    handler       The unsolicited message handler.
 *
 *  @param[in]    appState      A pointer to a higher layer object that holds context state.
 *
 *  @retval #WEAVE_ERROR_TOO_MANY_UNSOLICITED_MESSAGE_HANDLERS If the unsolicited message handler pool
 *                                                             is full and a new one cannot be allocated.
 *  @retval #WEAVE_NO_ERROR On success.
 */
WEAVE_ERROR WeaveExchangeManager::RegisterUnsolicitedMessageHandler(uint32_t profileId, uint8_t msgType, WeaveConnection *con,
        ExchangeContext::MessageReceiveFunct handler, void *appState)
{
    return RegisterUMH(profileId, (int16_t) msgType, con, false, handler, appState);
}

/**
 *  Register an unsolicited message handler for a given profile identifier, message type on a specified Weave
 *  connection.
 *
 *  @param[in]    profileId     The profile identifier of the received message.
 *
 *  @param[in]    msgType       The message type of the corresponding profile.
 *
 *  @param[in]    con           A pointer to the WeaveConnection object representing the TCP connection
 *                              with the peer.
 *
 *  @param[in]    handler       The unsolicited message handler.
 *
 *  @param[in]    allowDups     Boolean indicator of whether duplicate messages are allowed for a given
 *                              profile identifier, message type on a specified Weave connection.
 *
 *  @param[in]    appState      A pointer to a higher layer object that holds context state.
 *
 *  @retval #WEAVE_ERROR_TOO_MANY_UNSOLICITED_MESSAGE_HANDLERS If the unsolicited message handler pool
 *                                                             is full and a new one cannot be allocated.
 *  @retval #WEAVE_NO_ERROR On success.
 */
WEAVE_ERROR WeaveExchangeManager::RegisterUnsolicitedMessageHandler(uint32_t profileId, uint8_t msgType, WeaveConnection *con,
        ExchangeContext::MessageReceiveFunct handler, bool allowDups, void *appState)
{
    return RegisterUMH(profileId, (int16_t) msgType, con, allowDups, handler, appState);
}

/**
 *  Unregister an unsolicited message handler for a given profile identifier.
 *
 *  @param[in]    profileId     The profile identifier of the received message.
 *
 *  @retval #WEAVE_ERROR_NO_UNSOLICITED_MESSAGE_HANDLER  If the matching unsolicited message handler
 *                                                       is not found.
 *  @retval #WEAVE_NO_ERROR On success.
 */
WEAVE_ERROR WeaveExchangeManager::UnregisterUnsolicitedMessageHandler(uint32_t profileId)
{
    return UnregisterUMH(profileId, (int16_t) -1, NULL);
}

/**
 *  Unregister an unsolicited message handler for a given profile identifier and message type.
 *
 *  @param[in]    profileId     The profile identifier of the received message.
 *
 *  @param[in]    msgType       The message type of the corresponding profile.
 *
 *  @retval #WEAVE_ERROR_NO_UNSOLICITED_MESSAGE_HANDLER  If the matching unsolicited message handler
 *                                                       is not found.
 *  @retval #WEAVE_NO_ERROR On success.
 */
WEAVE_ERROR WeaveExchangeManager::UnregisterUnsolicitedMessageHandler(uint32_t profileId, uint8_t msgType)
{
    return UnregisterUMH(profileId, (int16_t) msgType, NULL);
}

/**
 *  Unregister an unsolicited message handler for a given profile identifier, message type, and Weave connection.
 *
 *  @param[in]    profileId     The profile identifier of the received message.
 *
 *  @param[in]    msgType       The message type of the corresponding profile.
 *
 *  @param[in]    con           A pointer to the WeaveConnection object representing the TCP connection
 *                              with the peer.
 *
 *  @retval #WEAVE_ERROR_NO_UNSOLICITED_MESSAGE_HANDLER  If the matching unsolicited message handler
 *                                                       is not found.
 *  @retval #WEAVE_NO_ERROR On success.
 */
WEAVE_ERROR WeaveExchangeManager::UnregisterUnsolicitedMessageHandler(uint32_t profileId, uint8_t msgType, WeaveConnection *con)
{
    return UnregisterUMH(profileId, (int16_t) msgType, con);
}

void WeaveExchangeManager::HandleAcceptError(WeaveMessageLayer *msgLayer, WEAVE_ERROR err)
{
    WeaveLogError(ExchangeManager, ""Accept FAILED, err = %s"", ErrorStr(err));
}

void WeaveExchangeManager::HandleConnectionReceived(WeaveConnection *con)
{
    // Hook the OnMessageReceived callback for new inbound connections.
    con->OnMessageReceived = HandleMessageReceived;
}

void WeaveExchangeManager::HandleConnectionClosed(WeaveConnection *con, WEAVE_ERROR conErr)
{
    for (int i = 0; i < WEAVE_CONFIG_MAX_BINDINGS; i++)
    {
        BindingPool[i].OnConnectionClosed(con, conErr);
    }

    ExchangeContext *ec = (ExchangeContext *) ContextPool;
    for (int i = 0; i < WEAVE_CONFIG_MAX_EXCHANGE_CONTEXTS; i++, ec++)
        if (ec->ExchangeMgr != NULL && ec->Con == con)
        {
            ec->HandleConnectionClosed(conErr);
        }

    UnsolicitedMessageHandler *umh = (UnsolicitedMessageHandler *) UMHandlerPool;
    for (int i = 0; i < WEAVE_CONFIG_MAX_UNSOLICITED_MESSAGE_HANDLERS; i++, umh++)
        if (umh->Handler != NULL && umh->Con == con)
        {
            SYSTEM_STATS_DECREMENT(nl::Weave::System::Stats::kExchangeMgr_NumUMHandlers);
            umh->Handler = NULL;
        }
}

/**
 * Expire the timers started by ExchangeContext instances.
 * This function is not meant to be used in production code.
 *
 * @return Number of timers found running.
 */
#if WEAVE_CONFIG_TEST
size_t WeaveExchangeManager::ExpireExchangeTimers(void)
{
    size_t retval = 0;
    ExchangeContext *ec = (ExchangeContext *) ContextPool;
    for (int i = 0; i < WEAVE_CONFIG_MAX_EXCHANGE_CONTEXTS; i++, ec++)
    {
        if (ec->ExchangeMgr != NULL)
        {
            if (ec->ResponseTimeout)
            {
                ec->CancelResponseTimer();
                ec->ResponseTimeout = 1;
                ec->StartResponseTimer();
                retval++;
            }
        }
    }
    return retval;
}
#endif

ExchangeContext *WeaveExchangeManager::AllocContext()
{
    ExchangeContext *ec = (ExchangeContext *) ContextPool;

    WEAVE_FAULT_INJECT(FaultInjection::kFault_AllocExchangeContext,
                       return NULL);

    for (int i = 0; i < WEAVE_CONFIG_MAX_EXCHANGE_CONTEXTS; i++, ec++)
        if (ec->ExchangeMgr == NULL)
        {
            memset(ec, 0, sizeof(ExchangeContext));
            ec->ExchangeMgr = this;
            ec->mRefCount = 1;
            mContextsInUse++;
            MessageLayer->SignalMessageLayerActivityChanged();
#if defined(WEAVE_EXCHANGE_CONTEXT_DETAIL_LOGGING)
            WeaveLogProgress(ExchangeManager, ""ec++ id: %d, inUse: %d, addr: 0x%x"", EXCHANGE_CONTEXT_ID(ec - ContextPool), mContextsInUse, ec);
#endif
            SYSTEM_STATS_INCREMENT(nl::Weave::System::Stats::kExchangeMgr_NumContexts);

            return ec;
        }
    WeaveLogError(ExchangeManager, ""Alloc ctxt FAILED"");
    return NULL;
}

#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
void WeaveExchangeManager::WRMPProcessDDMessage(uint32_t PauseTimeMillis, uint64_t DelayedNodeId)
{
    // Expire any virtual ticks that have expired so all wakeup sources reflect the current time
    WRMPExpireTicks();

    //Go through the retrans table entries for that node and adjust the timer.
    for (int i = 0; i < WEAVE_CONFIG_WRMP_RETRANS_TABLE_SIZE; i++)
    {
        //Exchcontext is the sentinel object to ascertain validity of the element
        if (RetransTable[i].exchContext)
        {
            //Adjust the retrans timer value if Delayed Node identifier matches Peer in ExchangeContext
            if (DelayedNodeId == RetransTable[i].exchContext->PeerNodeId)
            {

                //Paustime is specified in milliseconds; Update retrans values
                RetransTable[i].nextRetransTime += (PauseTimeMillis / mWRMPTimerInterval);

                //Call the application callback
                if (RetransTable[i].exchContext->OnDDRcvd)
                {
                    RetransTable[i].exchContext->OnDDRcvd(RetransTable[i].exchContext,
                                                          PauseTimeMillis);
                }
                else
                {
                    WeaveLogError(ExchangeManager,
                                  ""No App Handler for Delayed Delivery for ExchangeContext with Id %04"" PRIX16,
                                  RetransTable[i].exchContext->ExchangeId);

                }
            }//DelayedNodeId == PeerNodeId
        }//exchContext
    }//for loop in table entry

    // Schedule next physical wakeup
    WRMPStartTimer();
}
#endif // WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING

static void DefaultOnMessageReceived(ExchangeContext *ec, const IPPacketInfo *pktInfo, const WeaveMessageInfo *msgInfo, uint32_t profileId,
            uint8_t msgType, PacketBuffer *payload)
{
    WeaveLogError(ExchangeManager,
            ""Dropping unexpected message %08"" PRIX32 "":%d %04"" PRIX16 "" MsgId:%08"" PRIX32,
            profileId, msgType, ec->ExchangeId, msgInfo->MessageId);

    PacketBuffer::Free(payload);
}

void WeaveExchangeManager::DispatchMessage(WeaveMessageInfo *msgInfo, PacketBuffer *msgBuf)
{
    WeaveExchangeHeader exchangeHeader;
    UnsolicitedMessageHandler *umh         = NULL;
    UnsolicitedMessageHandler *matchingUMH = NULL;
    ExchangeContext *ec                    = NULL;
    WeaveConnection *msgCon                = NULL;
#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
    const uint8_t      *p                  = NULL;
    uint32_t     PauseTimeMillis           = 0;
    uint64_t     DelayedNodeId             = 0;
    bool dupMsg;
    bool msgNeedsAck;
    bool sendAckAndCloseExchange;
#endif
#if WEAVE_CONFIG_USE_APP_GROUP_KEYS_FOR_MSG_ENC
    bool isMsgCounterSyncResp;
    bool peerGroupMsgIdNotSynchronized;
#endif
    WEAVE_ERROR  err                       = WEAVE_NO_ERROR;

    // Decode the exchange header.
    err = DecodeHeader(&exchangeHeader, msgBuf);
    SuccessOrExit(err);

    //Check if the version is supported
    if ((msgInfo->MessageVersion != kWeaveMessageVersion_V1) &&
        (msgInfo->MessageVersion != kWeaveMessageVersion_V2))
    {
        ExitNow(err = WEAVE_ERROR_UNSUPPORTED_MESSAGE_VERSION);
    }

    // Notify Weave Security Manager that encrypted message has been received.
    if (msgInfo->EncryptionType != kWeaveEncryptionType_None)
    {
        MessageLayer->SecurityMgr->OnEncryptedMsgRcvd(msgInfo->KeyId, msgInfo->SourceNodeId, msgInfo->EncryptionType);
    }

    msgCon = msgInfo->InCon;

    WeaveLogRetain(ExchangeManager, ""Msg %s %08"" PRIX32 "":%d %d %016"" PRIX64 "" %04"" PRIX16 "" %04"" PRIX16 "" %ld MsgId:%08"" PRIX32,
                   ""rcvd"", exchangeHeader.ProfileId, exchangeHeader.MessageType,
                   (int)msgBuf->DataLength(), msgInfo->SourceNodeId, msgCon->LogId(), exchangeHeader.ExchangeId,
                   (long)err, msgInfo->MessageId);

#if WEAVE_CONFIG_USE_APP_GROUP_KEYS_FOR_MSG_ENC
    isMsgCounterSyncResp = exchangeHeader.ProfileId == nl::Weave::Profiles::kWeaveProfile_Security &&
                           exchangeHeader.MessageType == nl::Weave::Profiles::Security::kMsgType_MsgCounterSyncResp;
    peerGroupMsgIdNotSynchronized = (msgInfo->Flags & kWeaveMessageFlag_PeerGroupMsgIdNotSynchronized) != 0;

    // If received message is a MsgCounterSyncResp process it first.
    if (isMsgCounterSyncResp)
    {
        MessageLayer->SecurityMgr->HandleMsgCounterSyncRespMsg(msgInfo, msgBuf);
        msgBuf = NULL;
    }

    // If message counter synchronization was requested.
    if ((msgInfo->Flags & kWeaveMessageFlag_MsgCounterSyncReq) != 0)
    {
        MessageLayer->SecurityMgr->SendMsgCounterSyncResp(msgInfo, msgInfo->InPacketInfo);

#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
        // Retransmit all pending messages that were encrypted with application group key.
        RetransPendingAppGroupMsgs(msgInfo->SourceNodeId);
#endif
    }
    // Otherwise, if received message is not MsgCounterSyncResp and peer's message counter synchronization is needed.
    else if (!isMsgCounterSyncResp && peerGroupMsgIdNotSynchronized)
    {
        MessageLayer->SecurityMgr->SendSolitaryMsgCounterSyncReq(msgInfo, msgInfo->InPacketInfo);
    }

    // Exit now without error if received MsgCounterSyncResp message.
    if (isMsgCounterSyncResp)
    {
        ExitNow();
    }
#endif // WEAVE_CONFIG_USE_APP_GROUP_KEYS_FOR_MSG_ENC

#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
    //Received Delayed Delivery Message: Extend time for pending retrans objects
    if (exchangeHeader.ProfileId == nl::Weave::Profiles::kWeaveProfile_Common &&
        exchangeHeader.MessageType == nl::Weave::Profiles::Common::kMsgType_WRMP_Delayed_Delivery)
    {
        // Process Delayed Delivery message if it is not a duplicate.
        if ((msgInfo->Flags & kWeaveMessageFlag_DuplicateMessage) == 0)
        {
            p = msgBuf->Start();

            PauseTimeMillis = LittleEndian::Read32(p);
            DelayedNodeId = LittleEndian::Read64(p);

            WRMPProcessDDMessage(PauseTimeMillis, DelayedNodeId);
        }

        //Return after processing Delayed Delivery message
        ExitNow(err = WEAVE_NO_ERROR);
    }//If delayed delivery Msg
#endif

    // Search for an existing exchange that the message applies to. If a match is found...
    ec = (ExchangeContext *) ContextPool;
    for (int i = 0; i < WEAVE_CONFIG_MAX_EXCHANGE_CONTEXTS; i++, ec++)
    {
        if (ec->ExchangeMgr != NULL && ec->MatchExchange(msgCon, msgInfo, &exchangeHeader))
        {
#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
            // Found a matching exchange. Set flag for correct subsequent WRM
            // retransmission timeout selection.
            if (!ec->HasRcvdMsgFromPeer())
            {
                ec->SetMsgRcvdFromPeer(true);
            }
#endif

            //Matched ExchangeContext; send to message handler.
            ec->HandleMessage(msgInfo, &exchangeHeader, msgBuf);

            msgBuf = NULL;

            ExitNow(err = WEAVE_NO_ERROR);
        }
    }

#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
    // Is message a duplicate that needs ack.
    msgNeedsAck = exchangeHeader.Flags & kWeaveExchangeFlag_NeedsAck;
    dupMsg = (msgInfo->Flags & kWeaveMessageFlag_DuplicateMessage);
#endif

    // Search for an unsolicited message handler if it marked as being sent by an initiator. Since we didn't
    // find an existing exchange that matches the message, it must be an unsolicited message. However all
    // unsolicited messages must be marked as being from an initiator.
    if (exchangeHeader.Flags & kWeaveExchangeFlag_Initiator)
    {
        // Search for an unsolicited message handler that can handle the message. Prefer handlers that can explicitly
        // handle the message type over handlers that handle all messages for a profile.
        umh = (UnsolicitedMessageHandler *) UMHandlerPool;

        matchingUMH = NULL;

        for (int i = 0; i < WEAVE_CONFIG_MAX_UNSOLICITED_MESSAGE_HANDLERS; i++, umh++)
            if (umh->Handler != NULL && umh->ProfileId == exchangeHeader.ProfileId && (umh->Con == NULL || umh->Con == msgCon)
                && (!(msgInfo->Flags & kWeaveMessageFlag_DuplicateMessage) || umh->AllowDuplicateMsgs))
            {
                if (umh->MessageType == exchangeHeader.MessageType)
                {
                    matchingUMH = umh;
                    break;
                }

                if (umh->MessageType == -1)
                    matchingUMH = umh;
            }
    }
    // Discard the message if it isn't marked as being sent by an initiator and the message is not a duplicate
    // that needs to send ack to the peer.
    else
    {
#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
        if (!msgNeedsAck)
#endif
            ExitNow(err = WEAVE_ERROR_UNSOLICITED_MSG_NO_ORIGINATOR);
    }

    // If no existing exchange that the message applies to was found we need to create
    // a new exchange context (EC) in the following cases:
    //
    //   (Dup.) Msg |  UMH is  |  Allow  | Need Peer |              Action
    //   Needs Ack  |  Found   |   Dup.  | MsgIdSync |
    // ----------------------------------------------------------------------------------------------------------
    //       Y      |     Y    |    Y    |     -     | Create EC, ec->HandleMessage() sends Dup ack and App callback.
    //       Y      |     Y    |    N    |     N     | Create EC; ec->HandleMessage() sends Dup ack; Close EC.
    //       Y      |     N    |    -    |     N     | Create EC, ec->HandleMessage() sends Dup ack; Close EC.
    //       N      |     Y    |    -    |     -     | Create EC, ec->HandleMessage() sends ack (if needed) and App callback.
    //       N      |     N    |    -    |     -     | Do nothing.

#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
    // Create new exchange to send ack for a duplicate message and then close this exchange.
    sendAckAndCloseExchange = msgNeedsAck && (matchingUMH == NULL || (dupMsg && !matchingUMH->AllowDuplicateMsgs));

#if WEAVE_CONFIG_USE_APP_GROUP_KEYS_FOR_MSG_ENC
    // Don't create new EC only to send an ack if Peer's message counter synchronization is required.
    if (peerGroupMsgIdNotSynchronized)
        sendAckAndCloseExchange = false;
#endif
#endif

    // If we found a handler or we need to open a new exchange to send ack for a duplicate message.
    if (matchingUMH != NULL
#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
        || sendAckAndCloseExchange
#endif
       )
    {
        ExchangeContext::MessageReceiveFunct umhandler = NULL;

        ec = AllocContext();
        VerifyOrExit(ec != NULL, err = WEAVE_ERROR_NO_MEMORY);

        ec->Con = msgCon;
        ec->ExchangeId = exchangeHeader.ExchangeId;
        ec->PeerNodeId = msgInfo->SourceNodeId;
        if (msgInfo->InPacketInfo != NULL)
        {
            ec->PeerAddr = msgInfo->InPacketInfo->SrcAddress;
            ec->PeerPort = msgInfo->InPacketInfo->SrcPort;
            ec->PeerIntf = msgInfo->InPacketInfo->Interface;
        }
        ec->EncryptionType = msgInfo->EncryptionType;
        ec->KeyId = msgInfo->KeyId;
#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
        // No need to set WRMP timer, this will be done when we add to retrans table
        ec->mWRMPNextAckTime = 0;
        ec->SetAckPending(false);
        ec->SetMsgRcvdFromPeer(true);
        ec->mWRMPConfig = gDefaultWRMPConfig;
        ec->mWRMPThrottleTimeout = 0;
        //Internal and for Debug Only; When set, Exchange Layer does not send Ack.
        ec->SetDropAck(false);
#endif

        //Set the ExchangeContext version from the Message header version
        ec->mMsgProtocolVersion = msgInfo->MessageVersion;

        // If UMH was found and the exchange is created not just for sending ack.
#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
        if (!sendAckAndCloseExchange)
#endif
        {
            umhandler = matchingUMH->Handler;

            ec->SetInitiator(false);
            ec->AppState = matchingUMH->AppState;
            ec->OnMessageReceived = DefaultOnMessageReceived;
            ec->AllowDuplicateMsgs = matchingUMH->AllowDuplicateMsgs;

            WeaveLogProgress(ExchangeManager, ""ec id: %d, AppState: 0x%x"", EXCHANGE_CONTEXT_ID(ec - ContextPool), ec->AppState);
        }
#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
        // If the exchange is created only to send ack.
        else
        {
            // If rcvd msg is from initiator then this exchange is created as not Initiator (argument to SetInitiator() is false).
            // If rcvd msg is not from initiator then this exchange is created as Initiator (argument to SetInitiator() is true).
            ec->SetInitiator((exchangeHeader.Flags & kWeaveExchangeFlag_Initiator) == 0);
        }
#endif

        // Add a reservation for the message encryption key.  This will ensure the key is not removed until the exchange is freed.
        MessageLayer->SecurityMgr->ReserveKey(ec->PeerNodeId, ec->KeyId);

        // Arrange to automatically release the encryption key when the exchange is freed.
        ec->SetAutoReleaseKey(true);

        ec->HandleMessage(msgInfo, &exchangeHeader, msgBuf, umhandler);
        msgBuf = NULL;

#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
        // Close exchange if it was created only to send ack for a duplicate message.
        if (sendAckAndCloseExchange)
            ec->Close();
#endif
    }

exit:
    if (err != WEAVE_NO_ERROR)
    {
        WeaveLogError(ExchangeManager, ""DispatchMessage failed, err = %d"", err);
    }

    if (msgBuf != NULL)
    {
        PacketBuffer::Free(msgBuf);
    }

    return;
}

WEAVE_ERROR WeaveExchangeManager::RegisterUMH(uint32_t profileId, int16_t msgType, WeaveConnection *con, bool allowDups,
        ExchangeContext::MessageReceiveFunct handler, void *appState)
{
    UnsolicitedMessageHandler *umh = (UnsolicitedMessageHandler *) UMHandlerPool;
    UnsolicitedMessageHandler *selected = NULL;
    for (int i = 0; i < WEAVE_CONFIG_MAX_UNSOLICITED_MESSAGE_HANDLERS; i++, umh++)
    {
        if (umh->Handler == NULL)
        {
            if (selected == NULL)
                selected = umh;
        }
        else if (umh->ProfileId == profileId && umh->MessageType == msgType && umh->Con == con)
        {
            umh->Handler = handler;
            umh->AppState = appState;
            return WEAVE_NO_ERROR;
        }
    }

    if (selected == NULL)
        return WEAVE_ERROR_TOO_MANY_UNSOLICITED_MESSAGE_HANDLERS;

    selected->Handler = handler;
    selected->AppState = appState;
    selected->ProfileId = profileId;
    selected->Con = con;
    selected->MessageType = msgType;
    selected->AllowDuplicateMsgs = allowDups;

    SYSTEM_STATS_INCREMENT(nl::Weave::System::Stats::kExchangeMgr_NumUMHandlers);

    return WEAVE_NO_ERROR;
}

WEAVE_ERROR WeaveExchangeManager::UnregisterUMH(uint32_t profileId, int16_t msgType, WeaveConnection *con)
{
    UnsolicitedMessageHandler *umh = (UnsolicitedMessageHandler *) UMHandlerPool;
    for (int i = 0; i < WEAVE_CONFIG_MAX_UNSOLICITED_MESSAGE_HANDLERS; i++, umh++)
    {
        if (umh->Handler != NULL && umh->ProfileId == profileId && umh->MessageType == msgType && umh->Con == con)
        {
            umh->Handler = NULL;
            SYSTEM_STATS_DECREMENT(nl::Weave::System::Stats::kExchangeMgr_NumUMHandlers);
            return WEAVE_NO_ERROR;
        }
    }
    return WEAVE_ERROR_NO_UNSOLICITED_MESSAGE_HANDLER;
}

void WeaveExchangeManager::HandleMessageReceived(WeaveMessageLayer *msgLayer, WeaveMessageInfo *msgInfo, PacketBuffer *msgBuf)
{
    msgLayer->ExchangeMgr->DispatchMessage(msgInfo, msgBuf);
}

void WeaveExchangeManager::HandleMessageReceived(WeaveConnection *con, WeaveMessageInfo *msgInfo, PacketBuffer *msgBuf)
{
    con->MessageLayer->ExchangeMgr->DispatchMessage(msgInfo, msgBuf);
}

WEAVE_ERROR WeaveExchangeManager::PrependHeader(WeaveExchangeHeader *exchangeHeader, PacketBuffer *buf)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    uint16_t headLen = 8; //Constant part: Version/Flags + Msg Type + Exch Id + Profile Id
    uint8_t *p = NULL;

    // Make sure the buffer has a reserved size big enough to hold the full Weave header.
    if (!buf->EnsureReservedSize(WEAVE_HEADER_RESERVE_SIZE))
        ExitNow(err = WEAVE_ERROR_BUFFER_TOO_SMALL);

    // Verify the right application version is selected.
    if (exchangeHeader->Version != kWeaveExchangeVersion_V1)
        ExitNow(err = WEAVE_ERROR_UNSUPPORTED_EXCHANGE_VERSION);

#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
    //Compute the Header Len
    if (exchangeHeader->Flags & kWeaveExchangeFlag_AckId)
    {
        headLen += 4;
    }
#endif

    p = buf->Start();

    //Move the buffer start pointer back by the size of the app header.
    p -= headLen;

    // Adjust the buffer so that the start points to the start of the encoded message.
    buf->SetStart(p);

    // Encode the Weave application header
    Write8(p, ((exchangeHeader->Version << 4) | (exchangeHeader->Flags & 0xF)));
    Write8(p, exchangeHeader->MessageType);
    LittleEndian::Write16(p, exchangeHeader->ExchangeId);
    LittleEndian::Write32(p, exchangeHeader->ProfileId);

#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
    if (exchangeHeader->Flags & kWeaveExchangeFlag_AckId)
    {
        LittleEndian::Write32(p, exchangeHeader->AckMsgId);
    }
#endif

    WEAVE_FAULT_INJECT_MAX_ARG(FaultInjection::kFault_FuzzExchangeHeaderTx,
            // The FuzzExchangeHeader function takes as argument an index (0 to n-1) into a
            // (logical) array of fuzzing cases, because every field of the header can be fuzzed in 3
            // different ways. Therefore, the max index that can be used for the
            // message being sent depends on the number of fields in the header.
            // There are 4 fields, unless the AckMsgId field is present as
            // well, for a total of 5.
                ((exchangeHeader->Flags & kWeaveExchangeFlag_AckId ?
                   WEAVE_FAULT_INJECTION_EXCH_HEADER_NUM_FIELDS :
                   WEAVE_FAULT_INJECTION_EXCH_HEADER_NUM_FIELDS_WRMP) * WEAVE_FAULT_INJECTION_NUM_FUZZ_VALUES) -1,
                int32_t arg = 0;
                if (numFaultArgs > 0)
                {
                    arg = faultArgs[0];
                }
            ,
            // Code executed without the Manager's lock:
                nl::Weave::FaultInjection::FuzzExchangeHeader(buf->Start(), arg);
            );

exit:
    return err;
}

WEAVE_ERROR WeaveExchangeManager::DecodeHeader(WeaveExchangeHeader *exchangeHeader, PacketBuffer *buf)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;

    uint8_t *p = NULL;
    uint8_t versionFlags;
#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
    uint16_t msgLen = buf->DataLength();
    uint8_t *msgEnd = buf->Start() + msgLen;
#endif

    if (buf->DataLength() < 8)
        ExitNow(err = WEAVE_ERROR_INVALID_MESSAGE_LENGTH);

    p = buf->Start();

    versionFlags = Read8(p);
    exchangeHeader->Version = versionFlags >> 4;
    exchangeHeader->Flags = versionFlags & 0xF;

    if (exchangeHeader->Version != kWeaveExchangeVersion_V1)
        ExitNow(err = WEAVE_ERROR_UNSUPPORTED_EXCHANGE_VERSION);

    exchangeHeader->MessageType = Read8(p);

    exchangeHeader->ExchangeId = LittleEndian::Read16(p);

    exchangeHeader->ProfileId = LittleEndian::Read32(p);

#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
    if ((exchangeHeader->Flags & kWeaveExchangeFlag_AckId))
    {
        if ((p + 4) > msgEnd)
            ExitNow(err = WEAVE_ERROR_INVALID_MESSAGE_LENGTH);
        exchangeHeader->AckMsgId = LittleEndian::Read32(p);
    }
#endif

    buf->SetStart(p);

exit:
    return err;
}

/**
 *  Allow unsolicited messages to be received on the specified connection. This
 *  method sets the message reception handler on the given Weave connection.
 *
 *  @param[in]    con           A pointer to the Weave connection object.
 *
 */
void WeaveExchangeManager::AllowUnsolicitedMessages(WeaveConnection *con)
{
    // Hook the OnMessageReceived callback.
    con->OnMessageReceived = HandleMessageReceived;
}

/**
 *  Invoked when a message encryption key has been rejected by a peer (via a KeyError), or a key has
 *  otherwise become invalid (e.g. by ending a session).
 *
 *  @param[in] peerNodeId  The ID of the peer node with which the key is associated.
 *  @param[in] keyId       The ID of the key that has failed.
 *  @param[in] keyErr      A WEAVE_ERROR representing the reason the key is no longer valid.
 *
 */
void WeaveExchangeManager::NotifyKeyFailed(uint64_t peerNodeId, uint16_t keyId, WEAVE_ERROR keyErr)
{
    ExchangeContext *ec = (ExchangeContext *) ContextPool;

    for (int i = 0; i < WEAVE_CONFIG_MAX_EXCHANGE_CONTEXTS; i++, ec++)
    {
        if (ec->ExchangeMgr != NULL && ec->KeyId == keyId && ec->PeerNodeId == peerNodeId)
        {
#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
            // Ensure the exchange context stays around until we're done with it.
            ec->AddRef();

            // Fail entries matching ec.
            FailRetransmitTableEntries(ec, keyErr);
#endif

            // Application callback function in key error case.
            if (ec->OnKeyError)
                ec->OnKeyError(ec, keyErr);

#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
            // Release reference to the exchange context.
            ec->Release();
#endif
        }
    }

    for (int i = 0; i < WEAVE_CONFIG_MAX_BINDINGS; i++)
    {
        BindingPool[i].OnKeyFailed(peerNodeId, keyId, keyErr);
    }
}

/**
 *  Invoked when the security manager becomes available for initiating new secure sessions.
 */
void WeaveExchangeManager::NotifySecurityManagerAvailable()
{
    // Notify each binding that the security manager is now available.
    //
    // Note that this algorithm is unfair to bindings that are positioned later in the pool.
    // In practice, however, this is unlikely to cause any problems.
    for (int i = 0; i < WEAVE_CONFIG_MAX_BINDINGS; i++)
    {
        BindingPool[i].OnSecurityManagerAvailable();
    }
}

#if WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING
/**
 *  Clear MsgCounterSyncReq flag for all pending messages to that peer.
 *
 *  @param[in] peerNodeId    Node ID of the destination node.
 *
 */
void WeaveExchangeManager::ClearMsgCounterSyncReq(uint64_t peerNodeId)
{
    RetransTableEntry *re = (RetransTableEntry *) RetransTable;

    // Find all retransmit entries (re) matching peerNodeId and using application group key.
    for (int i = 0; i < WEAVE_CONFIG_WRMP_RETRANS_TABLE_SIZE; i++, re++)
    {
        if (re->exchContext != NULL && re->exchContext->PeerNodeId == peerNodeId && WeaveKeyId::IsAppGroupKey(re->exchContext->KeyId))
        {
            // Clear MsgCounterSyncReq flag.
            uint16_t headerField = LittleEndian::Get16(re->msgBuf->Start());
            headerField &= ~kWeaveMessageFlag_MsgCounterSyncReq;
            LittleEndian::Put16(re->msgBuf->Start(), headerField);
        }
    }
}

/**
 *  Retransmit all pending messages that were encrypted with application
 *  group key and were addressed to the specified node.
 *
 *  @param[in] peerNodeId    Node ID of the destination node.
 *
 */
void WeaveExchangeManager::RetransPendingAppGroupMsgs(uint64_t peerNodeId)
{
    RetransTableEntry *re = (RetransTableEntry *) RetransTable;

    // Find all retransmit entries (re) matching peerNodeId and using application group key.
    for (int i = 0; i < WEAVE_CONFIG_WRMP_RETRANS_TABLE_SIZE; i++, re++)
    {
        if (re->exchContext != NULL && re->exchContext->PeerNodeId == peerNodeId && WeaveKeyId::IsAppGroupKey(re->exchContext->KeyId))
        {
            // Decrement counter to discount the first sent message, which
            // was ignored by receiver due to un-synchronized message counter.
            re->sendCount--;

            // Retramsmit message.
            SendFromRetransTable(re);
        }
    }
}

/**
* Return a tick counter value given a time difference and a tick interval.
* The difference in time is not expected to exceed (2^32 - 1) within the
* scope of two timestamp comparisons in WRMP and, thus, it makes sense to cast
* the time delta to uint32_t. This also avoids invocation of 64 bit divisions
* in constrained platforms that do not support them.
*
* @param[in]  newTime        Timestamp value of in milliseconds.
* @param[in]  oldTime        Timestamp value of in milliseconds.
* @param[in]  tickInterval   Timer tick interval in milliseconds.
*
* @return Tick count for the time delta.
*/
uint32_t WeaveExchangeManager::GetTickCounterFromTimeDelta (uint64_t newTime,
                                                            uint64_t oldTime)
{
    uint32_t timeDelta = static_cast<uint32_t>(newTime - oldTime);

    return (timeDelta / mWRMPTimerInterval);
}

#if defined(WRMP_TICKLESS_DEBUG)
void WeaveExchangeManager::TicklessDebugDumpRetransTable(const char *log)
{
     WeaveLogProgress(ExchangeManager, log);

     for (int i = 0; i < WEAVE_CONFIG_WRMP_RETRANS_TABLE_SIZE; i++)
     {
         if (RetransTable[i].exchContext)
         {
             WeaveLogProgress(ExchangeManager, ""EC:%04"" PRIX16 "" MsgId:%08"" PRIX32 "" NextRetransTimeCtr:%04"" PRIX16,
                              RetransTable[i].exchContext,
                              RetransTable[i].msgId,
                              RetransTable[i].nextRetransTime);
         }
     }
}
#else
void WeaveExchangeManager::TicklessDebugDumpRetransTable(const char *log) { return; }
#endif // WRMP_TICKLESS_DEBUG

/**
* Iterate through active exchange contexts and retrans table entries.
* If an action needs to be triggered by WRMP time facilities, execute
* that action.
*
*/
void WeaveExchangeManager::WRMPExecuteActions(void)
{
    ExchangeContext *ec               = NULL;

    //Process Ack Tables for all ExchangeContexts
    ec = (ExchangeContext *)ContextPool;

#if defined(WRMP_TICKLESS_DEBUG)
    WeaveLogProgress(ExchangeManager, ""WRMPExecuteActions"");
#endif

    for (int i = 0; i < WEAVE_CONFIG_MAX_EXCHANGE_CONTEXTS; i++, ec++)
    {
        if (ec->ExchangeMgr != NULL && ec->IsAckPending())
        {
            if (0 == ec->mWRMPNextAckTime)
            {
#if defined(WRMP_TICKLESS_DEBUG)
                WeaveLogProgress(ExchangeManager, ""WRMPExecuteActions sending ACK"");
#endif
                //Send the Ack in a Common::Null message
                ec->SendCommonNullMessage();
                ec->SetAckPending(false);
            }
        }
    }

    TicklessDebugDumpRetransTable(""WRMPExecuteActions Dumping RetransTable entries before processing"");

    // Retransmit / cancel anything in the retrans table whose retrans timeout
    // has expired
    for (int i = 0; i < WEAVE_CONFIG_WRMP_RETRANS_TABLE_SIZE; i++)
    {
        ec = RetransTable[i].exchContext;
        if (ec)
        {
            WEAVE_ERROR err = WEAVE_NO_ERROR;

            if (0 == RetransTable[i].nextRetransTime)
            {
                uint8_t sendCount = RetransTable[i].sendCount;
                void * msgCtxt = RetransTable[i].msgCtxt;

                if (sendCount > ec->mWRMPConfig.mMaxRetrans)
                {
                    err = WEAVE_ERROR_MESSAGE_NOT_ACKNOWLEDGED;

                    WeaveLogError(ExchangeManager, ""Failed to Send Weave MsgId:%08"" PRIX32 "" sendCount: %"" PRIu8 "" max retries: %"" PRIu8,
                                  RetransTable[i].msgId, sendCount, ec->mWRMPConfig.mMaxRetrans);

                    // Remove from Table
                    ClearRetransmitTable(RetransTable[i]);
                }

                if (err == WEAVE_NO_ERROR)
                {
                    // Resend from Table (if the operation fails, the entry is cleared)
                    err = SendFromRetransTable(&(RetransTable[i]));
                }

                if (err == WEAVE_NO_ERROR)
                {
                    // If the retransmission was successful, update the passive timer
                    RetransTable[i].nextRetransTime = ec->GetCurrentRetransmitTimeout() / mWRMPTimerInterval;
#if defined(DEBUG)
                    WeaveLogProgress(ExchangeManager, ""Retransmit MsgId:%08"" PRIX32 "" Send Cnt %d"",
                            RetransTable[i].msgId, RetransTable[i].sendCount);
#endif
                }

                if (err != WEAVE_NO_ERROR)
                {
                    if (ec->OnSendError)
                    {
                        ec->OnSendError(ec, err, msgCtxt);
                    }
                }
            } //nextRetransTime = 0
        }
    }

    TicklessDebugDumpRetransTable(""WRMPExecuteActions Dumping RetransTable entries after processing"");
}

/**
* Calculate number of virtual WRMP ticks that have expired since we last
* called this function. Iterate through active exchange contexts and
* retrans table entries, subtracting expired virtual ticks to synchronize
* wakeup times with the current system time. Do not perform any actions
* beyond updating tick counts, actions will be performed by the physical
* WRMP timer tick expiry.
*
*/
void WeaveExchangeManager::WRMPExpireTicks(void)
{
    uint64_t            now         = 0;
    ExchangeContext*    ec          = NULL;
    uint16_t            deltaTicks;

    //Process Ack Tables for all ExchangeContexts
    ec = (ExchangeContext *)ContextPool;

    now = System::Timer::GetCurrentEpoch();

    // Number of full ticks elapsed since last timer processing.  We always round down
    // to the previous tick.  If we are between tick boundaries, the extra time since the
    // last virtual tick is not accounted for here (it will be accounted for when resetting
    // the WRMP timer)
    deltaTicks = GetTickCounterFromTimeDelta(now, mWRMPTimeStampBase);

#if defined(WRMP_TICKLESS_DEBUG)
    WeaveLogProgress(ExchangeManager, ""WRMPExpireTicks at %"" PRIu64 "", %"" PRIu64 "", %u"", now, mWRMPTimeStampBase, deltaTicks);
#endif

    for (int i = 0; i < WEAVE_CONFIG_MAX_EXCHANGE_CONTEXTS; i++, ec++)
    {
        if (ec->ExchangeMgr != NULL && ec->IsAckPending())
        {
            //Decrement counter of Ack timestamp by the elapsed timer ticks
            if (ec->mWRMPNextAckTime >= deltaTicks)
            {
                ec->mWRMPNextAckTime -= deltaTicks;
            }
            else
            {
                ec->mWRMPNextAckTime = 0;
            }
#if defined(WRMP_TICKLESS_DEBUG)
            WeaveLogProgress(ExchangeManager, ""WRMPExpireTicks set mWRMPNextAckTime to %u"", ec->mWRMPNextAckTime);
#endif
        }
    }

    //Process Throttle Time
    //Check Throttle timeout stored in EC to set/unset Throttle flag
    for (int i = 0; i < WEAVE_CONFIG_WRMP_RETRANS_TABLE_SIZE; i++)
    {
        ec = RetransTable[i].exchContext;
        if (ec)
        {
            //Process Retransmit Table
            //Decrement Throttle timeout by elapsed timeticks
            if (ec->mWRMPThrottleTimeout >= deltaTicks)
            {
                ec->mWRMPThrottleTimeout -= deltaTicks;
            }
            else
            {
                ec->mWRMPThrottleTimeout = 0;
            }
#if defined(WRMP_TICKLESS_DEBUG)
            WeaveLogProgress(ExchangeManager, ""WRMPExpireTicks set mWRMPThrottleTimeout to %u"", RetransTable[i].nextRetransTime);
#endif

            //Decrement Retransmit timeout by elapsed timeticks
            if (RetransTable[i].nextRetransTime >= deltaTicks)
            {
                RetransTable[i].nextRetransTime -= deltaTicks;
            }
            else
            {
                RetransTable[i].nextRetransTime = 0;
            }
#if defined(WRMP_TICKLESS_DEBUG)
            WeaveLogProgress(ExchangeManager, ""WRMPExpireTicks set nextRetransTime to %u"", RetransTable[i].nextRetransTime);
#endif
        } //ec entry is allocated
    }

    // Re-Adjust the base time stamp to the most recent tick boundary

    // Note on math: because we're really multiplying two 16-bit
    // unsigned numbers, we know that the result will fit in a 32-bit
    // unsigned without overflow. Consequently, casting operands to
    // 32-bit, and performing 32-bit multiplication is correct.
    mWRMPTimeStampBase += static_cast<uint64_t>( static_cast<uint32_t>(deltaTicks) * static_cast<uint32_t>(mWRMPTimerInterval));
#if defined(WRMP_TICKLESS_DEBUG)
    WeaveLogProgress(ExchangeManager, ""WRMPExpireTicks mWRMPTimeStampBase to %"" PRIu64, mWRMPTimeStampBase);
#endif
}

/**
 * Handle physical wakeup of system due to WRMP wakeup.
 *
 */
void WeaveExchangeManager::WRMPTimeout(System::Layer* aSystemLayer, void* aAppState,  System::Error aError)
{
    WeaveExchangeManager*   exchangeMgr             = reinterpret_cast<WeaveExchangeManager*>(aAppState);

    VerifyOrDie((aSystemLayer != NULL) && (exchangeMgr != NULL));

#if defined(WRMP_TICKLESS_DEBUG)
    WeaveLogProgress(ExchangeManager, ""WRMPTimeout\\n"");
#endif

    // Make sure all tick counts are sync'd to the current time
    exchangeMgr->WRMPExpireTicks();

    // Execute any actions that are due this tick
    exchangeMgr->WRMPExecuteActions();

    // Calculate next physical wakeup
    exchangeMgr->WRMPStartTimer();
}

/**
 *  Add a Weave message into the retransmission table to be subsequently resent if a corresponding acknowledgment
 *  is not received within the retransmission timeout.
 *
 *  @param[in]    ec        A pointer to the ExchangeContext object.
 *
 *  @param[in]    msgBuf    A pointer to the message buffer holding the Weave message to be retransmitted.
 *
 *  @param[in]    messageId The message identifier of the stored Weave message.
 *
 *  @param[in]    msgCtxt   A pointer to some application specific context object pertaining to this message.
 *
 *  @param[out]   rEntry    A pointer to a pointer of a retransmission table entry added into the table.
 *
 *  @retval  #WEAVE_ERROR_RETRANS_TABLE_FULL If there is no empty slot left in the table for addition.
 *  @retval  #WEAVE_NO_ERROR On success.
 *
 */
WEAVE_ERROR WeaveExchangeManager::AddToRetransTable(ExchangeContext *ec, PacketBuffer *msgBuf, uint32_t messageId, void *msgCtxt, RetransTableEntry **rEntry)
{
    bool added      = false;
    WEAVE_ERROR err = WEAVE_NO_ERROR;

    for (int i = 0; i < WEAVE_CONFIG_WRMP_RETRANS_TABLE_SIZE; i++)
    {
        //Check the exchContext pointer for finding an empty slot in Table
        if (!RetransTable[i].exchContext)
        {
            // Expire any virtual ticks that have expired so all wakeup sources reflect the current time
            WRMPExpireTicks();

            RetransTable[i].exchContext = ec;
            RetransTable[i].msgId = messageId;
            RetransTable[i].msgBuf = msgBuf;
            RetransTable[i].sendCount = 0;
            RetransTable[i].nextRetransTime = GetTickCounterFromTimeDelta(ec->GetCurrentRetransmitTimeout() + System::Timer::GetCurrentEpoch(), mWRMPTimeStampBase);

            RetransTable[i].msgCtxt = msgCtxt;
            *rEntry = &RetransTable[i];
            //Increment the reference count
            ec->AddRef();
            added = true;

            //Check if the timer needs to be started and start it.
            WRMPStartTimer();
            break;
        }
    }

    if (!added)
    {
        WeaveLogError(ExchangeManager, ""RetransTable Already Full"");
        err = WEAVE_ERROR_RETRANS_TABLE_FULL;
    }

    return err;
}

/**
 *  Send the specified entry from the retransmission table.
 *
 *  @param[in]    entry                A pointer to a retransmission table entry object that needs to be sent.
 *
 *  @return  #WEAVE_NO_ERROR On success, else corresponding WEAVE_ERROR returned from SendMessage.
 *
 */
WEAVE_ERROR WeaveExchangeManager::SendFromRetransTable(RetransTableEntry *entry)
{
    WEAVE_ERROR err = WEAVE_NO_ERROR;
    uint16_t msgSendFlags = 0;
    uint8_t     *p = NULL;
    uint32_t    len = 0;
    ExchangeContext *ec = entry->exchContext;

    // To trigger a call to OnSendError, set the number of transmissions so
    // that the next call to WRMPExecuteActions will abort this entry,
    // restart the timer immediately, and ExitNow.

    WEAVE_FAULT_INJECT(FaultInjection::kFault_WRMSendError,
                       entry->sendCount = (ec->mWRMPConfig.mMaxRetrans + 1);
                       entry->nextRetransTime = 0;
                       WRMPStartTimer();
                       ExitNow());

    if (ec)
    {
        msgSendFlags |= kWeaveMessageFlag_RetainBuffer;
        //Locally store the start and length;
        p = entry->msgBuf->Start();
        len = entry->msgBuf->DataLength();

        //Send the message through
        err = MessageLayer->SendMessage(ec->PeerAddr, ec->PeerPort, ec->PeerIntf,
                                        entry->msgBuf,
                                        msgSendFlags);
        //Reset the msgBuf start pointer and data length after sending
        entry->msgBuf->SetStart(p);
        entry->msgBuf->SetDataLength(len);

        //Update the counters
        entry->sendCount++;
    }
    else
    {
        WeaveLogError(ExchangeManager, ""Table entry invalid"");
    }

    VerifyOrExit(err != WEAVE_NO_ERROR, err = WEAVE_NO_ERROR);

    //Any error generated during initial sending is evaluated for criticality which would
    //qualify it to be reportable back to the caller. If it is non-critical then
    //err is set to WEAVE_NO_ERROR.
    if (WeaveMessageLayer::IsSendErrorNonCritical(err))
    {
        WeaveLogError(ExchangeManager, ""Non-crit err %ld sending Weave MsgId:%08"" PRIX32 "" from retrans table"",
                      long(err), entry->msgId);
        err = WEAVE_NO_ERROR;
    }
    else
    {
        //Remove from table
        WeaveLogError(ExchangeManager, ""Crit-err %ld when sending Weave MsgId:%08"" PRIX32 "", send tries: %d"",
                long(err), entry->msgId, entry->sendCount);

        ClearRetransmitTable(*entry);
    }

exit:
    return err;
}

/**
 *  Clear entries matching a specified ExchangeContext.
 *
 *  @param[in]    ec    A pointer to the ExchangeContext object.
 *
 */
void WeaveExchangeManager::ClearRetransmitTable(ExchangeContext *ec)
{
    for (int i = 0; i < WEAVE_CONFIG_WRMP_RETRANS_TABLE_SIZE; i++)
    {
        if (RetransTable[i].exchContext == ec)
        {
            //Clear the retransmit table entry.
            ClearRetransmitTable(RetransTable[i]);
        }
    }
}

/**
 *  Clear an entry in the retransmission table.
 *
 *  @param[in]    rEntry   A reference to the RetransTableEntry object.
 *
 */
void WeaveExchangeManager::ClearRetransmitTable(RetransTableEntry &rEntry)
{
    if (rEntry.exchContext)
    {
        // Expire any virtual ticks that have expired so all wakeup sources reflect the current time
        WRMPExpireTicks();

        rEntry.exchContext->Release();
        rEntry.exchContext = NULL;

        if (rEntry.msgBuf)
        {
            PacketBuffer::Free(rEntry.msgBuf);
            rEntry.msgBuf = NULL;
        }

        // Clear all other fields
        memset(&rEntry, 0, sizeof(rEntry));

        // Schedule next physical wakeup
        WRMPStartTimer();

    }
}

/**
 *  Fail entries matching a specified ExchangeContext.
 *
 *  @param[in]    ec    A pointer to the ExchangeContext object.
 *
 *  @param[in]    err   The error for failing table entries.
 *
 */
void WeaveExchangeManager::FailRetransmitTableEntries(ExchangeContext *ec, WEAVE_ERROR err)
{
    for (int i = 0; i < WEAVE_CONFIG_WRMP_RETRANS_TABLE_SIZE; i++)
    {
        if (RetransTable[i].exchContext == ec)
        {
            void *msgCtxt = RetransTable[i].msgCtxt;

            // Remove the entry from the retransmission table.
            ClearRetransmitTable(RetransTable[i]);

            // Application callback OnSendError.
            if (ec->OnSendError)
                ec->OnSendError(ec, err, msgCtxt);
        }
    }
}

/**
* Iterate through active exchange contexts and retrans table entries.
* Determine how many WRMP ticks we need to sleep before we need to physically
* wake the CPU to perform an action.  Set a timer to go off when we
* next need to wake the system.
*
*/
void WeaveExchangeManager::WRMPStartTimer()
{
    WEAVE_ERROR res                   = WEAVE_NO_ERROR;
    uint32_t nextWakeTime             = UINT32_MAX;
    bool foundWake                    = false;
    ExchangeContext *ec               = NULL;

    // Stop any active timers, we are about to set a new timer
    // based on the most up to date contents of the retrans
    // table
    WRMPStopTimer();

    // When do we need to next wake up to send an ACK?
    ec = (ExchangeContext *)ContextPool;

    for (int i = 0; i < WEAVE_CONFIG_MAX_EXCHANGE_CONTEXTS; i++, ec++)
    {
        if (ec->ExchangeMgr != NULL && ec->IsAckPending() && ec->mWRMPNextAckTime < nextWakeTime) {
            nextWakeTime = ec->mWRMPNextAckTime;
            foundWake = true;
#if defined(WRMP_TICKLESS_DEBUG)
            WeaveLogProgress(ExchangeManager, ""WRMPStartTimer next ACK time %u"", nextWakeTime);
#endif
        }
    }

    for (int i = 0; i < WEAVE_CONFIG_WRMP_RETRANS_TABLE_SIZE; i++)
    {
        ec = RetransTable[i].exchContext;
        if (ec)
        {
            // When do we need to next wake up for throttle retransmission?
            if (ec->mWRMPThrottleTimeout != 0 && ec->mWRMPThrottleTimeout < nextWakeTime) {
                nextWakeTime = ec->mWRMPThrottleTimeout;
                foundWake = true;
#if defined(WRMP_TICKLESS_DEBUG)
                WeaveLogProgress(ExchangeManager, ""WRMPStartTimer throttle timeout %u"", nextWakeTime);
#endif
            }

            // When do we need to next wake up for WRMP retransmit?
            if (RetransTable[i].nextRetransTime < nextWakeTime) {
                nextWakeTime = RetransTable[i].nextRetransTime;
                foundWake = true;
#if defined(WRMP_TICKLESS_DEBUG)
                WeaveLogProgress(ExchangeManager, ""WRMPStartTimer RetransTime %u"", nextWakeTime);
#endif
            }
        }
    }

    if (foundWake) {
        // Set timer for next tick boundary - subtract the elapsed time from the current tick
        int32_t timerArmValue = nextWakeTime * mWRMPTimerInterval - (System::Timer::GetCurrentEpoch() - mWRMPTimeStampBase);
#if defined(WRMP_TICKLESS_DEBUG)
        WeaveLogProgress(ExchangeManager, ""Setting WRMP timer for %d ms (%u %"" PRIu64 "" %"" PRIu64 "")"",
                timerArmValue,
                nextWakeTime, System::Timer::GetCurrentEpoch(), mWRMPTimeStampBase);
#endif
        // If the tick boundary has expired in the past (delayed processing of event due to other system activity),
        // expire the timer immediately
        if (timerArmValue < 0) {
            timerArmValue = 0;
        }
        res = MessageLayer->SystemLayer->StartTimer((uint32_t)timerArmValue, WRMPTimeout, this);

        VerifyOrDieWithMsg(res == WEAVE_NO_ERROR, ExchangeManager, ""Cannot start WRMPTimeout\\n"");
#if defined(WRMP_TICKLESS_DEBUG)
    } else {
        WeaveLogProgress(ExchangeManager, ""Not setting WRMP timeout at %"" PRIu64, System::Timer::GetCurrentEpoch());
#endif
    }

    TicklessDebugDumpRetransTable(""WRMPStartTimer Dumping RetransTable entries after setting wakeup times"");

}

void WeaveExchangeManager::WRMPStopTimer()
{
    MessageLayer->SystemLayer->CancelTimer(WRMPTimeout, this);
}
#endif // WEAVE_CONFIG_ENABLE_RELIABLE_MESSAGING

/**
 *  Initialize the shared pool of Bindings.
 *
 */
void WeaveExchangeManager::InitBindingPool(void)
{
    memset(BindingPool, 0, sizeof(BindingPool));
    for (size_t i = 0; i < WEAVE_CONFIG_MAX_BINDINGS; ++i)
    {
        BindingPool[i].mState = Binding::kState_NotAllocated;
        BindingPool[i].mExchangeManager = this;
    }
    mBindingsInUse = 0;
}

/**
 *  Allocate a new Binding
 *
 *  @return  A pointer to the newly allocated Binding, or NULL if the pool has been exhausted
 *
 */
Binding * WeaveExchangeManager::AllocBinding(void)
{
    Binding * pResult = NULL;

    WEAVE_FAULT_INJECT(FaultInjection::kFault_AllocBinding,
                           return NULL);

    for (size_t i = 0; i < WEAVE_CONFIG_MAX_BINDINGS; ++i)
    {
        if (Binding::kState_NotAllocated == BindingPool[i].mState)
        {
            pResult = &BindingPool[i];
            ++mBindingsInUse;
            SYSTEM_STATS_INCREMENT(nl::Weave::System::Stats::kExchangeMgr_NumBindings);
            break;
        }
    }

    return pResult;
}

/**
 *  Deallocate the binding object so it could be reused later
 *
 *  @param[in]  binding         A pointer to the binding object to be deallocated. The object
 *                              must be previously allocated from this #WeaveExchangeManager.
 *
 */
void WeaveExchangeManager::FreeBinding(Binding * binding)
{
    binding->mState = Binding::kState_NotAllocated;
    --mBindingsInUse;
    SYSTEM_STATS_DECREMENT(nl::Weave::System::Stats::kExchangeMgr_NumBindings);
}

/**
 *  Allocate a new Binding with the arguments supplied
 *
 *  @param[in]  eventCallback   A function pointer to be used for event callback
 *  @param[in]  appState        A pointer to some context which would be carried in event callback later
 *
 *  @return  A pointer to the newly allocated Binding, or NULL if the pool has been exhausted
 *
 */
Binding * WeaveExchangeManager::NewBinding(Binding::EventCallback eventCallback, void *appState)
{
    Binding * pResult = AllocBinding();
    if (NULL != pResult)
    {
        pResult->Init(appState, eventCallback);
    }
    return pResult;
}

/**
 *  Get an ID suitable for identifying a binding in log messages.
 *
 *  @param[in]  binding         A pointer to a Binding object
 *
 *  @return                     An unsigned integer identifying the binding
 *
 */
uint16_t WeaveExchangeManager::GetBindingLogId(const Binding * const binding) const
{
    // note that the result of pointer subtraction should be ptrdiff_t
    return static_cast<uint16_t>(binding - BindingPool);
}

} // namespace nl
} // namespace Weave
",16374,True,2913.3968346302863,median
"// Copyright (c) 2020 Run Jump Labs LLC.  All right reserved. 
// This code is licensed under MIT license (see license.txt for details)
#include <stdlib.h>

#include ""Arduino.h""
#include ""dreammakerfx.h""


fx_pedal pedal;

/************************************************************************
 *  Initialization
 ***********************************************************************/

/**
 * @brief      Initializes the pedal object with default debug level (just warnings and errors)
 */
void fx_pedal::init(void) {
  init(MSG_WARN, false);
}


/**
 * @brief      Initializes the pedal object with user defined debug level
 *
 * @param[in]  debug_level  The debug level to display (MSG_DEBUG, MSG_INFO, MSG_WARN, MSG_ERROR)
 */
void fx_pedal::init(DEBUG_MSG_LEVEL debug_level) {
  init(debug_level, false);
}


[[deprecated(""Replaced by init(DEBUG_MSG_LEVEL debug_level), which has an improved interface"")]]
void fx_pedal::init(bool debug_enable) {
  if (debug_enable) {
    init(MSG_INFO);    
  } else {
    init();
  }
}

[[deprecated(""Replaced by init(DEBUG_MSG_LEVEL debug_level), which has an improved interface"")]]
void fx_pedal::init(bool debug_enable, bool dsp_telem) {
  if (dsp_telem) {
    init(MSG_DEBUG);    
  } else {

  }
}

/**
 * @brief      Initializes the pedal object with used defined debug level, bypasses DSP reset
 *
 * @param[in]  debug_level   The debug level to display (MSG_DEBUG, MSG_INFO, MSG_WARN, MSG_ERROR)
 * @param[in]  dsp_no_reset  The dsp no reset (set to true to bypass reset)
 */
void fx_pedal::init(DEBUG_MSG_LEVEL debug_level, bool dsp_no_reset) {

  dmfx_debug_level = debug_level;
  dmfx_debug_no_reset = debug_no_reset = dsp_no_reset;

  #if defined (DM_FX)
    // Setup LEDs
    pinMode(PIN_FOOTSW_LED_1, OUTPUT);
    pinMode(PIN_FOOTSW_LED_2, OUTPUT);
    pinMode(PIN_ARD_LED, OUTPUT);
    //pinMode(PIN_USR_PB, INPUT);
    //attachInterrupt(digitalPinToInterrupt(PIN_USR_PB), user_pb_pressed, FALLING);

  #elif defined (DM_FX_TWO)
    pinMode(PIN_ARD_LED_G, OUTPUT);
    pinMode(PIN_ARD_LED_Y, OUTPUT);
    digitalWrite(PIN_ARD_LED_G, HIGH);
    digitalWrite(PIN_ARD_LED_Y, LOW);
  #endif 

  // Initialize hardware pins
  pinMode(PIN_FOOTSW_1, INPUT);
  pinMode(PIN_FOOTSW_2, INPUT);

  bool left = digitalRead(PIN_FOOTSW_LEFT);
  bool right = digitalRead(PIN_FOOTSW_RIGHT);

  // if both buttons held, reboot into bootloader
  if (!left && ! right) {
    for (int i=0;i<10;i++) {
      turn_on_left_footsw_led();
      turn_off_right_footsw_led();;
      delay(100);
      turn_off_left_footsw_led();;
      turn_on_right_footsw_led();;
      delay(100);
    }
    reset_into_bootloader();
  }

  // Initialize the RGB LEDs if present

  rgb_leds_init();
  turn_on_left_footsw_led_rgb(0, 0, 200);
  turn_on_center_footsw_led_rgb(0, 0, 200);
  turn_on_right_footsw_led_rgb(0, 0, 200);

  int now = millis();
  bool timeout = false;
  while ( !Serial && !timeout) {
    if (millis() > now + 2000) {
      timeout = true;
    }
  }

    // Set up telemetry link to SHARC
  Serial1.begin(115200);
  // Set up Serial USB link
  Serial.begin(115200);
  Serial.print(""DreamMaker FX By Run Jump Labs"");
  Serial.print("" (version: "");
  String package_str = String(API_VERSION);
  package_str.replace(""0"",""."");
  Serial.print(package_str);    
  Serial.println("")"");

  #if defined (DM_FX)
    // Initialize the WM8731
    wm8731_initialize();
  #elif defined (DM_FX_TWO)
    // Initialize SigmaDSP
    adau1761_initialize();
  #endif 


  turn_on_left_footsw_led_rgb(100, 0, 100);
  turn_on_center_footsw_led_rgb(100, 0, 100);
  turn_on_right_footsw_led_rgb(100, 0, 100);


  attachInterrupt(digitalPinToInterrupt(PIN_FOOTSW_1), footswitch_right_pressed_isr, FALLING);
  attachInterrupt(digitalPinToInterrupt(PIN_FOOTSW_2), footswitch_left_pressed_isr, FALLING);
  
  if (!dsp_no_reset) {
    // Reset the DSP
    DEBUG_MSG(""Resetting DSP"", MSG_DEBUG);
    dsp_reset();
  } else {
    // If we're not resetting DSP, at least make sure it's not still using the SPI port to boot
    DEBUG_MSG(""Bypassing DSP reset"", MSG_DEBUG);
    wait_for_dsp_spi_flash_access_to_cease();
  }
  
  turn_on_left_footsw_led_rgb(100, 100, 0);
  turn_on_center_footsw_led_rgb(100, 100, 0);
  turn_on_right_footsw_led_rgb(100, 100, 0);



  




  // Wait for the DSP to boot and report firmware
  wait_for_dsp_to_boot();

  turn_on_left_footsw_led_rgb(100, 100, 100);
  turn_on_center_footsw_led_rgb(100, 100, 100);
  turn_on_right_footsw_led_rgb(100, 100, 100);

  /**
   * Next check to see if we need to do a firmware update
   */
  bool firmware_match = true;
  if (dsp_status.firmware_ver != API_VERSION) {
    firmware_match = false;
  }
  if (!firmware_match) {
    Serial.println("" The Arduino package version does not match the DSP firmware version, updating firmware..."");
    dsp_update_firmware_image();
    dsp_reset();
    wait_for_dsp_spi_flash_access_to_cease();
    wait_for_dsp_to_boot();
  }

  // Wait for the DSP to be ready
  wait_for_dsp_to_be_ready();

  turn_off_left_footsw_led();
  turn_off_center_footsw_led();
  turn_off_right_footsw_led();

  initialized = true;


}




/******************************************************************************
 *  DSP SPI Protocol
 *****************************************************************************/

#ifndef DOXYGEN_SHOULD_SKIP_THIS

/**
 * @brief      Transmits the control routing stack to the DSP
 */
void  fx_pedal::spi_transmit_control_routing_stack(void) {

  DEBUG_MSG(""Starting"", MSG_DEBUG);

  uint16_t * routing_block = (uint16_t *) malloc(total_control_routes*8*sizeof(uint16_t));
  if (routing_block == NULL) {
      DEBUG_MSG(""Could not allocate space for routing block"", MSG_ERROR);
      display_error_status(ERROR_INTERNAL);    
  }

  // serialize routing data
  int indx = 0;
  routing_block[indx++] = HEADER_CONTROL_ROUTING_BLOCK;
  for (int i=0;i<total_control_routes;i++) {
    routing_block[indx++] = (control_routing_stack[i].src_id << 8) | control_routing_stack[i].src_node_indx;
    routing_block[indx++] = (control_routing_stack[i].dest_id << 8) | control_routing_stack[i].dest_node_indx;
    routing_block[indx++] = control_routing_stack[i].src_param_id; 
    routing_block[indx++] = control_routing_stack[i].dest_param_id; 
    float scale = control_routing_stack[i].scale;
    float offset = control_routing_stack[i].offset;
    uint32_t part_32 = * (uint32_t *) &scale;
    routing_block[indx++] = (uint16_t) (part_32 >> 16);
    routing_block[indx++] = (uint16_t) (part_32 & 0xFFFF);
    part_32 = * (uint32_t *) &offset;
    routing_block[indx++] = (uint16_t) (part_32 >> 16);
    routing_block[indx++] = (uint16_t) (part_32 & 0xFFFF);
    routing_block[indx++] = (uint16_t) control_routing_stack[i].type;

  }

  // Copy to SPI transmit fifo
  spi_fifo_insert_block(routing_block, indx);

  free (routing_block);

  DEBUG_MSG(""Complete"", MSG_DEBUG);

}

/**
 * @brief  Transmits the routing stack to the DSP
 */
void  fx_pedal::spi_transmit_audio_routing_stack(void) {

  DEBUG_MSG(""Starting"", MSG_DEBUG);

  uint16_t * routing_block = (uint16_t *) malloc(total_audio_routes*2*sizeof(uint16_t));
  if (routing_block == NULL) {
      DEBUG_MSG(""Could not allocate space for routing block"", MSG_ERROR);
      display_error_status(ERROR_INTERNAL);    
  }
 
  // serialize routing data
  int indx = 0;
  routing_block[indx++] = HEADER_AUDIO_ROUTING_BLOCK;
  for (int i=0;i<total_audio_routes;i++) {
    routing_block[indx++] = (audio_routing_stack[i].src_id << 8) | audio_routing_stack[i].src_node_indx;
    routing_block[indx++] = (audio_routing_stack[i].dest_id << 8) | audio_routing_stack[i].dest_node_indx;
  }

  // Copy to SPI transmit fifo
  spi_fifo_insert_block(routing_block, indx);

  DEBUG_MSG(""Complete"", MSG_DEBUG);


}


/**
 * @brief  Transmits the instance stack to the DSP
 */
void fx_pedal::spi_transmit_instance_stack(void) {

  DEBUG_MSG(""Starting"", MSG_DEBUG);

  uint16_t * spi_instance_block = (uint16_t *) malloc((total_instances + 1)*sizeof(uint16_t));
  if (spi_instance_block == NULL) {
      DEBUG_MSG(""Could not allocate space for routing block"", MSG_ERROR);
      display_error_status(ERROR_INTERNAL);    
  }

  // serialize instance data
  int indx = 0;
  spi_instance_block[indx++] = HEADER_INSTANCE_BLOCK;
  for (int i=0;i<total_instances;i++) {
    spi_instance_block[indx++] = (instance_stack[i].type << 8) | instance_stack[i].id; 
  }

  // Copy to SPI transmit fifo
  spi_fifo_insert_block(spi_instance_block, indx);

  free(spi_instance_block);

  DEBUG_MSG(""Complete"", MSG_DEBUG);

}

/**
 * @brief      Transmits an updated parameter to the DSP
 *
 * @param[in]  instance_type  The instance type
 * @param[in]  instance_id    The instance identifier
 * @param[in]  param_type     The parameter type
 * @param[in]  param_id       The parameter identifier
 * @param      value          Pointer to the new value
 */
void fx_pedal::spi_transmit_param(EFFECT_TYPE instance_type, uint32_t instance_id, PARAM_TYPES param_type, uint8_t param_id, void * value) {
  
  DEBUG_MSG(""Starting"", MSG_DEBUG);  

  static uint16_t param_block[7] = {HEADER_SINGLE_PARAMETER};

  uint16_t part_16;
  uint32_t part_32;

  param_block[1] = (uint16_t) instance_type;
  param_block[2] = (uint16_t) instance_id;
  param_block[3] = (uint16_t) param_type;
  param_block[4] = param_id;

  if (param_type == T_BOOL) {
    part_16 = * (uint8_t *) value;
    param_block[5] = part_16;
  }
  else if (param_type == T_INT16) {
    param_block[5] = (uint16_t) (* (uint16_t *) value);
  }
  else if (param_type == T_INT32) {
    param_block[5] = (uint16_t)((* (uint32_t *) value) >> 16);
    param_block[6] = (uint16_t)((* (uint32_t *) value) & 0xFFFF);
  }
  else if (param_type == T_FLOAT) {
    part_32 = * (uint32_t *) value;
    param_block[5] = (uint16_t) (part_32 >> 16);
    param_block[6] = (uint16_t) (part_32 & 0xFFFF);
  }     

  // Add to transmit FIFO
  spi_fifo_insert_block(param_block, sizeof(param_block)/sizeof(uint16_t));

  DEBUG_MSG(""Complete"", MSG_DEBUG);  

}

/**
 * @brief   Set pedal bypass state
 */
void fx_pedal::spi_transmit_bypass(uint16_t bypass_state) {

  DEBUG_MSG(""Starting"", MSG_DEBUG);  
  uint16_t param_block[2];

  param_block[0] = HEADER_SET_BYPASS;
  param_block[1] = bypass_state; 
 
  // Copy to SPI transmit fifo
  spi_fifo_insert_block(param_block, 2);

  DEBUG_MSG(""Complete"", MSG_DEBUG);  

}

void fx_pedal::spi_get_status(void) {

  uint16_t param_block[1];
  param_block[0] = HEADER_GET_STATUS;

  spi_fifo_insert_block(param_block, SPI_DSP_STAT_FRAME_SIZE);
  
}

/**
 * @brief   Transmits one set of parameters to the DSP
 */
void fx_pedal::spi_transmit_params(uint16_t node_index) {

  DEBUG_MSG(""Starting"", MSG_DEBUG);  
  
  uint16_t param_block[MAX_PARMS_PER_FX];
  uint16_t size;

  if (!node_index) {
    DEBUG_MSG(""This instance is not part of a canvas"", MSG_ERROR);  
    display_error_status(ERROR_CODE_ILLEGAL_ROUTING);   
  }

  fx_effect * effect = (fx_effect *) instance_stack[node_index].address;
  
  if (effect == NULL) {
    DEBUG_MSG(""NULL effect encountered"", MSG_ERROR);  
    display_error_status(ERROR_CODE_ILLEGAL_ROUTING);   
  }

  #if 0
    Serial.println(""Generating parameter transmit block"");
  #endif 

  size = 0;
  param_block[0] = HEADER_PARAMETER_BLOCK;
  param_block[1] = (uint16_t) instance_stack[node_index].type;  // instance type
  param_block[2] = (uint16_t) instance_stack[node_index].id;    // instance id
  effect->serialize_params(&param_block[3], &size);
  size += 3;

  // Copy to SPI transmit fifo
  spi_fifo_insert_block(param_block, size);

  DEBUG_MSG(""Complete"", MSG_DEBUG);  

}

/**
 * @brief   Transmits all initial parameters to the DSP
 */
void fx_pedal::spi_transmit_all_params(void) {

  DEBUG_MSG(""Starting"", MSG_DEBUG);  

  uint16_t param_block[MAX_PARMS_PER_FX];
  uint16_t size;

  param_block[0] = HEADER_PARAMETER_BLOCK;

  for (int i=1;i<total_instances;i++) {
    size = 0;

    fx_effect * effect = (fx_effect *) instance_stack[i].address;
    
    if (effect == NULL) {
      DEBUG_MSG(""NULL effect encountered"", MSG_ERROR);  
      display_error_status(ERROR_CODE_ILLEGAL_ROUTING);  
    } else {
      param_block[1] = (uint16_t) instance_stack[i].type;  // instance type
      param_block[2] = (uint16_t) instance_stack[i].id;    // instance id
      effect->serialize_params(&param_block[3], &size);
      size += 3;

      // Copy to SPI transmit block
      spi_fifo_insert_block(param_block, size);

      if (dmfx_debug_level == MSG_DEBUG) {
        Serial.print(""  Type: "");
        Serial.print(instance_stack[i].type);
        Serial.print("", ID: "");
        Serial.print(instance_stack[i].id);
        Serial.print("", Size: "");
        Serial.println(size);
        #if 0
          for (int i=0;i<size;i++) {
            Serial.print(""    0x"");
            Serial.println(param_block[i], HEX);
          }
        #endif 
      }

    }
  }

  DEBUG_MSG(""Complete"", MSG_DEBUG);  
}




/**
 * @brief Check if any SPI transactions need to happen
 */
void  fx_pedal::spi_service(void) {
  spi_transmit_buffered_frames(false);
}

#endif // DOXYGEN_SHOULD_SKIP_THIS








/******************************************************************************
 *  Audio and control routing
 *****************************************************************************/


/**
 * @brief      Adds a new audio route
 *
 * @param[in]  src_id          The source identifier
 * @param[in]  src_node_indx   The source node indx
 * @param[in]  dest_id         The destination identifier
 * @param[in]  dest_node_indx  The destination node indx
 *
 * @return     true if successful, false if not
 */
bool  fx_pedal::add_audio_route_to_stack(uint8_t src_id, 
                                          uint8_t src_node_indx, 
                                          uint8_t dest_id, 
                                          uint8_t dest_node_indx) {
  audio_routing_stack[total_audio_routes].src_id = src_id;
  audio_routing_stack[total_audio_routes].src_node_indx = src_node_indx;
  audio_routing_stack[total_audio_routes].dest_id = dest_id;
  audio_routing_stack[total_audio_routes].dest_node_indx = dest_node_indx;
  total_audio_routes++;

  return true;
}

/**
 * @brief      Adds a control route 
 *
 * @param[in]  src_id          The source identifier
 * @param[in]  src_node_indx   The source node indx
 * @param[in]  dest_id         The destination identifier
 * @param[in]  dest_node_indx  The destination node indx
 *
 * @return     true if successful, false if not
 */
bool  fx_pedal::add_control_route_to_stack(uint8_t src_id, 
                                            uint8_t src_node_indx, 
                                            uint8_t src_param_id, 
                                            uint8_t dest_id,                                             
                                            uint8_t dest_node_indx,
                                            uint8_t dest_param_id, 
                                            float scale,
                                            float offset,
                                            CTRL_NODE_TYPE type) {

  control_routing_stack[total_control_routes].src_id = src_id;
  control_routing_stack[total_control_routes].src_node_indx = src_node_indx;
  control_routing_stack[total_control_routes].src_param_id = src_param_id;
  control_routing_stack[total_control_routes].dest_id = dest_id;
  control_routing_stack[total_control_routes].dest_node_indx = dest_node_indx;
  control_routing_stack[total_control_routes].dest_param_id = dest_param_id;
  control_routing_stack[total_control_routes].scale = scale;
  control_routing_stack[total_control_routes].offset = offset;
  control_routing_stack[total_control_routes].type = type;
  
  total_control_routes++;

  return true;  
}


/**
 * @brief      Routes a source node (output) to a destination mode (input)
 *
 * @param      src   The source / output
 * @param      dest  The destination / input
 *
 * @return     True is successful, false if not
 */
bool fx_pedal::route_audio(fx_audio_node * src, fx_audio_node * dest) {

  bool local_debug = false;
  // Ensure inputs and outputs are valid
  if (src->node_direction != NODE_OUT || dest->node_direction != NODE_IN) {
    DEBUG_MSG(""Source node is not an output, or destination node is not an input"", MSG_ERROR);
    display_error_status(ERROR_CODE_ILLEGAL_ROUTING);
    return false;
  }

  uint8_t src_id, dest_id;

  // Set to false in case we bail mid-way through due to error
  valid_audio_routes = false;

  // Check to see if inputs and outputs are in our stack, and add if not
  if (src->parent_effect != NULL) {
    bool found = false;
    for (int i=0;i<total_instances;i++) {
      if ((void *) src->parent_effect == instance_stack[i].address) {
        found = true;
        src_id = i;
      }
    }
    if (!found) {
      instance_stack[total_instances].address = src->parent_effect; 
      instance_stack[total_instances].type = src->parent_effect->get_type(); 
      instance_stack[total_instances].id = total_instances; 
      src_id = total_instances;      

      #if 0
        Serial.print(""route_audio(): Adding new (source) instance type: "");
        Serial.print(instance_stack[total_instances].type);
        Serial.print("", address: "");
        Serial.println((uint32_t) instance_stack[total_instances].address, HEX);
      #endif


      // Set instance ID in this effect instance too
      src->parent_effect->instance_id = total_instances;

      total_instances++;

    }
  } else if (src->parent_canvas != NULL) {
    src_id = 0;
  }

  if (dest->parent_effect != NULL) {
    bool found = false;
    for (int i=0;i<total_instances;i++) {
      if ((void *) dest->parent_effect == instance_stack[i].address) {
        found = true;
        dest_id = i;
      }
    }
    if (!found) {
      instance_stack[total_instances].address = dest->parent_effect; 
      instance_stack[total_instances].type = dest->parent_effect->get_type(); 
      instance_stack[total_instances].id = total_instances; 
      dest_id = total_instances;

      #if 0
        Serial.print(""route_audio(): Adding new (dest) instance type: "");
        Serial.print(instance_stack[total_instances].type);
        Serial.print("", address: "");
        Serial.println((uint32_t) instance_stack[total_instances].address, HEX);
      #endif

      // Set instance ID in this effect instance too
      dest->parent_effect->instance_id = total_instances;

      total_instances++;
    }
  } else if (dest->parent_canvas != NULL) {
    dest_id = 0;
  }

  // Add routes to our routing table
  uint8_t src_node_indx, dest_node_indx;
  bool res;

  // Look up source node
  if (src->parent_effect != NULL) {
    res = src->parent_effect->get_audio_node_index(src, &src_node_indx);
    if (!res) {
      DEBUG_MSG(""Couldn't find this source node in the effect!"", MSG_ERROR);
      display_error_status(ERROR_CODE_ILLEGAL_ROUTING);
      return false;
    }
  }
  else if (src->parent_canvas != NULL) {
    res = src->parent_canvas->get_audio_node_index(src, &src_node_indx);
    if (!res) {
      DEBUG_MSG(""Couldn't find this source node in the canvas!"", MSG_ERROR);
      display_error_status(ERROR_CODE_ILLEGAL_ROUTING);
      return false;
    }
  }

  // Look up destination node
  if (dest->parent_effect != NULL) {
    res = dest->parent_effect->get_audio_node_index(dest, &dest_node_indx);
    if (!res) {
      DEBUG_MSG(""Couldn't find this destination node in the effect!"", MSG_ERROR);
      display_error_status(ERROR_CODE_ILLEGAL_ROUTING);
      return false;
    }
  }
  else if (dest->parent_canvas != NULL) {
    res = dest->parent_canvas->get_audio_node_index(dest, &dest_node_indx);
    if (!res) {
      DEBUG_MSG(""Couldn't find this destination node in the canvas!"", MSG_ERROR);
      display_error_status(ERROR_CODE_ILLEGAL_ROUTING);
      return false;
    }
  }

  // Set both nodes to connected
  src->connected = true;
  dest->connected = true;

  // Add route to routing table
  add_audio_route_to_stack(src_id, src_node_indx, dest_id, dest_node_indx);

  // Check routing table for any outputs that are being written to twice
  for (int i=0;i<total_audio_routes;i++) {
    for (int j=0;j<total_audio_routes;j++) {
      if (i != j) {
        if ((audio_routing_stack[i].dest_id == audio_routing_stack[j].dest_id) && 
            (audio_routing_stack[i].dest_node_indx == audio_routing_stack[j].dest_node_indx)) {
          DEBUG_MSG(""Two different effects writing to same audio node"", MSG_ERROR);
          return false;
        }
      }
    }
  }

  // Happy days, we made it
  valid_audio_routes = true;
  return true;
}


/**
 * @brief      Route a control source node (output) to a destination mode (input)
 *
 * @param      src   The source node (should be an output)
 * @param      dest  The destination node (should be an input)
 *
 * @return     True is successful, false if not
 */
bool fx_pedal::route_control(fx_control_node * src, fx_control_node * dest) {
  route_control(src, dest, 1.0, 0.0);
}

/**
 * @brief      Route a control source node (output) to a destination mode (input)
 *
 * @param      src     The source node (should be an output)
 * @param      dest    The destination node (should be an input)
 * @param[in]  scale   The scale to apply to the control value
 * @param[in]  offset  The offset to apply to the control value
 *
 * @return     True is successful, false if not
 */
bool fx_pedal::route_control(fx_control_node * src, fx_control_node * dest, float scale, float offset) {

  // Set to false in case we bail mid-way through due to error
  valid_control_routes = false;

// Ensure inputs and outputs are valid
  if (src->node_direction != NODE_OUT || dest->node_direction != NODE_IN) {
    DEBUG_MSG(""Source must be output, dest must be input"", MSG_ERROR);
    display_error_status(ERROR_CODE_ILLEGAL_ROUTING);
    return false;
  }

  uint8_t src_id, dest_id;

  // Check to see if inputs and outputs are in our stack, and add if not
  if (src->parent_effect != NULL) {
    bool found = false;
    for (int i=0;i<total_instances;i++) {
      if ((void *) src->parent_effect == instance_stack[i].address) {
        found = true;
        src_id = i;
      }
    }
    if (!found) {
      instance_stack[total_instances].address = src->parent_effect; 
      instance_stack[total_instances].type = src->parent_effect->get_type(); 
      instance_stack[total_instances].id = total_instances; 
      src_id = total_instances;
      src->parent_effect->instance_id = total_instances;
      total_instances++;

      #if 0
        Serial.println(src->parent_effect->get_name());
      #endif
    }
  } else if (src->parent_canvas != NULL) {
    src_id = 0;
  }

  if (dest->parent_effect != NULL) {
    bool found = false;
    for (int i=0;i<total_instances;i++) {
      if ((void *) dest->parent_effect == instance_stack[i].address) {
        found = true;
        dest_id = i;
      }
    }
    if (!found) {
      instance_stack[total_instances].address = dest->parent_effect; 
      instance_stack[total_instances].type = dest->parent_effect->get_type(); 
      instance_stack[total_instances].id = total_instances; 
      dest_id = total_instances;
      dest->parent_effect->instance_id = total_instances;
      total_instances++;
    }
  } else if (src->parent_canvas != NULL) {
    dest_id = 0;
  }

  // Make sure controllers are compatible
  if (dest->node_type != src->node_type) {
    DEBUG_MSG(""Trying to connect incompatible controls"", MSG_ERROR);
    return false;
  }

  // Add routes to our routing table
  uint8_t src_node_indx, dest_node_indx;
  bool res;

  // Look up source node
  if (src->parent_effect != NULL) {
    res = src->parent_effect->get_control_node_index(src, &src_node_indx);
    if (!res) {
      DEBUG_MSG(""Couldn't find the source node in an effect"", MSG_ERROR);
      display_error_status(ERROR_CODE_ILLEGAL_ROUTING);
      return false;
    }
  }
  else if (src->parent_canvas != NULL) {
    if (src->parent_canvas)
    res = src->parent_canvas->get_control_node_index(src, &src_node_indx);
    if (!res) {
      DEBUG_MSG(""Couldn't find the source node in the canvas"", MSG_ERROR);
      display_error_status(ERROR_CODE_ILLEGAL_ROUTING);
      return false;
    }
  }

  // Look up destination node
  if (dest->parent_effect != NULL) {
    res = dest->parent_effect->get_control_node_index(dest, &dest_node_indx);
    if (!res) {
      DEBUG_MSG(""Couldn't find the dest node in an effect"", MSG_ERROR);
      display_error_status(ERROR_CODE_ILLEGAL_ROUTING);
      return false;
    }
  }
  else if (dest->parent_canvas != NULL) {
    if (dest->parent_canvas)
    res = dest->parent_canvas->get_control_node_index(dest, &dest_node_indx);
    if (!res) {
      DEBUG_MSG(""Couldn't find the dest node in the canvas"", MSG_ERROR);
      display_error_status(ERROR_CODE_ILLEGAL_ROUTING);
      return false;
    }
  }

  // Set both nodes to connected
  src->connected = true;
  dest->connected = true;

  // Add route to routing table
  add_control_route_to_stack(src_id, src_node_indx, src->param_id, dest_id, dest_node_indx, dest->param_id, scale, offset, dest->node_type);

  // Check routing table for any outputs that are being written to twice

  for (int i=0;i<total_control_routes;i++) {
    for (int j=0;j<total_control_routes;j++) {
      if (i != j) {
        if ((control_routing_stack[i].dest_id == control_routing_stack[j].dest_id) && 
            (control_routing_stack[i].dest_node_indx == control_routing_stack[j].dest_node_indx)) {
          DEBUG_MSG(""Two different effects writing to same control node"", MSG_ERROR);
          return false;
        }
      }
    }
  }

  // Happy days, we made it
  valid_control_routes = true;
  return true;

}


/**
 * @brief      Set one of the footswitches to be a bypass button.  
 * 
 * This function will also set the corresponding LED to turn on and off when bypass is 
 * disabled / enabled.
 *
 * @param[in]  footswitch  The footswitch (FOOTSWITCH_RIGHT, FOOTSWITCH_LEFT)
 */
void fx_pedal::add_bypass_button(FOOTSWITCH footswitch) {
  bypass_control_enabled = true;
  pedal.bypassed = true;
  bypass_footswitch = footswitch;
}

/**
 * @brief      Set one of the footswitches to be a tap tempo / length button
 *
 * @param[in]  footswitch        The footswitch (FOOTSWITCH_RIGHT, FOOTSWITCH_LEFT, FOOTSWITCH_BOTH)
 * @param[in]  enable_led_flash  Set the corresponding LED to flash at tempo rate
 */
void fx_pedal::add_tap_interval_button(FOOTSWITCH footswitch, bool enable_led_flash) {
  tap_control_enabled = true;
  if (bypass_footswitch == footswitch) {
    DEBUG_MSG(""Attempting to add tap interval to footswitch already used for bypass"", MSG_ERROR);
    return;
  }

  tap_led_flash = enable_led_flash;
  tap_footswitch = footswitch;
  tap_indx = 0;
  tap_last_tap = millis();

}


#ifndef DOXYGEN_SHOULD_SKIP_THIS

/**
 * @brief      Looks up a node in the current node stack
 *
 * @param      node        Pointer to node to look up
 * @param      node_index  Pointer to location node index (output)
 *
 * @return     True if found, false if not
 */
bool  fx_pedal::get_audio_node_index(fx_audio_node * node, uint8_t * node_index) {

  for (int i=0;i<MAX_NODES_PER_FX;i++) {

    if (node == audio_node_stack[i]) {
      *node_index = i;
      return true;
    }
  }
  return false;
}


/**
 * @brief      Looks up a control node in the current node stack
 *
 * @param      node        Pointer to node to look up
 * @param      node_index  Pointer to location node index (output)
 *
 * @return     True if found, false if not
 */
bool  fx_pedal::get_control_node_index(fx_control_node * node, uint8_t * node_index) {

  for (int i=0;i<MAX_NODES_PER_FX;i++) {

    if (node == control_node_stack[i]) {
      *node_index = i;
      return true;
    }
  }
  return false;
}

#endif  // DOXYGEN_SHOULD_SKIP_THIS







/******************************************************************************
 *  Canvas control functions 
 *****************************************************************************/


/**
 * @brief      Pedal service function that should be called in the Arduino loop() function
 */
void fx_pedal::service(void) {

  if (tap_control_enabled) {
    if (tap_footswitch == FOOTSWITCH_LEFT) {
      if (millis() < tap_led_flash_cntr + 50) {
        turn_on_left_footsw_led();
      } else {
        turn_off_left_footsw_led();
      }
    }
    else if (tap_footswitch == FOOTSWITCH_RIGHT) {
      if (millis() < tap_led_flash_cntr + 50) {
        turn_on_right_footsw_led();
      } else {
        turn_off_right_footsw_led();
      }
    }
  }

  if ((tap_blink_only_enabled || tap_control_enabled) && tap_locked) {
    if (millis() > tap_led_flash_cntr + tap_interval_ms) {
      tap_led_flash_cntr = millis();
      if (tap_footswitch == FOOTSWITCH_LEFT) {
        turn_on_left_footsw_led();
      } else if (tap_footswitch == FOOTSWITCH_RIGHT) {
        turn_on_right_footsw_led();
      }
    } else if (millis() > tap_led_flash_cntr + 200) {
      if (tap_footswitch == FOOTSWITCH_LEFT) {
        turn_off_left_footsw_led();
      } else if (tap_footswitch == FOOTSWITCH_RIGHT) {
        turn_off_right_footsw_led();
      }
    }
  }

  if (dsp_status.state_err_other) {
    DEBUG_MSG(""Internal error detected on DSP - try resetting"", MSG_WARN);
    dsp_status.state_err_other = false;
    delay(1000);
  }

  // Service LEDs
  led_left.service();
  #if defined (DM_FX_TWO)
    led_center.service();
  #endif
  led_right.service();

  button_press_check();
  service_button_events();

  // Read in telemetry data from the DSP
  display_data_from_sharc();

  // Run the remainder of service loop ~30 times / second
  if (millis() < last_service_ts + 33) return;
  last_service_ts = millis();

  // Read the pots and switches
  #if defined (DM_FX)
    pot_right.read_pot();
    pot_center.read_pot();
    pot_left.read_pot();

  #elif defined (DM_FX_TWO)
    pot_top_left.read_pot();
    pot_top_right.read_pot();
    pot_bot_left.read_pot();
    pot_bot_center.read_pot();
    pot_bot_right.read_pot();
    exp_pedal.read_pot();
    toggle_left.read_switch();
    toggle_right.read_switch();

  #endif 

  // Get status data from the DSP
  spi_get_status();

  // Service any parameter updates
  spi_service();

}

void    fx_pedal::bypass_fx(void) {
  DEBUG_MSG(""Bypass"", MSG_DEBUG);
  spi_transmit_bypass((uint16_t) 1);
}


void    fx_pedal::enable_fx(void) {
  DEBUG_MSG(""Enable"", MSG_DEBUG);
  spi_transmit_bypass((uint16_t) 0);
}


/**
 * @brief      Runs the current canvas (i.e. compiles and downloads to the DSP)
 *
 * @return     True if successful, false if not
 */
bool fx_pedal::run(void) {

  
  bool ready = true;

  // Check to see if our routing is valid
  if (total_audio_routes == 0) {
    DEBUG_MSG(""No routes defined"", MSG_ERROR);
    display_error_status(ERROR_CODE_ILLEGAL_ROUTING);
  } else if (!valid_audio_routes) {
    DEBUG_MSG(""Errors in the audio routing.  Fix errors in your route_audio() calls."", MSG_ERROR);
    display_error_status(ERROR_CODE_ILLEGAL_ROUTING);
  } else if (total_control_routes > 0 && !valid_control_routes) {
    DEBUG_MSG(""Errors in the control routing.  Fix errors in your route_control() calls."", MSG_ERROR);
    display_error_status(ERROR_CODE_ILLEGAL_ROUTING);
  }  

  if (ready) {
    display_data_from_sharc();

    // Send routing stack to DSP
    spi_transmit_audio_routing_stack();
    display_data_from_sharc();

    spi_transmit_control_routing_stack();
    display_data_from_sharc();

    // Send instance stack to DSP
    spi_transmit_instance_stack();
    display_data_from_sharc();

    // Send parameters to DSP
    spi_transmit_all_params();
    display_data_from_sharc();

    // If we've added bypass controls, start effect bypassed
    if (bypass_control_enabled) {
      pedal.bypassed = true;
      bypass_fx();
    } else {
      pedal.bypassed = false;
      enable_fx();
    }

    // Wait for DSP to send message that canvas is running
    wait_for_canvas_to_start();
    int now = millis();
    while (millis() < now + 50) {
      display_data_from_sharc();
    }



    if (dsp_status.state_canvas_running) {
      DEBUG_MSG(""Canvas is running"", MSG_INFO);
    } else {
      report_canvas_errors();
      ready = false;
    } 
  }

  // Display error code on LEDs
  if (!ready) {
    display_error_status(ERROR_CODE_ILLEGAL_ROUTING);
  }

  return ready;

}




/******************************************************************************
 *  Parameter control functions 
 *****************************************************************************/




#ifndef DOXYGEN_SHOULD_SKIP_THIS

void fx_pedal::register_tap(void) {

  uint32_t interval = millis() - tap_last_tap;
  tap_last_tap = millis();
  tap_led_flash_cntr = millis();

  #if 0
    Serial.print(""Debug: interval:"");
    Serial.println(interval);
  #endif 

  if (tap_indx == 0 || interval > 2000) {
    
    tap_indx = 1;      
    tap_locked = false;
    tap_new_val = false;

    for (int i=0;i<15;i++) {
      tap_history[i] = 0;
    }

    return;
  } else if (tap_indx < 2) {
    tap_history[tap_indx++] = interval;
    tap_locked = false;
  } else {
    tap_history[tap_indx++] = interval;
    if (tap_indx >= 16) {
      tap_indx = 15;
    }
    float sum = 0.0;
    for (int i=1; i<tap_indx; i++) {
      sum += (float) tap_history[i];
    }
    sum *= 1.0/((float) (tap_indx-1));
    tap_locked = true;
    tap_interval_ms = sum;
    tap_new_val = true;
    #if 0
      Serial.print(""Debug: tap ms:"");
      Serial.println(tap_interval_ms);
    #endif 
  }
}

void fx_pedal::button_press_check(void) {
  static int time_since_last_press = 0;
  if (millis() < time_since_last_press + 75) {
    return;
  }
  time_since_last_press = millis();

  bool left = !digitalRead(PIN_FOOTSW_LEFT);
  bool right = !digitalRead(PIN_FOOTSW_RIGHT);

  if (left && left != footswitch_left_last_state) {
    footswitch_left_pressed = true;  
  } else if (!left && left != footswitch_left_last_state) {
    footswitch_left_released = true;  
  }

  if (right && right != footswitch_right_last_state) {
    footswitch_right_pressed = true;  
  } else if (!right && right != footswitch_right_last_state) {
    footswitch_right_released = true; 
  }

  footswitch_left_last_state = left;
  footswitch_right_last_state = right;
}

void  fx_pedal::service_button_events(void) {

  if (footswitch_right_pressed_event) {
    footswitch_right_pressed_event = false;

    if (bypass_control_enabled && bypass_footswitch == FOOTSWITCH_RIGHT) {

        DEBUG_MSG(""Toggle bypass"", MSG_DEBUG);

        if (bypassed) {
          led_right.turn_on();
          enable_fx();
        } else {
          led_right.turn_off();
          bypass_fx();
        }
        bypassed = !bypassed;
      }
  }

  if (footswitch_left_pressed_event) {
    footswitch_left_pressed_event = false;
    if (bypass_control_enabled && bypass_footswitch == FOOTSWITCH_LEFT) {

      DEBUG_MSG(""Toggle bypass"", MSG_DEBUG);

      if (bypassed) {
        //Serial.println(""Turning on left LED"");
        led_left.turn_on();
        //turn_on_left_footsw_led();
        enable_fx();
      } else {
        //Serial.println(""Turning off left LED"");
        led_left.turn_off();
        //turn_off_left_footsw_led();
        bypass_fx();
      }
      bypassed = !bypassed;
    }
  }
}

#endif // DOXYGEN_SHOULD_SKIP_THIS



/**
 * @brief      Returns true when a new tap interval has been tapped in by the user
 *
 * @return     { description_of_the_return_value }
 */
bool fx_pedal::new_tap_interval(void) {
  if (tap_new_val) {
    tap_new_val = false;
    return true;
  } else {
    return false;
  }
}


/**
 * @brief      Returns the current tap interval in milliseconds
 *
 * @return     The tap interval in milliseconds.
 */
float fx_pedal::get_tap_interval_ms(void) {
  if (tap_locked) {
    return tap_interval_ms;
  } else {
    return 1000.0;
  }
}

/**
 * @brief      Returns the current tap interval in Hertz (cycles / second)
 *
 * @return     The tap frequency in Hertz
 */
float fx_pedal::get_tap_freq_hz(void) {
  if (tap_locked) {
    return 1.0/(0.001 * tap_interval_ms);
  } else {
    return 1.0;
  }
}


/**
 * @brief      Sets the LED blink rate for tap interval
 * 
 * Use this if there is a pot that can also change the tempo / rate / duration
 * to override what has been previously ""tapped"" in.
 *
 * @param[in]  rate_hz  The new blink rate in Hertz
 */
void fx_pedal::set_tap_blink_rate_hz(float rate_hz) {
  if (rate_hz < 0) {
    rate_hz = 0;
  } else if (rate_hz > 100) {
    rate_hz = 100.0;
  }
  tap_interval_ms = (1000.0/rate_hz);
  tap_locked = true;
  tap_control_enabled = true;
}

/**
 * @brief      Sets the LED blink rate for tap interval with LED control
 *
 * Use this if there is a pot that can also change the tempo / rate / duration
 * to override what has been previously ""tapped"" in.
 *
 * @param[in]  rate_hz  The new blink rate in Hertz
 * @param[in]  led      Which LED to flash (FOOTSWITCH_LEFT, FOOTSWITCH_RIGHT)
 */
void fx_pedal::set_tap_blink_rate_hz(float rate_hz, FOOTSWITCH led) {
  if (rate_hz < 0) {
    rate_hz = 0;
  } else if (rate_hz > 100) {
    rate_hz = 100.0;
  }
  tap_interval_ms = (1000.0/rate_hz);
  tap_locked = true;
  tap_blink_only_enabled = true;
  tap_footswitch = led;

} 


/**
 * @brief      Sets the LED blink rate in milliseconds.
 *
 * Use this if there is a pot that can also change the tempo / rate / duration
 * to override what has been previously ""tapped"" in. 
 * 
 * @param[in]  ms    The blink rate in milliseconds
 */
void fx_pedal::set_tap_blink_rate_ms(float ms) {
  if (ms < 0) {
    ms = 10;
  } else if (ms > 10000) {
    ms = 10000.0;
  }
  tap_interval_ms = ms;
  tap_locked = true;
  tap_control_enabled = true;
}

/**
 * @brief      Sets the LED blink rate for tap interval with LED control
 *
 * Use this if there is a pot that can also change the tempo / rate / duration
 * to override what has been previously ""tapped"" in. 
 *
 * @param[in]  ms    The new blink period in milliseconds
 * @param[in]  led   Which LED to flash (FOOTSWITCH_LEFT, FOOTSWITCH_RIGHT)
 */
void fx_pedal::set_tap_blink_rate_ms(float ms, FOOTSWITCH led) {
  if (ms < 0) {
    ms = 10;
  } else if (ms > 10000) {
    ms = 10000.0;
  }
  tap_interval_ms = ms;
  tap_locked = true;
  tap_blink_only_enabled = true;
  tap_footswitch = led;
}    



/**
 * @brief      Checks if a button was just pressed and optionally turns on an LED when it is
 *
 * This function is used to create events when a button is held down and released to momentarily
 * enable / disable functionality.
 *
 * @param[in]  footswitch  The footswitch (FOOTSWITCH_LEFT, FOOTSWITCH_RIGHT, (FOOTSWITCH_LEFT, FOOTSWITCH_BOTH)
 * @param[in]  enable_led  If true, lights LED while button pressed
 *
 * @return     true if button is pressed, false if not
 */
bool fx_pedal::button_pressed(FOOTSWITCH footswitch, bool enable_led) {
  bool result = false;

  if (footswitch == FOOTSWITCH_BOTH && footswitch_left_pressed && footswitch_right_pressed) {
    footswitch_left_pressed = false;
    footswitch_left_released = false;
    footswitch_right_pressed = false;
    footswitch_right_released = false;
    result = true;
  } else if (footswitch == FOOTSWITCH_LEFT && footswitch_left_pressed) {
    footswitch_left_pressed = false;
    footswitch_left_released = false;
    if (enable_led) {
      led_left.turn_on();
    }
    result = true;
  } else if (footswitch == FOOTSWITCH_RIGHT && footswitch_right_pressed) {
    footswitch_right_pressed = false;
    footswitch_right_released = false;
    if (enable_led) {
      led_right.turn_on();
    }
    result = true;
  }
  return result;
}

/**
 * @brief      Checks if a button was just released and optionally turns off an LED when it was
 *
 * This function is used to create events when a button is held down and released to momentarily
 * enable / disable functionality.
 *
 * @param[in]  footswitch  The footswitch (FOOTSWITCH_LEFT, FOOTSWITCH_RIGHT, (FOOTSWITCH_LEFT, FOOTSWITCH_BOTH)
 * @param[in]  enable_led  If true, turns off the LED when button is released
 *
 * @return     { description_of_the_return_value }
 */
bool fx_pedal::button_released(FOOTSWITCH footswitch, bool enable_led) {
  bool result = false;
  if (footswitch == FOOTSWITCH_LEFT && footswitch_left_released) {
    footswitch_left_pressed = false;
    footswitch_left_released = false;
    if (enable_led) {
      led_left.turn_off();
      //turn_off_left_footsw_led();
    }
    result = true;
  } else if (footswitch == FOOTSWITCH_RIGHT && footswitch_right_released) {
    footswitch_right_pressed = false;
    footswitch_right_released = false;
    if (enable_led) {
      led_right.turn_off();
      //turn_off_right_footsw_led();
    }
    result = true;
  }
  return result;
}










/**
 * @brief      Prints the current processor loading (percentage) to Serial console
 *
 * @param[in]  seconds  How many seconds to wait before displaying the loading again
 */
void fx_pedal::print_processor_load(int seconds) {
  if (seconds < 1) {
    seconds = 1;
  }
  static int now = 0;
  if (millis() > now + seconds*1000) {
    Serial.print(""Processor load: "");
    Serial.print(dsp_status.loading_percentage);
    Serial.println(""%"");
    now = millis();
  }
}





/**
 * @brief   Utility function to print the instance stack to the console
 */
void fx_pedal::print_instance_stack() {

  char buf[64];

  Serial.println();
  Serial.println(""Instance stack:"");

  sprintf(buf,"" Total instances: %d"", (int) total_instances); Serial.println(buf);
  for (int i=0;i<total_instances;i++) {
    if (instance_stack[i].type != FX_UNDEFINED) {

      sprintf(buf,"" ID: %#04x"", (int) instance_stack[i].id); Serial.println(buf);

      Serial.print(""  Type: "");
      Serial.print(get_effect_type(instance_stack[i].type));
      Serial.print("" ("");
      Serial.print(instance_stack[i].type);
      Serial.println("")"");
      
      sprintf(buf,""  Address: %#04x"", (int) instance_stack[i].address); Serial.println(buf);

    } else {
      Serial.println(""Undefined instance found"");
    }
  }
  Serial.println();
}

/**
 * @brief   Utility function to print the routing table to the console
 */
void fx_pedal::print_routing_table() {
  
  char buf[64];

  Serial.println();
  Serial.println(""Audio routing table:"");

  if (total_audio_routes > 0) {
    for (int i=0;i<total_audio_routes;i++) {
      if (audio_routing_stack[i].src_id != UNDEFINED) {        
        Serial.print("" Src ID: "");
        Serial.println((int) audio_routing_stack[i].src_id, HEX);
        Serial.print(""  Src Node Indx: "");
        Serial.println((int) audio_routing_stack[i].src_node_indx, HEX);
        Serial.print("" Dest ID: "");
        Serial.println((int) audio_routing_stack[i].dest_id, HEX);
        Serial.print(""  Dest Node Indx: "");
        Serial.println((int) audio_routing_stack[i].dest_node_indx, HEX);
        Serial.println();
      }
    }
  } else {
    Serial.println("" No audio routes in canvas"");
  }

  Serial.println(""Control routing table:"");

  if (total_control_routes > 0) {
    for (int i=0;i<total_control_routes;i++) {
      if (audio_routing_stack[i].src_id != UNDEFINED) {
        Serial.print("" Src ID: "");
        Serial.println((int) control_routing_stack[i].src_id, HEX);
        Serial.print(""  Src Node Indx: "");
        Serial.println((int) control_routing_stack[i].src_node_indx, HEX);
        Serial.print("" Dest ID: "");
        Serial.println((int) control_routing_stack[i].dest_id, HEX);
        Serial.print(""  Dest Node Indx: "");
        Serial.println((int) control_routing_stack[i].dest_node_indx, HEX);
        Serial.println();
      }
    }
  } else {
    Serial.println("" No control routes in canvas"");
  }


}

/**
 * @brief    Utility function to print the parameter tables
 */
void fx_pedal::print_param_tables() {
  char buf[64];

  Serial.println();
  Serial.println(""Parameter tables:"");

  if (total_instances <= 1) {
    Serial.println("" There are no effect instances in this canvas so there are no parameters"");
    return;
  }

  for (int i=1;i<total_instances;i++) {
    if (instance_stack[i].address == NULL) {
      sprintf(buf, ""Null pointer encoundered for instance %d"", i); Serial.println(buf);
    } else {

      if (instance_stack[i].type == FX_ALLPASS_FILTER) {
        sprintf(buf, ""Allpass filter (instance %d)"", i); Serial.println(buf);
        fx_allpass_filter * effect = (fx_allpass_filter *) instance_stack[i].address; 
        effect->print_params();
      }

      else if (instance_stack[i].type == FX_ADSR_ENVELOPE) {
        sprintf(buf, ""ADSR Envelope (instance %d)"", i); Serial.println(buf);
        fx_adsr_envelope * effect = (fx_adsr_envelope *) instance_stack[i].address; 
        effect->print_params();
      }

      else if (instance_stack[i].type == FX_AMPLITUDE_MODULATOR) {
        sprintf(buf, ""AMP MODULATOR (instance %d)"", i); Serial.println(buf);
        fx_amplitude_mod * effect = (fx_amplitude_mod *) instance_stack[i].address; 
        effect->print_params();
      }

      else if (instance_stack[i].type == FX_ARPEGGIATOR) {
        sprintf(buf, ""Arpeggiator (instance %d)"", i); Serial.println(buf);
        fx_arpeggiator * effect = (fx_arpeggiator *) instance_stack[i].address; 
        effect->print_params();
      }

      else if (instance_stack[i].type == FX_BIQUAD_FILTER) {
        sprintf(buf, ""BIQUAD (instance %d)"", i); Serial.println(buf);
        fx_biquad_filter * effect = (fx_biquad_filter *) instance_stack[i].address; 
        effect->print_params();
      }

      else if (instance_stack[i].type == FX_DESTRUCTOR) {
        sprintf(buf, ""Destructor (instance %d)"", i); Serial.println(buf);
        fx_destructor * effect = (fx_destructor *) instance_stack[i].address; 
        effect->print_params();
      }

      else if (instance_stack[i].type == FX_COMPRESSOR) {
        sprintf(buf, ""Compressor (instance %d)"", i); Serial.println(buf);
        fx_compressor * effect = (fx_compressor *) instance_stack[i].address; 
        effect->print_params();
      }

      else if (instance_stack[i].type == FX_DELAY) {
        sprintf(buf, ""DELAY (instance %d)"", i); Serial.println(buf);
        fx_delay * effect = (fx_delay *) instance_stack[i].address; 
        effect->print_params();
      }

      else if (instance_stack[i].type == FX_DELAY_MULTITAP) {
        sprintf(buf, ""MULTITAP DELAY (instance %d)"", i); Serial.println(buf);
        fx_multitap_delay * effect = (fx_multitap_delay *) instance_stack[i].address; 
        effect->print_params();
      }

      else if (instance_stack[i].type == FX_ENVELOPE_TRACKER) {
        sprintf(buf, ""ENVELOPE TRACKER (instance %d)"", i); Serial.println(buf);
        fx_envelope_tracker * effect = (fx_envelope_tracker *) instance_stack[i].address; 
        effect->print_params();
      }


      else if (instance_stack[i].type == FX_GAIN) {
        sprintf(buf, ""GAIN (instance %d)"", i); Serial.println(buf);
        fx_gain * effect = (fx_gain *) instance_stack[i].address; 
        effect->print_params();
      }

      else if (instance_stack[i].type == FX_HARMONIZER) {
        sprintf(buf, ""HARMONIZER (instance %d)"", i); Serial.println(buf);
        fx_harmonizer * effect = (fx_harmonizer *) instance_stack[i].address; 
        effect->print_params();
      }

      else if (instance_stack[i].type == FX_IMPULSE_RESPONSE) {
        sprintf(buf, ""IMPULSE RESPONSE (instance %d)"", i); Serial.println(buf);
        fx_impulse_response * effect = (fx_impulse_response *) instance_stack[i].address; 
        effect->print_params();
      }


      else if (instance_stack[i].type == FX_MIXER_2) {
        sprintf(buf, ""MIXER x 2 (instance %d)"", i); Serial.println(buf);
        fx_mixer_2 * effect = (fx_mixer_2 *) instance_stack[i].address; 
        effect->print_params();
      }      
  
      else if (instance_stack[i].type == FX_MIXER_3) {
        sprintf(buf, ""MIXER x 3 (instance %d)"", i); Serial.println(buf);
        fx_mixer_3 * effect = (fx_mixer_3 *) instance_stack[i].address; 
        effect->print_params();
      }      

     else  if (instance_stack[i].type == FX_MIXER_4) {
        sprintf(buf, ""MIXER x 4 (instance %d)"", i); Serial.println(buf);
        fx_mixer_4 * effect = (fx_mixer_4 *) instance_stack[i].address; 
        effect->print_params();
      }      

      else if (instance_stack[i].type == FX_PHASE_SHIFTER) {
        sprintf(buf, ""PHASE SHIFTER (instance %d)"", i); Serial.println(buf);
        fx_phase_shifter * effect = (fx_phase_shifter *) instance_stack[i].address; 
        effect->print_params();
      }

      else if (instance_stack[i].type == FX_PITCH_SHIFT) {
        sprintf(buf, ""PITCH SHIFT (instance %d)"", i); Serial.println(buf);
        fx_pitch_shift * effect = (fx_pitch_shift *) instance_stack[i].address; 
        effect->print_params();
      }

      else if (instance_stack[i].type == FX_RING_MOD) {
        sprintf(buf, ""RING MODULATOR (instance %d)"", i); Serial.println(buf);
        fx_ring_mod * effect = (fx_ring_mod *) instance_stack[i].address; 
        effect->print_params();
      }

      else if (instance_stack[i].type == FX_SLICER) {
        sprintf(buf, ""SLICER (instance %d)"", i); Serial.println(buf);
        fx_slicer * effect = (fx_slicer *) instance_stack[i].address; 
        effect->print_params();
      }

      else if (instance_stack[i].type == FX_LOOPER) {
        sprintf(buf, ""LOOPER (instance %d)"", i); Serial.println(buf);
        fx_looper * effect = (fx_looper *) instance_stack[i].address; 
        effect->print_params();
      }

      else if (instance_stack[i].type == FX_INSTRUMENT_SYNTH) {
        sprintf(buf, ""INSTRUMENT SYNTH (instance %d)"", i); Serial.println(buf);
        fx_instrument_synth * effect = (fx_instrument_synth *) instance_stack[i].address; 
        effect->print_params();
      }      

      else if (instance_stack[i].type == FX_OSCILLATOR) {
        sprintf(buf, ""OSCILLATOR (instance %d)"", i); Serial.println(buf);
        fx_oscillator * effect = (fx_oscillator *) instance_stack[i].address; 
        effect->print_params();
      }


      else if (instance_stack[i].type == FX_VARIABLE_DELAY) {
        sprintf(buf, ""VARIABLE DELAY (instance %d)"", i); Serial.println(buf);
        fx_variable_delay * effect = (fx_variable_delay *) instance_stack[i].address; 
        effect->print_params();
      }

      else {
        sprintf(buf, ""UNKNOWN (instance %d)"", i); Serial.println(buf);
        fx_effect * effect = (fx_effect *) instance_stack[i].address;
        effect->print_params();
      }
    }
  }
}

#ifndef DOXYGEN_SHOULD_SKIP_THIS

/**
 * @brief      Gets the effect type string
 *
 * @param[in]  t     The effect type
 *
 * @return     string value.
 */
char * fx_pedal::get_effect_type(EFFECT_TYPE t) {
  if (t == FX_NONE) return ""none"";
  else if (t == FX_ADSR_ENVELOPE) return ""adsr envelope"";
  else if (t == FX_ALLPASS_FILTER) return ""allpass filter"";
  else if (t == FX_AMPLITUDE_MODULATOR) return ""amplitude modulator"";
  else if (t == FX_ARPEGGIATOR) return ""arpeggiator"";
  else if (t == FX_BIQUAD_FILTER) return ""biquad filter"";
  else if (t == FX_DESTRUCTOR) return ""destructor"";
  else if (t == FX_COMPRESSOR) return ""compressor"";
  else if (t == FX_DELAY) return ""delay"";
  else if (t == FX_DELAY_MULTITAP) return ""multitap delay"";
  else if (t == FX_ENVELOPE_TRACKER) return ""envelope tracker"";
  else if (t == FX_GAIN) return ""gain"";  
  else if (t == FX_IMPULSE_RESPONSE) return ""impulse response"";
  else if (t == FX_INSTRUMENT_SYNTH) return ""instrument synth"";
  else if (t == FX_LOOPER) return ""looper"";
  else if (t == FX_MIXER_2) return ""mixer x 2"";  
  else if (t == FX_MIXER_3) return ""mixer x 3"";  
  else if (t == FX_MIXER_4) return ""mixer x 4"";  
  else if (t == FX_OSCILLATOR) return ""oscillator"";  
  else if (t == FX_PHASE_SHIFTER) return ""phase shifter"";
  else if (t == FX_PITCH_SHIFT) return ""pitch shift"";
  else if (t == FX_RING_MOD) return ""ring modulator"";
  else if (t == FX_SLICER) return ""slicer"";
  else if (t == FX_SPECTRALIZER) return ""spectralizer"";
  else if (t == FX_VARIABLE_DELAY) return ""variable delay"";
  else if (t == FX_UNDEFINED) return ""undefined"";
  else if (t == FX_CANVAS) return ""canvas"";
  else return ""unknown"";
}

#endif 




















/************************************************************************
 *
 *                        EFFECTS FUNCTIONS
 *
 ***********************************************************************/


/**
 * @brief      Looks up the index of a given node in the node stack for this effect
 *
 * @param      node        The node to look up
 * @param      node_index  The node index that was looked up (output)
 *
 * @return     True if found, false if not
 */
bool fx_effect::get_audio_node_index(fx_audio_node * node, uint8_t * local_node_index) {

  for (int i=0;i<MAX_NODES_PER_FX;i++) {

    if (node == audio_node_stack[i]) {
      *local_node_index = i;
      
      // save in instance
      node_index = i;
      return true;
    }
  }
  return false;
}

bool fx_effect::get_control_node_index(fx_control_node * node, uint8_t * local_node_index) {
  

  for (int i=0;i<MAX_NODES_PER_FX;i++) {
  
    if (node == control_node_stack[i]) {
      *local_node_index = i;
      
      // save in instance
      node_index = i;
      return true;
    }
  }
  return false;
}


uint16_t * fx_effect::serialize_params(uint16_t * serialized_params, uint16_t * size) {

  // serialize instance data
  int indx = 0;

  uint32_t part_32;
  uint16_t part_16;
  uint8_t part_8;
  
  for (int i=0;i<total_params;i++) {
   
    if (param_stack_types[i] == T_BOOL) {
     // Serial.println("" : bool"");
      part_16 = * (uint8_t *) param_stack[i];
      serialized_params[indx++] = part_16;
    }
    else if (param_stack_types[i] == T_INT16) {
      //Serial.println("" : int16"");
      //Serial.println((int)param_stack[i],HEX);
      serialized_params[indx++] = (uint16_t) (* (uint16_t *) param_stack[i]);
    }
    else if (param_stack_types[i] == T_INT32) {
      //Serial.println("" : int32"");
      part_32 = * (uint32_t *) param_stack[i];
      serialized_params[indx++] = (uint16_t)((* (uint32_t *) param_stack[i]) >> 16);
      serialized_params[indx++] = (uint16_t)((* (uint32_t *) param_stack[i]) & 0xFFFF);
    }
    else if (param_stack_types[i] == T_FLOAT) {
      //Serial.println("" : float"");
      part_32 = * (uint32_t *) param_stack[i];
      serialized_params[indx++] = (uint16_t) (part_32 >> 16);
      serialized_params[indx++] = (uint16_t) (part_32 & 0xFFFF);
    }   

    if (indx > MAX_PARMS_PER_FX-5) {
      Serial.print(""Error with "");
      Serial.println(effect_name); 
      DEBUG_MSG(""Maximum parameter limit (MAX_PARMS_PER_FX) exceeded"", MSG_ERROR); 
      display_error_status(ERROR_INTERNAL);
    }

    //sprintf(buf,""  %#08x - %d"", param_stack[i], (int) param_stack_types[i]); Serial.println(buf);

  }
  *size = indx;
  #if 0
    Serial.println(""  ------"");

    for (int i=0;i<indx;i++) {
      //sprintf(buf,""  %#04x, [%#08x] -> %#04x - %d"", serialized_params[i], param_stack[i], * (uint16_t *) param_stack[i], (int) param_stack_types[i]); Serial.println(buf);
      sprintf(buf,""  %#04x"", serialized_params[i]); Serial.println(buf);
    }
    Serial.println(""Complete"");
    //sprintf(buf, ""Bool: %d"" , (int) sizeof(bool)); Serial.println(buf);
  #endif 
}

/**
 * @brief      Checks to see if a float parameter has been updated
 * 
 * This function also applies hysteresis 
 *
 * @param      param       The parameter
 * @param      param_last  The parameter last
 *
 * @return     True if updated, false if not
 */
bool  fx_effect::float_param_updated( float * param, float * param_last, float threshold ) {
  
  bool different;
  if (abs(*param - *param_last) > threshold) {
    different = true;
  } else {
    different = false;
  }

  *param_last = *param;

  return different;

}

/**
 * @brief      Checks to see if a bool parameter has been updated
 *
 * @param      param       The parameter
 * @param      param_last  The parameter last
 *
 * @return     True if updated, false if not
 */
bool  fx_effect::bool_param_updated( bool * param, bool * param_last ) {
  bool different = false;
  if (*param != *param_last) {
    different = true;
  }
  *param_last = *param;
  return different;
}    


void  fx_effect::print_params(void) {
  Serial.println("" No print function declared for this effect"");
}

bool  fx_effect::service(void) {
  Serial.println("" No service function declared for this effect"");  
  return false;
}






/************************************************************************
 *
 *                        LED FUNCTIONS
 *
 ***********************************************************************/


#ifndef DOXYGEN_SHOULD_SKIP_THIS

fx_led::fx_led(LED_POS pos) {
  led_pos = pos;
  last_scan = millis();
}


void  fx_led::update_rgb_led(void) {
  rgb_write((int) led_pos, (uint8_t) cur_r, (uint8_t) cur_g, (uint8_t) cur_b);
}

void  fx_led::service() {
  if (millis() >= last_scan + LED_UPDATE_RATE_MS) {
    last_scan = millis();

    if (steps) {

      cur_r += inc_r;
      cur_g += inc_g;
      cur_b += inc_b;

      update_rgb_led();

      steps--;
    }
  }
}   
#endif // DOXYGEN_SHOULD_SKIP_THIS



/**
 * @brief      Turns on this LED.  When using an RGB LED, this turns it on to red.
 * 
 * ``` CPP
 * pedal.led_right.turn_on();  // turns on the right LED
 * ```
 */
void  fx_led::turn_on() {

  switch(led_pos) {
    case LED_RIGHT: 
      turn_on_right_footsw_led(); break;
    case LED_CENTER: 
      turn_on_center_footsw_led(); break;
    case LED_LEFT: 
      turn_on_left_footsw_led(); break;
    default: break;
  }
}

/**
 * @brief      Turns on this LED to a specific RGB color
 * 
 * ``` CPP
 * pedal.led_left.turn_on(100, 0, 75); // turn left LED purple
 * ```
 *
 * @param[in]  red    The red component (0-255)
 * @param[in]  green  The green component (0-255)
 * @param[in]  blue   The blue component (0-255)
 */
void  fx_led::turn_on(uint8_t red, uint8_t green, uint8_t blue) {
  set_rgb(red, green, blue);
}

/**
 * @brief      Turns on this LED to a specific RGB color.  If the 
 * LED is not an RGB LED, it will just turn on the LED anyway.
 *
 * ``` CPP
 * pedal.led_left.turn_on(GREEN);
 * ```
 *
 * @param[in]  rgb   The color from LED_COLOR type
 */
void  fx_led::turn_on(LED_COLOR rgb) {
  set_rgb(rgb);
}


/**
 * @brief      Turns off this LED
 * 
 * ``` CPP
 * pedal.led_center.turn_off(); // turn off center LED
 * ``` 
 */
void  fx_led::turn_off() {
  switch(led_pos) {
    case LED_RIGHT: turn_off_right_footsw_led(); break;
    case LED_CENTER: turn_off_center_footsw_led(); break;
    case LED_LEFT: turn_off_left_footsw_led(); break;
    default: break;
  }
}

/**
 * @brief      Sets the RGB color value for this LED
 *
 * ``` CPP
 * 
 * pedal.led_center.set_rgb(40, 0, 50); // Set center LED to purplish color
 * ```
 * 
 *
 * @param[in]  red    The new red component (0-255)
 * @param[in]  green  The new green component (0-255)
 * @param[in]  blue   The new blue component (0-255)
 */
void  fx_led::set_rgb(uint8_t red, uint8_t green, uint8_t blue) {
  #if defined (DM_FX)
    turn_on();
  #elif defined (DM_FX_TWO)
    cur_r = red;
    cur_g = green;
    cur_b = blue;
    steps = 0;
    update_rgb_led();      
  #endif       
}

/**
 * @brief      Sets the RGB color value for this LED
 *
 * ``` CPP
 * pedal.led_right.set_rgb(RED);  // set right LED to red color
 * ``` 
 *
 * @param[in]  rgb   The color from LED_COLOR type
 */
void  fx_led::set_rgb(LED_COLOR rgb) {

  #if defined (DM_FX_TWO)
    float red = ((uint32_t) rgb >> 16) & 0xFF;
    float green = ((uint32_t) rgb >> 8) & 0xFF;
    float blue = (uint32_t) rgb & 0xFF;
    set_rgb(red, green, blue);      
  #endif 
}

/**
 * @brief      Fade this LED to a new RGB value.  The fade happens in the background.
 * 
 * Fade the right LED from red to blue over 1 second.
 * 
 * ``` CPP
 *   pedal.led_right.set_rgb(RED);
 *   pedal.led_right.fade_to_rgb(0, 0, 100, 1000.0);
 * ```
 *
 * The fade happens in the background so the code execution will not wait until the
 * fade completes.
 *
 * @param[in]  red           The red component (0-255)
 * @param[in]  green         The green component (0-255)
 * @param[in]  blue          The blue component (0-255)
 * @param[in]  milliseconds  The milliseconds component (0-255)
 */
void  fx_led::fade_to_rgb(uint8_t red, uint8_t green, uint8_t blue, uint32_t milliseconds) {
  #if defined (DM_FX_TWO)
    target_r = red;
    target_g = green;
    target_b = blue;

    steps = (uint32_t) ((float) milliseconds * (1.0/LED_UPDATE_RATE_MS));
    float inc = 1.0/(float) steps;

    inc_r = (target_r - cur_r) * inc;
    inc_g = (target_g - cur_g) * inc;
    inc_b = (target_b - cur_b) * inc;

    update_rgb_led();
  #endif 

}

/**
 * @brief      Fade this LED to a new RGB value.
 *
 * Fade the right LED from red to blue over 1 second
 * ``` CPP
 *   pedal.led_right.set_rgb(RED);
 *   pedal.led_right.fade_to_rgb(BLUE, 1000.0);
 * ```
 *
 * The fade happens in the background so the code execution will not wait until the
 * fade completes.
 *
 * @param[in]  rgb           The color from LED_COLOR type
 * @param[in]  milliseconds  The milliseconds to perform fade over
 */
void  fx_led::fade_to_rgb(LED_COLOR rgb, uint32_t milliseconds) {
  float red = (rgb >> 16) & 0xFF;
  float green = (rgb >> 8) & 0xFF;
  float blue = rgb & 0xFF;
  fade_to_rgb(red, green, blue, milliseconds);

}



",16299,True,2756.7542020966866,median
"// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2012 The dollarcoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <boost/foreach.hpp>
#include <boost/tuple/tuple.hpp>

using namespace std;
using namespace boost;

#include ""script.h""
#include ""core.h""
#include ""keystore.h""
#include ""bignum.h""
#include ""key.h""
#include ""sync.h""
#include ""util.h""

bool CheckSig(vector<unsigned char> vchSig, const vector<unsigned char> &vchPubKey, const CScript &scriptCode, const CTransaction& txTo, unsigned int nIn, int nHashType, int flags);



typedef vector<unsigned char> valtype;
static const valtype vchFalse(0);
static const valtype vchZero(0);
static const valtype vchTrue(1, 1);
static const CBigNum bnZero(0);
static const CBigNum bnOne(1);
static const CBigNum bnFalse(0);
static const CBigNum bnTrue(1);
static const size_t nMaxNumSize = 4;


CBigNum CastToBigNum(const valtype& vch)
{
    if (vch.size() > nMaxNumSize)
        throw runtime_error(""CastToBigNum() : overflow"");
    // Get rid of extra leading zeros
    return CBigNum(CBigNum(vch).getvch());
}

bool CastToBool(const valtype& vch)
{
    for (unsigned int i = 0; i < vch.size(); i++)
    {
        if (vch[i] != 0)
        {
            // Can be negative zero
            if (i == vch.size()-1 && vch[i] == 0x80)
                return false;
            return true;
        }
    }
    return false;
}



//
// Script is a stack machine (like Forth) that evaluates a predicate
// returning a bool indicating valid or not.  There are no loops.
//
#define stacktop(i)  (stack.at(stack.size()+(i)))
#define altstacktop(i)  (altstack.at(altstack.size()+(i)))
static inline void popstack(vector<valtype>& stack)
{
    if (stack.empty())
        throw runtime_error(""popstack() : stack empty"");
    stack.pop_back();
}


const char* GetTxnOutputType(txnouttype t)
{
    switch (t)
    {
    case TX_NONSTANDARD: return ""nonstandard"";
    case TX_PUBKEY: return ""pubkey"";
    case TX_PUBKEYHASH: return ""pubkeyhash"";
    case TX_SCRIPTHASH: return ""scripthash"";
    case TX_MULTISIG: return ""multisig"";
    }
    return NULL;
}


const char* GetOpName(opcodetype opcode)
{
    switch (opcode)
    {
    // push value
    case OP_0                      : return ""0"";
    case OP_PUSHDATA1              : return ""OP_PUSHDATA1"";
    case OP_PUSHDATA2              : return ""OP_PUSHDATA2"";
    case OP_PUSHDATA4              : return ""OP_PUSHDATA4"";
    case OP_1NEGATE                : return ""-1"";
    case OP_RESERVED               : return ""OP_RESERVED"";
    case OP_1                      : return ""1"";
    case OP_2                      : return ""2"";
    case OP_3                      : return ""3"";
    case OP_4                      : return ""4"";
    case OP_5                      : return ""5"";
    case OP_6                      : return ""6"";
    case OP_7                      : return ""7"";
    case OP_8                      : return ""8"";
    case OP_9                      : return ""9"";
    case OP_10                     : return ""10"";
    case OP_11                     : return ""11"";
    case OP_12                     : return ""12"";
    case OP_13                     : return ""13"";
    case OP_14                     : return ""14"";
    case OP_15                     : return ""15"";
    case OP_16                     : return ""16"";

    // control
    case OP_NOP                    : return ""OP_NOP"";
    case OP_VER                    : return ""OP_VER"";
    case OP_IF                     : return ""OP_IF"";
    case OP_NOTIF                  : return ""OP_NOTIF"";
    case OP_VERIF                  : return ""OP_VERIF"";
    case OP_VERNOTIF               : return ""OP_VERNOTIF"";
    case OP_ELSE                   : return ""OP_ELSE"";
    case OP_ENDIF                  : return ""OP_ENDIF"";
    case OP_VERIFY                 : return ""OP_VERIFY"";
    case OP_RETURN                 : return ""OP_RETURN"";

    // stack ops
    case OP_TOALTSTACK             : return ""OP_TOALTSTACK"";
    case OP_FROMALTSTACK           : return ""OP_FROMALTSTACK"";
    case OP_2DROP                  : return ""OP_2DROP"";
    case OP_2DUP                   : return ""OP_2DUP"";
    case OP_3DUP                   : return ""OP_3DUP"";
    case OP_2OVER                  : return ""OP_2OVER"";
    case OP_2ROT                   : return ""OP_2ROT"";
    case OP_2SWAP                  : return ""OP_2SWAP"";
    case OP_IFDUP                  : return ""OP_IFDUP"";
    case OP_DEPTH                  : return ""OP_DEPTH"";
    case OP_DROP                   : return ""OP_DROP"";
    case OP_DUP                    : return ""OP_DUP"";
    case OP_NIP                    : return ""OP_NIP"";
    case OP_OVER                   : return ""OP_OVER"";
    case OP_PICK                   : return ""OP_PICK"";
    case OP_ROLL                   : return ""OP_ROLL"";
    case OP_ROT                    : return ""OP_ROT"";
    case OP_SWAP                   : return ""OP_SWAP"";
    case OP_TUCK                   : return ""OP_TUCK"";

    // splice ops
    case OP_CAT                    : return ""OP_CAT"";
    case OP_SUBSTR                 : return ""OP_SUBSTR"";
    case OP_LEFT                   : return ""OP_LEFT"";
    case OP_RIGHT                  : return ""OP_RIGHT"";
    case OP_SIZE                   : return ""OP_SIZE"";

    // bit logic
    case OP_INVERT                 : return ""OP_INVERT"";
    case OP_AND                    : return ""OP_AND"";
    case OP_OR                     : return ""OP_OR"";
    case OP_XOR                    : return ""OP_XOR"";
    case OP_EQUAL                  : return ""OP_EQUAL"";
    case OP_EQUALVERIFY            : return ""OP_EQUALVERIFY"";
    case OP_RESERVED1              : return ""OP_RESERVED1"";
    case OP_RESERVED2              : return ""OP_RESERVED2"";

    // numeric
    case OP_1ADD                   : return ""OP_1ADD"";
    case OP_1SUB                   : return ""OP_1SUB"";
    case OP_2MUL                   : return ""OP_2MUL"";
    case OP_2DIV                   : return ""OP_2DIV"";
    case OP_NEGATE                 : return ""OP_NEGATE"";
    case OP_ABS                    : return ""OP_ABS"";
    case OP_NOT                    : return ""OP_NOT"";
    case OP_0NOTEQUAL              : return ""OP_0NOTEQUAL"";
    case OP_ADD                    : return ""OP_ADD"";
    case OP_SUB                    : return ""OP_SUB"";
    case OP_MUL                    : return ""OP_MUL"";
    case OP_DIV                    : return ""OP_DIV"";
    case OP_MOD                    : return ""OP_MOD"";
    case OP_LSHIFT                 : return ""OP_LSHIFT"";
    case OP_RSHIFT                 : return ""OP_RSHIFT"";
    case OP_BOOLAND                : return ""OP_BOOLAND"";
    case OP_BOOLOR                 : return ""OP_BOOLOR"";
    case OP_NUMEQUAL               : return ""OP_NUMEQUAL"";
    case OP_NUMEQUALVERIFY         : return ""OP_NUMEQUALVERIFY"";
    case OP_NUMNOTEQUAL            : return ""OP_NUMNOTEQUAL"";
    case OP_LESSTHAN               : return ""OP_LESSTHAN"";
    case OP_GREATERTHAN            : return ""OP_GREATERTHAN"";
    case OP_LESSTHANOREQUAL        : return ""OP_LESSTHANOREQUAL"";
    case OP_GREATERTHANOREQUAL     : return ""OP_GREATERTHANOREQUAL"";
    case OP_MIN                    : return ""OP_MIN"";
    case OP_MAX                    : return ""OP_MAX"";
    case OP_WITHIN                 : return ""OP_WITHIN"";

    // crypto
    case OP_RIPEMD160              : return ""OP_RIPEMD160"";
    case OP_SHA1                   : return ""OP_SHA1"";
    case OP_SHA256                 : return ""OP_SHA256"";
    case OP_HASH160                : return ""OP_HASH160"";
    case OP_HASH256                : return ""OP_HASH256"";
    case OP_CODESEPARATOR          : return ""OP_CODESEPARATOR"";
    case OP_CHECKSIG               : return ""OP_CHECKSIG"";
    case OP_CHECKSIGVERIFY         : return ""OP_CHECKSIGVERIFY"";
    case OP_CHECKMULTISIG          : return ""OP_CHECKMULTISIG"";
    case OP_CHECKMULTISIGVERIFY    : return ""OP_CHECKMULTISIGVERIFY"";

    // expanson
    case OP_NOP1                   : return ""OP_NOP1"";
    case OP_NOP2                   : return ""OP_NOP2"";
    case OP_NOP3                   : return ""OP_NOP3"";
    case OP_NOP4                   : return ""OP_NOP4"";
    case OP_NOP5                   : return ""OP_NOP5"";
    case OP_NOP6                   : return ""OP_NOP6"";
    case OP_NOP7                   : return ""OP_NOP7"";
    case OP_NOP8                   : return ""OP_NOP8"";
    case OP_NOP9                   : return ""OP_NOP9"";
    case OP_NOP10                  : return ""OP_NOP10"";



    // template matching params
    case OP_PUBKEYHASH             : return ""OP_PUBKEYHASH"";
    case OP_PUBKEY                 : return ""OP_PUBKEY"";

    case OP_INVALIDOPCODE          : return ""OP_INVALIDOPCODE"";
    default:
        return ""OP_UNKNOWN"";
    }
}

bool IsCanonicalPubKey(const valtype &vchPubKey, unsigned int flags) {
    if (!(flags & SCRIPT_VERIFY_STRICTENC))
        return true;

    if (vchPubKey.size() < 33)
        return error(""Non-canonical public key: too short"");
    if (vchPubKey[0] == 0x04) {
        if (vchPubKey.size() != 65)
            return error(""Non-canonical public key: invalid length for uncompressed key"");
    } else if (vchPubKey[0] == 0x02 || vchPubKey[0] == 0x03) {
        if (vchPubKey.size() != 33)
            return error(""Non-canonical public key: invalid length for compressed key"");
    } else {
        return error(""Non-canonical public key: compressed nor uncompressed"");
    }
    return true;
}

bool IsCanonicalSignature(const valtype &vchSig, unsigned int flags) {
    if (!(flags & SCRIPT_VERIFY_STRICTENC))
        return true;

    // See https://bitcointalk.org/index.php?topic=8392.msg127623#msg127623
    // A canonical signature exists of: <30> <total len> <02> <len R> <R> <02> <len S> <S> <hashtype>
    // Where R and S are not negative (their first byte has its highest bit not set), and not
    // excessively padded (do not start with a 0 byte, unless an otherwise negative number follows,
    // in which case a single 0 byte is necessary and even required).
    if (vchSig.size() < 9)
        return error(""Non-canonical signature: too short"");
    if (vchSig.size() > 73)
        return error(""Non-canonical signature: too long"");
    unsigned char nHashType = vchSig[vchSig.size() - 1] & (~(SIGHASH_ANYONECANPAY));
    if (nHashType < SIGHASH_ALL || nHashType > SIGHASH_SINGLE)
        return error(""Non-canonical signature: unknown hashtype byte"");
    if (vchSig[0] != 0x30)
        return error(""Non-canonical signature: wrong type"");
    if (vchSig[1] != vchSig.size()-3)
        return error(""Non-canonical signature: wrong length marker"");
    unsigned int nLenR = vchSig[3];
    if (5 + nLenR >= vchSig.size())
        return error(""Non-canonical signature: S length misplaced"");
    unsigned int nLenS = vchSig[5+nLenR];
    if ((unsigned long)(nLenR+nLenS+7) != vchSig.size())
        return error(""Non-canonical signature: R+S length mismatch"");

    const unsigned char *R = &vchSig[4];
    if (R[-2] != 0x02)
        return error(""Non-canonical signature: R value type mismatch"");
    if (nLenR == 0)
        return error(""Non-canonical signature: R length is zero"");
    if (R[0] & 0x80)
        return error(""Non-canonical signature: R value negative"");
    if (nLenR > 1 && (R[0] == 0x00) && !(R[1] & 0x80))
        return error(""Non-canonical signature: R value excessively padded"");

    const unsigned char *S = &vchSig[6+nLenR];
    if (S[-2] != 0x02)
        return error(""Non-canonical signature: S value type mismatch"");
    if (nLenS == 0)
        return error(""Non-canonical signature: S length is zero"");
    if (S[0] & 0x80)
        return error(""Non-canonical signature: S value negative"");
    if (nLenS > 1 && (S[0] == 0x00) && !(S[1] & 0x80))
        return error(""Non-canonical signature: S value excessively padded"");

    if (flags & SCRIPT_VERIFY_EVEN_S) {
        if (S[nLenS-1] & 1)
            return error(""Non-canonical signature: S value odd"");
    }

    return true;
}

bool EvalScript(vector<vector<unsigned char> >& stack, const CScript& script, const CTransaction& txTo, unsigned int nIn, unsigned int flags, int nHashType)
{
    CAutoBN_CTX pctx;
    CScript::const_iterator pc = script.begin();
    CScript::const_iterator pend = script.end();
    CScript::const_iterator pbegincodehash = script.begin();
    opcodetype opcode;
    valtype vchPushValue;
    vector<bool> vfExec;
    vector<valtype> altstack;
    if (script.size() > 10000)
        return false;
    int nOpCount = 0;

    try
    {
        while (pc < pend)
        {
            bool fExec = !count(vfExec.begin(), vfExec.end(), false);

            //
            // Read instruction
            //
            if (!script.GetOp(pc, opcode, vchPushValue))
                return false;
            if (vchPushValue.size() > MAX_SCRIPT_ELEMENT_SIZE)
                return false;
            if (opcode > OP_16 && ++nOpCount > 201)
                return false;

            if (opcode == OP_CAT ||
                opcode == OP_SUBSTR ||
                opcode == OP_LEFT ||
                opcode == OP_RIGHT ||
                opcode == OP_INVERT ||
                opcode == OP_AND ||
                opcode == OP_OR ||
                opcode == OP_XOR ||
                opcode == OP_2MUL ||
                opcode == OP_2DIV ||
                opcode == OP_MUL ||
                opcode == OP_DIV ||
                opcode == OP_MOD ||
                opcode == OP_LSHIFT ||
                opcode == OP_RSHIFT)
                return false; // Disabled opcodes.

            if (fExec && 0 <= opcode && opcode <= OP_PUSHDATA4)
                stack.push_back(vchPushValue);
            else if (fExec || (OP_IF <= opcode && opcode <= OP_ENDIF))
            switch (opcode)
            {
                //
                // Push value
                //
                case OP_1NEGATE:
                case OP_1:
                case OP_2:
                case OP_3:
                case OP_4:
                case OP_5:
                case OP_6:
                case OP_7:
                case OP_8:
                case OP_9:
                case OP_10:
                case OP_11:
                case OP_12:
                case OP_13:
                case OP_14:
                case OP_15:
                case OP_16:
                {
                    // ( -- value)
                    CBigNum bn((int)opcode - (int)(OP_1 - 1));
                    stack.push_back(bn.getvch());
                }
                break;


                //
                // Control
                //
                case OP_NOP:
                case OP_NOP1: case OP_NOP2: case OP_NOP3: case OP_NOP4: case OP_NOP5:
                case OP_NOP6: case OP_NOP7: case OP_NOP8: case OP_NOP9: case OP_NOP10:
                break;

                case OP_IF:
                case OP_NOTIF:
                {
                    // <expression> if [statements] [else [statements]] endif
                    bool fValue = false;
                    if (fExec)
                    {
                        if (stack.size() < 1)
                            return false;
                        valtype& vch = stacktop(-1);
                        fValue = CastToBool(vch);
                        if (opcode == OP_NOTIF)
                            fValue = !fValue;
                        popstack(stack);
                    }
                    vfExec.push_back(fValue);
                }
                break;

                case OP_ELSE:
                {
                    if (vfExec.empty())
                        return false;
                    vfExec.back() = !vfExec.back();
                }
                break;

                case OP_ENDIF:
                {
                    if (vfExec.empty())
                        return false;
                    vfExec.pop_back();
                }
                break;

                case OP_VERIFY:
                {
                    // (true -- ) or
                    // (false -- false) and return
                    if (stack.size() < 1)
                        return false;
                    bool fValue = CastToBool(stacktop(-1));
                    if (fValue)
                        popstack(stack);
                    else
                        return false;
                }
                break;

                case OP_RETURN:
                {
                    return false;
                }
                break;


                //
                // Stack ops
                //
                case OP_TOALTSTACK:
                {
                    if (stack.size() < 1)
                        return false;
                    altstack.push_back(stacktop(-1));
                    popstack(stack);
                }
                break;

                case OP_FROMALTSTACK:
                {
                    if (altstack.size() < 1)
                        return false;
                    stack.push_back(altstacktop(-1));
                    popstack(altstack);
                }
                break;

                case OP_2DROP:
                {
                    // (x1 x2 -- )
                    if (stack.size() < 2)
                        return false;
                    popstack(stack);
                    popstack(stack);
                }
                break;

                case OP_2DUP:
                {
                    // (x1 x2 -- x1 x2 x1 x2)
                    if (stack.size() < 2)
                        return false;
                    valtype vch1 = stacktop(-2);
                    valtype vch2 = stacktop(-1);
                    stack.push_back(vch1);
                    stack.push_back(vch2);
                }
                break;

                case OP_3DUP:
                {
                    // (x1 x2 x3 -- x1 x2 x3 x1 x2 x3)
                    if (stack.size() < 3)
                        return false;
                    valtype vch1 = stacktop(-3);
                    valtype vch2 = stacktop(-2);
                    valtype vch3 = stacktop(-1);
                    stack.push_back(vch1);
                    stack.push_back(vch2);
                    stack.push_back(vch3);
                }
                break;

                case OP_2OVER:
                {
                    // (x1 x2 x3 x4 -- x1 x2 x3 x4 x1 x2)
                    if (stack.size() < 4)
                        return false;
                    valtype vch1 = stacktop(-4);
                    valtype vch2 = stacktop(-3);
                    stack.push_back(vch1);
                    stack.push_back(vch2);
                }
                break;

                case OP_2ROT:
                {
                    // (x1 x2 x3 x4 x5 x6 -- x3 x4 x5 x6 x1 x2)
                    if (stack.size() < 6)
                        return false;
                    valtype vch1 = stacktop(-6);
                    valtype vch2 = stacktop(-5);
                    stack.erase(stack.end()-6, stack.end()-4);
                    stack.push_back(vch1);
                    stack.push_back(vch2);
                }
                break;

                case OP_2SWAP:
                {
                    // (x1 x2 x3 x4 -- x3 x4 x1 x2)
                    if (stack.size() < 4)
                        return false;
                    swap(stacktop(-4), stacktop(-2));
                    swap(stacktop(-3), stacktop(-1));
                }
                break;

                case OP_IFDUP:
                {
                    // (x - 0 | x x)
                    if (stack.size() < 1)
                        return false;
                    valtype vch = stacktop(-1);
                    if (CastToBool(vch))
                        stack.push_back(vch);
                }
                break;

                case OP_DEPTH:
                {
                    // -- stacksize
                    CBigNum bn(stack.size());
                    stack.push_back(bn.getvch());
                }
                break;

                case OP_DROP:
                {
                    // (x -- )
                    if (stack.size() < 1)
                        return false;
                    popstack(stack);
                }
                break;

                case OP_DUP:
                {
                    // (x -- x x)
                    if (stack.size() < 1)
                        return false;
                    valtype vch = stacktop(-1);
                    stack.push_back(vch);
                }
                break;

                case OP_NIP:
                {
                    // (x1 x2 -- x2)
                    if (stack.size() < 2)
                        return false;
                    stack.erase(stack.end() - 2);
                }
                break;

                case OP_OVER:
                {
                    // (x1 x2 -- x1 x2 x1)
                    if (stack.size() < 2)
                        return false;
                    valtype vch = stacktop(-2);
                    stack.push_back(vch);
                }
                break;

                case OP_PICK:
                case OP_ROLL:
                {
                    // (xn ... x2 x1 x0 n - xn ... x2 x1 x0 xn)
                    // (xn ... x2 x1 x0 n - ... x2 x1 x0 xn)
                    if (stack.size() < 2)
                        return false;
                    int n = CastToBigNum(stacktop(-1)).getint();
                    popstack(stack);
                    if (n < 0 || n >= (int)stack.size())
                        return false;
                    valtype vch = stacktop(-n-1);
                    if (opcode == OP_ROLL)
                        stack.erase(stack.end()-n-1);
                    stack.push_back(vch);
                }
                break;

                case OP_ROT:
                {
                    // (x1 x2 x3 -- x2 x3 x1)
                    //  x2 x1 x3  after first swap
                    //  x2 x3 x1  after second swap
                    if (stack.size() < 3)
                        return false;
                    swap(stacktop(-3), stacktop(-2));
                    swap(stacktop(-2), stacktop(-1));
                }
                break;

                case OP_SWAP:
                {
                    // (x1 x2 -- x2 x1)
                    if (stack.size() < 2)
                        return false;
                    swap(stacktop(-2), stacktop(-1));
                }
                break;

                case OP_TUCK:
                {
                    // (x1 x2 -- x2 x1 x2)
                    if (stack.size() < 2)
                        return false;
                    valtype vch = stacktop(-1);
                    stack.insert(stack.end()-2, vch);
                }
                break;


                case OP_SIZE:
                {
                    // (in -- in size)
                    if (stack.size() < 1)
                        return false;
                    CBigNum bn(stacktop(-1).size());
                    stack.push_back(bn.getvch());
                }
                break;


                //
                // Bitwise logic
                //
                case OP_EQUAL:
                case OP_EQUALVERIFY:
                //case OP_NOTEQUAL: // use OP_NUMNOTEQUAL
                {
                    // (x1 x2 - bool)
                    if (stack.size() < 2)
                        return false;
                    valtype& vch1 = stacktop(-2);
                    valtype& vch2 = stacktop(-1);
                    bool fEqual = (vch1 == vch2);
                    // OP_NOTEQUAL is disabled because it would be too easy to say
                    // something like n != 1 and have some wiseguy pass in 1 with extra
                    // zero bytes after it (numerically, 0x01 == 0x0001 == 0x000001)
                    //if (opcode == OP_NOTEQUAL)
                    //    fEqual = !fEqual;
                    popstack(stack);
                    popstack(stack);
                    stack.push_back(fEqual ? vchTrue : vchFalse);
                    if (opcode == OP_EQUALVERIFY)
                    {
                        if (fEqual)
                            popstack(stack);
                        else
                            return false;
                    }
                }
                break;


                //
                // Numeric
                //
                case OP_1ADD:
                case OP_1SUB:
                case OP_NEGATE:
                case OP_ABS:
                case OP_NOT:
                case OP_0NOTEQUAL:
                {
                    // (in -- out)
                    if (stack.size() < 1)
                        return false;
                    CBigNum bn = CastToBigNum(stacktop(-1));
                    switch (opcode)
                    {
                    case OP_1ADD:       bn += bnOne; break;
                    case OP_1SUB:       bn -= bnOne; break;
                    case OP_NEGATE:     bn = -bn; break;
                    case OP_ABS:        if (bn < bnZero) bn = -bn; break;
                    case OP_NOT:        bn = (bn == bnZero); break;
                    case OP_0NOTEQUAL:  bn = (bn != bnZero); break;
                    default:            assert(!""invalid opcode""); break;
                    }
                    popstack(stack);
                    stack.push_back(bn.getvch());
                }
                break;

                case OP_ADD:
                case OP_SUB:
                case OP_BOOLAND:
                case OP_BOOLOR:
                case OP_NUMEQUAL:
                case OP_NUMEQUALVERIFY:
                case OP_NUMNOTEQUAL:
                case OP_LESSTHAN:
                case OP_GREATERTHAN:
                case OP_LESSTHANOREQUAL:
                case OP_GREATERTHANOREQUAL:
                case OP_MIN:
                case OP_MAX:
                {
                    // (x1 x2 -- out)
                    if (stack.size() < 2)
                        return false;
                    CBigNum bn1 = CastToBigNum(stacktop(-2));
                    CBigNum bn2 = CastToBigNum(stacktop(-1));
                    CBigNum bn;
                    switch (opcode)
                    {
                    case OP_ADD:
                        bn = bn1 + bn2;
                        break;

                    case OP_SUB:
                        bn = bn1 - bn2;
                        break;

                    case OP_BOOLAND:             bn = (bn1 != bnZero && bn2 != bnZero); break;
                    case OP_BOOLOR:              bn = (bn1 != bnZero || bn2 != bnZero); break;
                    case OP_NUMEQUAL:            bn = (bn1 == bn2); break;
                    case OP_NUMEQUALVERIFY:      bn = (bn1 == bn2); break;
                    case OP_NUMNOTEQUAL:         bn = (bn1 != bn2); break;
                    case OP_LESSTHAN:            bn = (bn1 < bn2); break;
                    case OP_GREATERTHAN:         bn = (bn1 > bn2); break;
                    case OP_LESSTHANOREQUAL:     bn = (bn1 <= bn2); break;
                    case OP_GREATERTHANOREQUAL:  bn = (bn1 >= bn2); break;
                    case OP_MIN:                 bn = (bn1 < bn2 ? bn1 : bn2); break;
                    case OP_MAX:                 bn = (bn1 > bn2 ? bn1 : bn2); break;
                    default:                     assert(!""invalid opcode""); break;
                    }
                    popstack(stack);
                    popstack(stack);
                    stack.push_back(bn.getvch());

                    if (opcode == OP_NUMEQUALVERIFY)
                    {
                        if (CastToBool(stacktop(-1)))
                            popstack(stack);
                        else
                            return false;
                    }
                }
                break;

                case OP_WITHIN:
                {
                    // (x min max -- out)
                    if (stack.size() < 3)
                        return false;
                    CBigNum bn1 = CastToBigNum(stacktop(-3));
                    CBigNum bn2 = CastToBigNum(stacktop(-2));
                    CBigNum bn3 = CastToBigNum(stacktop(-1));
                    bool fValue = (bn2 <= bn1 && bn1 < bn3);
                    popstack(stack);
                    popstack(stack);
                    popstack(stack);
                    stack.push_back(fValue ? vchTrue : vchFalse);
                }
                break;


                //
                // Crypto
                //
                case OP_RIPEMD160:
                case OP_SHA1:
                case OP_SHA256:
                case OP_HASH160:
                case OP_HASH256:
                {
                    // (in -- hash)
                    if (stack.size() < 1)
                        return false;
                    valtype& vch = stacktop(-1);
                    valtype vchHash((opcode == OP_RIPEMD160 || opcode == OP_SHA1 || opcode == OP_HASH160) ? 20 : 32);
                    if (opcode == OP_RIPEMD160)
                        RIPEMD160(&vch[0], vch.size(), &vchHash[0]);
                    else if (opcode == OP_SHA1)
                        SHA1(&vch[0], vch.size(), &vchHash[0]);
                    else if (opcode == OP_SHA256)
                        SHA256(&vch[0], vch.size(), &vchHash[0]);
                    else if (opcode == OP_HASH160)
                    {
                        uint160 hash160 = Hash160(vch);
                        memcpy(&vchHash[0], &hash160, sizeof(hash160));
                    }
                    else if (opcode == OP_HASH256)
                    {
                        uint256 hash = Hash(vch.begin(), vch.end());
                        memcpy(&vchHash[0], &hash, sizeof(hash));
                    }
                    popstack(stack);
                    stack.push_back(vchHash);
                }
                break;

                case OP_CODESEPARATOR:
                {
                    // Hash starts after the code separator
                    pbegincodehash = pc;
                }
                break;

                case OP_CHECKSIG:
                case OP_CHECKSIGVERIFY:
                {
                    // (sig pubkey -- bool)
                    if (stack.size() < 2)
                        return false;

                    valtype& vchSig    = stacktop(-2);
                    valtype& vchPubKey = stacktop(-1);

                    ////// debug print
                    //PrintHex(vchSig.begin(), vchSig.end(), ""sig: %s\\n"");
                    //PrintHex(vchPubKey.begin(), vchPubKey.end(), ""pubkey: %s\\n"");

                    // Subset of script starting at the most recent codeseparator
                    CScript scriptCode(pbegincodehash, pend);

                    // Drop the signature, since there's no way for a signature to sign itself
                    scriptCode.FindAndDelete(CScript(vchSig));

                    bool fSuccess = IsCanonicalSignature(vchSig, flags) && IsCanonicalPubKey(vchPubKey, flags) &&
                        CheckSig(vchSig, vchPubKey, scriptCode, txTo, nIn, nHashType, flags);

                    popstack(stack);
                    popstack(stack);
                    stack.push_back(fSuccess ? vchTrue : vchFalse);
                    if (opcode == OP_CHECKSIGVERIFY)
                    {
                        if (fSuccess)
                            popstack(stack);
                        else
                            return false;
                    }
                }
                break;

                case OP_CHECKMULTISIG:
                case OP_CHECKMULTISIGVERIFY:
                {
                    // ([sig ...] num_of_signatures [pubkey ...] num_of_pubkeys -- bool)

                    int i = 1;
                    if ((int)stack.size() < i)
                        return false;

                    int nKeysCount = CastToBigNum(stacktop(-i)).getint();
                    if (nKeysCount < 0 || nKeysCount > 20)
                        return false;
                    nOpCount += nKeysCount;
                    if (nOpCount > 201)
                        return false;
                    int ikey = ++i;
                    i += nKeysCount;
                    if ((int)stack.size() < i)
                        return false;

                    int nSigsCount = CastToBigNum(stacktop(-i)).getint();
                    if (nSigsCount < 0 || nSigsCount > nKeysCount)
                        return false;
                    int isig = ++i;
                    i += nSigsCount;
                    if ((int)stack.size() < i)
                        return false;

                    // Subset of script starting at the most recent codeseparator
                    CScript scriptCode(pbegincodehash, pend);

                    // Drop the signatures, since there's no way for a signature to sign itself
                    for (int k = 0; k < nSigsCount; k++)
                    {
                        valtype& vchSig = stacktop(-isig-k);
                        scriptCode.FindAndDelete(CScript(vchSig));
                    }

                    bool fSuccess = true;
                    while (fSuccess && nSigsCount > 0)
                    {
                        valtype& vchSig    = stacktop(-isig);
                        valtype& vchPubKey = stacktop(-ikey);

                        // Check signature
                        bool fOk = IsCanonicalSignature(vchSig, flags) && IsCanonicalPubKey(vchPubKey, flags) &&
                            CheckSig(vchSig, vchPubKey, scriptCode, txTo, nIn, nHashType, flags);

                        if (fOk) {
                            isig++;
                            nSigsCount--;
                        }
                        ikey++;
                        nKeysCount--;

                        // If there are more signatures left than keys left,
                        // then too many signatures have failed
                        if (nSigsCount > nKeysCount)
                            fSuccess = false;
                    }

                    while (i-- > 0)
                        popstack(stack);
                    stack.push_back(fSuccess ? vchTrue : vchFalse);

                    if (opcode == OP_CHECKMULTISIGVERIFY)
                    {
                        if (fSuccess)
                            popstack(stack);
                        else
                            return false;
                    }
                }
                break;

                default:
                    return false;
            }

            // Size limits
            if (stack.size() + altstack.size() > 1000)
                return false;
        }
    }
    catch (...)
    {
        return false;
    }


    if (!vfExec.empty())
        return false;

    return true;
}









uint256 SignatureHash(CScript scriptCode, const CTransaction& txTo, unsigned int nIn, int nHashType)
{
    if (nIn >= txTo.vin.size())
    {
        printf(""ERROR: SignatureHash() : nIn=%d out of range\\n"", nIn);
        return 1;
    }
    CTransaction txTmp(txTo);

    // In case concatenating two scripts ends up with two codeseparators,
    // or an extra one at the end, this prevents all those possible incompatibilities.
    scriptCode.FindAndDelete(CScript(OP_CODESEPARATOR));

    // Blank out other inputs' signatures
    for (unsigned int i = 0; i < txTmp.vin.size(); i++)
        txTmp.vin[i].scriptSig = CScript();
    txTmp.vin[nIn].scriptSig = scriptCode;

    // Blank out some of the outputs
    if ((nHashType & 0x1f) == SIGHASH_NONE)
    {
        // Wildcard payee
        txTmp.vout.clear();

        // Let the others update at will
        for (unsigned int i = 0; i < txTmp.vin.size(); i++)
            if (i != nIn)
                txTmp.vin[i].nSequence = 0;
    }
    else if ((nHashType & 0x1f) == SIGHASH_SINGLE)
    {
        // Only lock-in the txout payee at same index as txin
        unsigned int nOut = nIn;
        if (nOut >= txTmp.vout.size())
        {
            printf(""ERROR: SignatureHash() : nOut=%d out of range\\n"", nOut);
            return 1;
        }
        txTmp.vout.resize(nOut+1);
        for (unsigned int i = 0; i < nOut; i++)
            txTmp.vout[i].SetNull();

        // Let the others update at will
        for (unsigned int i = 0; i < txTmp.vin.size(); i++)
            if (i != nIn)
                txTmp.vin[i].nSequence = 0;
    }

    // Blank out other inputs completely, not recommended for open transactions
    if (nHashType & SIGHASH_ANYONECANPAY)
    {
        txTmp.vin[0] = txTmp.vin[nIn];
        txTmp.vin.resize(1);
    }

    // Serialize and hash
    CHashWriter ss(SER_GETHASH, 0);
    ss << txTmp << nHashType;
    return ss.GetHash();
}


// Valid signature cache, to avoid doing expensive ECDSA signature checking
// twice for every transaction (once when accepted into memory pool, and
// again when accepted into the block chain)

class CSignatureCache
{
private:
     // sigdata_type is (signature hash, signature, public key):
    typedef boost::tuple<uint256, std::vector<unsigned char>, CPubKey> sigdata_type;
    std::set< sigdata_type> setValid;
    boost::shared_mutex cs_sigcache;

public:
    bool
    Get(const uint256 &hash, const std::vector<unsigned char>& vchSig, const CPubKey& pubKey)
    {
        boost::shared_lock<boost::shared_mutex> lock(cs_sigcache);

        sigdata_type k(hash, vchSig, pubKey);
        std::set<sigdata_type>::iterator mi = setValid.find(k);
        if (mi != setValid.end())
            return true;
        return false;
    }

    void Set(const uint256 &hash, const std::vector<unsigned char>& vchSig, const CPubKey& pubKey)
    {
        // DoS prevention: limit cache size to less than 10MB
        // (~200 bytes per cache entry times 50,000 entries)
        // Since there are a maximum of 20,000 signature operations per block
        // 50,000 is a reasonable default.
        int64 nMaxCacheSize = GetArg(""-maxsigcachesize"", 50000);
        if (nMaxCacheSize <= 0) return;

        boost::unique_lock<boost::shared_mutex> lock(cs_sigcache);

        while (static_cast<int64>(setValid.size()) > nMaxCacheSize)
        {
            // Evict a random entry. Random because that helps
            // foil would-be DoS attackers who might try to pre-generate
            // and re-use a set of valid signatures just-slightly-greater
            // than our cache size.
            uint256 randomHash = GetRandHash();
            std::vector<unsigned char> unused;
            std::set<sigdata_type>::iterator it =
                setValid.lower_bound(sigdata_type(randomHash, unused, unused));
            if (it == setValid.end())
                it = setValid.begin();
            setValid.erase(*it);
        }

        sigdata_type k(hash, vchSig, pubKey);
        setValid.insert(k);
    }
};

bool CheckSig(vector<unsigned char> vchSig, const vector<unsigned char> &vchPubKey, const CScript &scriptCode,
              const CTransaction& txTo, unsigned int nIn, int nHashType, int flags)
{
    static CSignatureCache signatureCache;

    CPubKey pubkey(vchPubKey);
    if (!pubkey.IsValid())
        return false;

    // Hash type is one byte tacked on to the end of the signature
    if (vchSig.empty())
        return false;
    if (nHashType == 0)
        nHashType = vchSig.back();
    else if (nHashType != vchSig.back())
        return false;
    vchSig.pop_back();

    uint256 sighash = SignatureHash(scriptCode, txTo, nIn, nHashType);

    if (signatureCache.Get(sighash, vchSig, pubkey))
        return true;

    if (!pubkey.Verify(sighash, vchSig))
        return false;

    if (!(flags & SCRIPT_VERIFY_NOCACHE))
        signatureCache.Set(sighash, vchSig, pubkey);

    return true;
}









//
// Return public keys or hashes from scriptPubKey, for 'standard' transaction types.
//
bool Solver(const CScript& scriptPubKey, txnouttype& typeRet, vector<vector<unsigned char> >& vSolutionsRet)
{
    // Templates
    static map<txnouttype, CScript> mTemplates;
    if (mTemplates.empty())
    {
        // Standard tx, sender provides pubkey, receiver adds signature
        mTemplates.insert(make_pair(TX_PUBKEY, CScript() << OP_PUBKEY << OP_CHECKSIG));

        // dollarcoin address tx, sender provides hash of pubkey, receiver provides signature and pubkey
        mTemplates.insert(make_pair(TX_PUBKEYHASH, CScript() << OP_DUP << OP_HASH160 << OP_PUBKEYHASH << OP_EQUALVERIFY << OP_CHECKSIG));

        // Sender provides N pubkeys, receivers provides M signatures
        mTemplates.insert(make_pair(TX_MULTISIG, CScript() << OP_SMALLINTEGER << OP_PUBKEYS << OP_SMALLINTEGER << OP_CHECKMULTISIG));
    }

    // Shortcut for pay-to-script-hash, which are more constrained than the other types:
    // it is always OP_HASH160 20 [20 byte hash] OP_EQUAL
    if (scriptPubKey.IsPayToScriptHash())
    {
        typeRet = TX_SCRIPTHASH;
        vector<unsigned char> hashBytes(scriptPubKey.begin()+2, scriptPubKey.begin()+22);
        vSolutionsRet.push_back(hashBytes);
        return true;
    }

    // Scan templates
    const CScript& script1 = scriptPubKey;
    BOOST_FOREACH(const PAIRTYPE(txnouttype, CScript)& tplate, mTemplates)
    {
        const CScript& script2 = tplate.second;
        vSolutionsRet.clear();

        opcodetype opcode1, opcode2;
        vector<unsigned char> vch1, vch2;

        // Compare
        CScript::const_iterator pc1 = script1.begin();
        CScript::const_iterator pc2 = script2.begin();
        while (true)
        {
            if (pc1 == script1.end() && pc2 == script2.end())
            {
                // Found a match
                typeRet = tplate.first;
                if (typeRet == TX_MULTISIG)
                {
                    // Additional checks for TX_MULTISIG:
                    unsigned char m = vSolutionsRet.front()[0];
                    unsigned char n = vSolutionsRet.back()[0];
                    if (m < 1 || n < 1 || m > n || vSolutionsRet.size()-2 != n)
                        return false;
                }
                return true;
            }
            if (!script1.GetOp(pc1, opcode1, vch1))
                break;
            if (!script2.GetOp(pc2, opcode2, vch2))
                break;

            // Template matching opcodes:
            if (opcode2 == OP_PUBKEYS)
            {
                while (vch1.size() >= 33 && vch1.size() <= 120)
                {
                    vSolutionsRet.push_back(vch1);
                    if (!script1.GetOp(pc1, opcode1, vch1))
                        break;
                }
                if (!script2.GetOp(pc2, opcode2, vch2))
                    break;
                // Normal situation is to fall through
                // to other if/else statements
            }

            if (opcode2 == OP_PUBKEY)
            {
                if (vch1.size() < 33 || vch1.size() > 120)
                    break;
                vSolutionsRet.push_back(vch1);
            }
            else if (opcode2 == OP_PUBKEYHASH)
            {
                if (vch1.size() != sizeof(uint160))
                    break;
                vSolutionsRet.push_back(vch1);
            }
            else if (opcode2 == OP_SMALLINTEGER)
            {   // Single-byte small integer pushed onto vSolutions
                if (opcode1 == OP_0 ||
                    (opcode1 >= OP_1 && opcode1 <= OP_16))
                {
                    char n = (char)CScript::DecodeOP_N(opcode1);
                    vSolutionsRet.push_back(valtype(1, n));
                }
                else
                    break;
            }
            else if (opcode1 != opcode2 || vch1 != vch2)
            {
                // Others must match exactly
                break;
            }
        }
    }

    vSolutionsRet.clear();
    typeRet = TX_NONSTANDARD;
    return false;
}


bool Sign1(const CKeyID& address, const CKeyStore& keystore, uint256 hash, int nHashType, CScript& scriptSigRet)
{
    CKey key;
    if (!keystore.GetKey(address, key))
        return false;

    vector<unsigned char> vchSig;
    if (!key.Sign(hash, vchSig))
        return false;
    vchSig.push_back((unsigned char)nHashType);
    scriptSigRet << vchSig;

    return true;
}

bool SignN(const vector<valtype>& multisigdata, const CKeyStore& keystore, uint256 hash, int nHashType, CScript& scriptSigRet)
{
    int nSigned = 0;
    int nRequired = multisigdata.front()[0];
    for (unsigned int i = 1; i < multisigdata.size()-1 && nSigned < nRequired; i++)
    {
        const valtype& pubkey = multisigdata[i];
        CKeyID keyID = CPubKey(pubkey).GetID();
        if (Sign1(keyID, keystore, hash, nHashType, scriptSigRet))
            ++nSigned;
    }
    return nSigned==nRequired;
}

//
// Sign scriptPubKey with private keys stored in keystore, given transaction hash and hash type.
// Signatures are returned in scriptSigRet (or returns false if scriptPubKey can't be signed),
// unless whichTypeRet is TX_SCRIPTHASH, in which case scriptSigRet is the redemption script.
// Returns false if scriptPubKey could not be completely satisfied.
//
bool Solver(const CKeyStore& keystore, const CScript& scriptPubKey, uint256 hash, int nHashType,
                  CScript& scriptSigRet, txnouttype& whichTypeRet)
{
    scriptSigRet.clear();

    vector<valtype> vSolutions;
    if (!Solver(scriptPubKey, whichTypeRet, vSolutions))
        return false;

    CKeyID keyID;
    switch (whichTypeRet)
    {
    case TX_NONSTANDARD:
        return false;
    case TX_PUBKEY:
        keyID = CPubKey(vSolutions[0]).GetID();
        return Sign1(keyID, keystore, hash, nHashType, scriptSigRet);
    case TX_PUBKEYHASH:
        keyID = CKeyID(uint160(vSolutions[0]));
        if (!Sign1(keyID, keystore, hash, nHashType, scriptSigRet))
            return false;
        else
        {
            CPubKey vch;
            keystore.GetPubKey(keyID, vch);
            scriptSigRet << vch;
        }
        return true;
    case TX_SCRIPTHASH:
        return keystore.GetCScript(uint160(vSolutions[0]), scriptSigRet);

    case TX_MULTISIG:
        scriptSigRet << OP_0; // workaround CHECKMULTISIG bug
        return (SignN(vSolutions, keystore, hash, nHashType, scriptSigRet));
    }
    return false;
}

int ScriptSigArgsExpected(txnouttype t, const std::vector<std::vector<unsigned char> >& vSolutions)
{
    switch (t)
    {
    case TX_NONSTANDARD:
        return -1;
    case TX_PUBKEY:
        return 1;
    case TX_PUBKEYHASH:
        return 2;
    case TX_MULTISIG:
        if (vSolutions.size() < 1 || vSolutions[0].size() < 1)
            return -1;
        return vSolutions[0][0] + 1;
    case TX_SCRIPTHASH:
        return 1; // doesn't include args needed by the script
    }
    return -1;
}

bool IsStandard(const CScript& scriptPubKey)
{
    vector<valtype> vSolutions;
    txnouttype whichType;
    if (!Solver(scriptPubKey, whichType, vSolutions))
        return false;

    if (whichType == TX_MULTISIG)
    {
        unsigned char m = vSolutions.front()[0];
        unsigned char n = vSolutions.back()[0];
        // Support up to x-of-3 multisig txns as standard
        if (n < 1 || n > 3)
            return false;
        if (m < 1 || m > n)
            return false;
    }

    return whichType != TX_NONSTANDARD;
}


unsigned int HaveKeys(const vector<valtype>& pubkeys, const CKeyStore& keystore)
{
    unsigned int nResult = 0;
    BOOST_FOREACH(const valtype& pubkey, pubkeys)
    {
        CKeyID keyID = CPubKey(pubkey).GetID();
        if (keystore.HaveKey(keyID))
            ++nResult;
    }
    return nResult;
}


class CKeyStoreIsMineVisitor : public boost::static_visitor<bool>
{
private:
    const CKeyStore *keystore;
public:
    CKeyStoreIsMineVisitor(const CKeyStore *keystoreIn) : keystore(keystoreIn) { }
    bool operator()(const CNoDestination &dest) const { return false; }
    bool operator()(const CKeyID &keyID) const { return keystore->HaveKey(keyID); }
    bool operator()(const CScriptID &scriptID) const { return keystore->HaveCScript(scriptID); }
};

bool IsMine(const CKeyStore &keystore, const CTxDestination &dest)
{
    return boost::apply_visitor(CKeyStoreIsMineVisitor(&keystore), dest);
}

bool IsMine(const CKeyStore &keystore, const CScript& scriptPubKey)
{
    vector<valtype> vSolutions;
    txnouttype whichType;
    if (!Solver(scriptPubKey, whichType, vSolutions))
        return false;

    CKeyID keyID;
    switch (whichType)
    {
    case TX_NONSTANDARD:
        return false;
    case TX_PUBKEY:
        keyID = CPubKey(vSolutions[0]).GetID();
        return keystore.HaveKey(keyID);
    case TX_PUBKEYHASH:
        keyID = CKeyID(uint160(vSolutions[0]));
        return keystore.HaveKey(keyID);
    case TX_SCRIPTHASH:
    {
        CScript subscript;
        if (!keystore.GetCScript(CScriptID(uint160(vSolutions[0])), subscript))
            return false;
        return IsMine(keystore, subscript);
    }
    case TX_MULTISIG:
    {
        // Only consider transactions ""mine"" if we own ALL the
        // keys involved. multi-signature transactions that are
        // partially owned (somebody else has a key that can spend
        // them) enable spend-out-from-under-you attacks, especially
        // in shared-wallet situations.
        vector<valtype> keys(vSolutions.begin()+1, vSolutions.begin()+vSolutions.size()-1);
        return HaveKeys(keys, keystore) == keys.size();
    }
    }
    return false;
}

bool ExtractDestination(const CScript& scriptPubKey, CTxDestination& addressRet)
{
    vector<valtype> vSolutions;
    txnouttype whichType;
    if (!Solver(scriptPubKey, whichType, vSolutions))
        return false;

    if (whichType == TX_PUBKEY)
    {
        addressRet = CPubKey(vSolutions[0]).GetID();
        return true;
    }
    else if (whichType == TX_PUBKEYHASH)
    {
        addressRet = CKeyID(uint160(vSolutions[0]));
        return true;
    }
    else if (whichType == TX_SCRIPTHASH)
    {
        addressRet = CScriptID(uint160(vSolutions[0]));
        return true;
    }
    // Multisig txns have more than one address...
    return false;
}

bool ExtractDestinations(const CScript& scriptPubKey, txnouttype& typeRet, vector<CTxDestination>& addressRet, int& nRequiredRet)
{
    addressRet.clear();
    typeRet = TX_NONSTANDARD;
    vector<valtype> vSolutions;
    if (!Solver(scriptPubKey, typeRet, vSolutions))
        return false;

    if (typeRet == TX_MULTISIG)
    {
        nRequiredRet = vSolutions.front()[0];
        for (unsigned int i = 1; i < vSolutions.size()-1; i++)
        {
            CTxDestination address = CPubKey(vSolutions[i]).GetID();
            addressRet.push_back(address);
        }
    }
    else
    {
        nRequiredRet = 1;
        CTxDestination address;
        if (!ExtractDestination(scriptPubKey, address))
           return false;
        addressRet.push_back(address);
    }

    return true;
}

class CAffectedKeysVisitor : public boost::static_visitor<void> {
private:
    const CKeyStore &keystore;
    std::vector<CKeyID> &vKeys;

public:
    CAffectedKeysVisitor(const CKeyStore &keystoreIn, std::vector<CKeyID> &vKeysIn) : keystore(keystoreIn), vKeys(vKeysIn) {}

    void Process(const CScript &script) {
        txnouttype type;
        std::vector<CTxDestination> vDest;
        int nRequired;
        if (ExtractDestinations(script, type, vDest, nRequired)) {
            BOOST_FOREACH(const CTxDestination &dest, vDest)
                boost::apply_visitor(*this, dest);
        }
    }

    void operator()(const CKeyID &keyId) {
        if (keystore.HaveKey(keyId))
            vKeys.push_back(keyId);
    }

    void operator()(const CScriptID &scriptId) {
        CScript script;
        if (keystore.GetCScript(scriptId, script))
            Process(script);
    }

    void operator()(const CNoDestination &none) {}
};

void ExtractAffectedKeys(const CKeyStore &keystore, const CScript& scriptPubKey, std::vector<CKeyID> &vKeys) {
    CAffectedKeysVisitor(keystore, vKeys).Process(scriptPubKey);
}

bool VerifyScript(const CScript& scriptSig, const CScript& scriptPubKey, const CTransaction& txTo, unsigned int nIn,
                  unsigned int flags, int nHashType)
{
    vector<vector<unsigned char> > stack, stackCopy;
    if (!EvalScript(stack, scriptSig, txTo, nIn, flags, nHashType))
        return false;
    if (flags & SCRIPT_VERIFY_P2SH)
        stackCopy = stack;
    if (!EvalScript(stack, scriptPubKey, txTo, nIn, flags, nHashType))
        return false;
    if (stack.empty())
        return false;

    if (CastToBool(stack.back()) == false)
        return false;

    // Additional validation for spend-to-script-hash transactions:
    if ((flags & SCRIPT_VERIFY_P2SH) && scriptPubKey.IsPayToScriptHash())
    {
        if (!scriptSig.IsPushOnly()) // scriptSig must be literals-only
            return false;            // or validation fails

        // stackCopy cannot be empty here, because if it was the
        // P2SH  HASH <> EQUAL  scriptPubKey would be evaluated with
        // an empty stack and the EvalScript above would return false.
        assert(!stackCopy.empty());

        const valtype& pubKeySerialized = stackCopy.back();
        CScript pubKey2(pubKeySerialized.begin(), pubKeySerialized.end());
        popstack(stackCopy);

        if (!EvalScript(stackCopy, pubKey2, txTo, nIn, flags, nHashType))
            return false;
        if (stackCopy.empty())
            return false;
        return CastToBool(stackCopy.back());
    }

    return true;
}


bool SignSignature(const CKeyStore &keystore, const CScript& fromPubKey, CTransaction& txTo, unsigned int nIn, int nHashType)
{
    assert(nIn < txTo.vin.size());
    CTxIn& txin = txTo.vin[nIn];

    // Leave out the signature from the hash, since a signature can't sign itself.
    // The checksig op will also drop the signatures from its hash.
    uint256 hash = SignatureHash(fromPubKey, txTo, nIn, nHashType);

    txnouttype whichType;
    if (!Solver(keystore, fromPubKey, hash, nHashType, txin.scriptSig, whichType))
        return false;

    if (whichType == TX_SCRIPTHASH)
    {
        // Solver returns the subscript that need to be evaluated;
        // the final scriptSig is the signatures from that
        // and then the serialized subscript:
        CScript subscript = txin.scriptSig;

        // Recompute txn hash using subscript in place of scriptPubKey:
        uint256 hash2 = SignatureHash(subscript, txTo, nIn, nHashType);

        txnouttype subType;
        bool fSolved =
            Solver(keystore, subscript, hash2, nHashType, txin.scriptSig, subType) && subType != TX_SCRIPTHASH;
        // Append serialized subscript whether or not it is completely signed:
        txin.scriptSig << static_cast<valtype>(subscript);
        if (!fSolved) return false;
    }

    // Test solution
    return VerifyScript(txin.scriptSig, fromPubKey, txTo, nIn, SCRIPT_VERIFY_P2SH | SCRIPT_VERIFY_STRICTENC, 0);
}

bool SignSignature(const CKeyStore &keystore, const CTransaction& txFrom, CTransaction& txTo, unsigned int nIn, int nHashType)
{
    assert(nIn < txTo.vin.size());
    CTxIn& txin = txTo.vin[nIn];
    assert(txin.prevout.n < txFrom.vout.size());
    const CTxOut& txout = txFrom.vout[txin.prevout.n];

    return SignSignature(keystore, txout.scriptPubKey, txTo, nIn, nHashType);
}

static CScript PushAll(const vector<valtype>& values)
{
    CScript result;
    BOOST_FOREACH(const valtype& v, values)
        result << v;
    return result;
}

static CScript CombineMultisig(CScript scriptPubKey, const CTransaction& txTo, unsigned int nIn,
                               const vector<valtype>& vSolutions,
                               vector<valtype>& sigs1, vector<valtype>& sigs2)
{
    // Combine all the signatures we've got:
    set<valtype> allsigs;
    BOOST_FOREACH(const valtype& v, sigs1)
    {
        if (!v.empty())
            allsigs.insert(v);
    }
    BOOST_FOREACH(const valtype& v, sigs2)
    {
        if (!v.empty())
            allsigs.insert(v);
    }

    // Build a map of pubkey -> signature by matching sigs to pubkeys:
    assert(vSolutions.size() > 1);
    unsigned int nSigsRequired = vSolutions.front()[0];
    unsigned int nPubKeys = vSolutions.size()-2;
    map<valtype, valtype> sigs;
    BOOST_FOREACH(const valtype& sig, allsigs)
    {
        for (unsigned int i = 0; i < nPubKeys; i++)
        {
            const valtype& pubkey = vSolutions[i+1];
            if (sigs.count(pubkey))
                continue; // Already got a sig for this pubkey

            if (CheckSig(sig, pubkey, scriptPubKey, txTo, nIn, 0, 0))
            {
                sigs[pubkey] = sig;
                break;
            }
        }
    }
    // Now build a merged CScript:
    unsigned int nSigsHave = 0;
    CScript result; result << OP_0; // pop-one-too-many workaround
    for (unsigned int i = 0; i < nPubKeys && nSigsHave < nSigsRequired; i++)
    {
        if (sigs.count(vSolutions[i+1]))
        {
            result << sigs[vSolutions[i+1]];
            ++nSigsHave;
        }
    }
    // Fill any missing with OP_0:
    for (unsigned int i = nSigsHave; i < nSigsRequired; i++)
        result << OP_0;

    return result;
}

static CScript CombineSignatures(CScript scriptPubKey, const CTransaction& txTo, unsigned int nIn,
                                 const txnouttype txType, const vector<valtype>& vSolutions,
                                 vector<valtype>& sigs1, vector<valtype>& sigs2)
{
    switch (txType)
    {
    case TX_NONSTANDARD:
        // Don't know anything about this, assume bigger one is correct:
        if (sigs1.size() >= sigs2.size())
            return PushAll(sigs1);
        return PushAll(sigs2);
    case TX_PUBKEY:
    case TX_PUBKEYHASH:
        // Signatures are bigger than placeholders or empty scripts:
        if (sigs1.empty() || sigs1[0].empty())
            return PushAll(sigs2);
        return PushAll(sigs1);
    case TX_SCRIPTHASH:
        if (sigs1.empty() || sigs1.back().empty())
            return PushAll(sigs2);
        else if (sigs2.empty() || sigs2.back().empty())
            return PushAll(sigs1);
        else
        {
            // Recur to combine:
            valtype spk = sigs1.back();
            CScript pubKey2(spk.begin(), spk.end());

            txnouttype txType2;
            vector<vector<unsigned char> > vSolutions2;
            Solver(pubKey2, txType2, vSolutions2);
            sigs1.pop_back();
            sigs2.pop_back();
            CScript result = CombineSignatures(pubKey2, txTo, nIn, txType2, vSolutions2, sigs1, sigs2);
            result << spk;
            return result;
        }
    case TX_MULTISIG:
        return CombineMultisig(scriptPubKey, txTo, nIn, vSolutions, sigs1, sigs2);
    }

    return CScript();
}

CScript CombineSignatures(CScript scriptPubKey, const CTransaction& txTo, unsigned int nIn,
                          const CScript& scriptSig1, const CScript& scriptSig2)
{
    txnouttype txType;
    vector<vector<unsigned char> > vSolutions;
    Solver(scriptPubKey, txType, vSolutions);

    vector<valtype> stack1;
    EvalScript(stack1, scriptSig1, CTransaction(), 0, SCRIPT_VERIFY_STRICTENC, 0);
    vector<valtype> stack2;
    EvalScript(stack2, scriptSig2, CTransaction(), 0, SCRIPT_VERIFY_STRICTENC, 0);

    return CombineSignatures(scriptPubKey, txTo, nIn, txType, vSolutions, stack1, stack2);
}

unsigned int CScript::GetSigOpCount(bool fAccurate) const
{
    unsigned int n = 0;
    const_iterator pc = begin();
    opcodetype lastOpcode = OP_INVALIDOPCODE;
    while (pc < end())
    {
        opcodetype opcode;
        if (!GetOp(pc, opcode))
            break;
        if (opcode == OP_CHECKSIG || opcode == OP_CHECKSIGVERIFY)
            n++;
        else if (opcode == OP_CHECKMULTISIG || opcode == OP_CHECKMULTISIGVERIFY)
        {
            if (fAccurate && lastOpcode >= OP_1 && lastOpcode <= OP_16)
                n += DecodeOP_N(lastOpcode);
            else
                n += 20;
        }
        lastOpcode = opcode;
    }
    return n;
}

unsigned int CScript::GetSigOpCount(const CScript& scriptSig) const
{
    if (!IsPayToScriptHash())
        return GetSigOpCount(true);

    // This is a pay-to-script-hash scriptPubKey;
    // get the last item that the scriptSig
    // pushes onto the stack:
    const_iterator pc = scriptSig.begin();
    vector<unsigned char> data;
    while (pc < scriptSig.end())
    {
        opcodetype opcode;
        if (!scriptSig.GetOp(pc, opcode, data))
            return 0;
        if (opcode > OP_16)
            return 0;
    }

    /// ... and return its opcount:
    CScript subscript(data.begin(), data.end());
    return subscript.GetSigOpCount(true);
}

bool CScript::IsPayToScriptHash() const
{
    // Extra-fast test for pay-to-script-hash CScripts:
    return (this->size() == 23 &&
            this->at(0) == OP_HASH160 &&
            this->at(1) == 0x14 &&
            this->at(22) == OP_EQUAL);
}

class CScriptVisitor : public boost::static_visitor<bool>
{
private:
    CScript *script;
public:
    CScriptVisitor(CScript *scriptin) { script = scriptin; }

    bool operator()(const CNoDestination &dest) const {
        script->clear();
        return false;
    }

    bool operator()(const CKeyID &keyID) const {
        script->clear();
        *script << OP_DUP << OP_HASH160 << keyID << OP_EQUALVERIFY << OP_CHECKSIG;
        return true;
    }

    bool operator()(const CScriptID &scriptID) const {
        script->clear();
        *script << OP_HASH160 << scriptID << OP_EQUAL;
        return true;
    }
};

void CScript::SetDestination(const CTxDestination& dest)
{
    boost::apply_visitor(CScriptVisitor(this), dest);
}

void CScript::SetMultisig(int nRequired, const std::vector<CPubKey>& keys)
{
    this->clear();

    *this << EncodeOP_N(nRequired);
    BOOST_FOREACH(const CPubKey& key, keys)
        *this << key;
    *this << EncodeOP_N(keys.size()) << OP_CHECKMULTISIG;
}

bool CScriptCompressor::IsToKeyID(CKeyID &hash) const
{
    if (script.size() == 25 && script[0] == OP_DUP && script[1] == OP_HASH160 
                            && script[2] == 20 && script[23] == OP_EQUALVERIFY
                            && script[24] == OP_CHECKSIG) {
        memcpy(&hash, &script[3], 20);
        return true;
    }
    return false;
}

bool CScriptCompressor::IsToScriptID(CScriptID &hash) const
{
    if (script.size() == 23 && script[0] == OP_HASH160 && script[1] == 20
                            && script[22] == OP_EQUAL) {
        memcpy(&hash, &script[2], 20);
        return true;
    }
    return false;
}

bool CScriptCompressor::IsToPubKey(CPubKey &pubkey) const
{
    if (script.size() == 35 && script[0] == 33 && script[34] == OP_CHECKSIG
                            && (script[1] == 0x02 || script[1] == 0x03)) {
        pubkey.Set(&script[1], &script[34]);
        return true;
    }
    if (script.size() == 67 && script[0] == 65 && script[66] == OP_CHECKSIG
                            && script[1] == 0x04) {
        pubkey.Set(&script[1], &script[66]);
        return pubkey.IsFullyValid(); // if not fully valid, a case that would not be compressible
    }
    return false;
}

bool CScriptCompressor::Compress(std::vector<unsigned char> &out) const
{
    CKeyID keyID;
    if (IsToKeyID(keyID)) {
        out.resize(21);
        out[0] = 0x00;
        memcpy(&out[1], &keyID, 20);
        return true;
    }
    CScriptID scriptID;
    if (IsToScriptID(scriptID)) {
        out.resize(21);
        out[0] = 0x01;
        memcpy(&out[1], &scriptID, 20);
        return true;
    }
    CPubKey pubkey;
    if (IsToPubKey(pubkey)) {
        out.resize(33);
        memcpy(&out[1], &pubkey[1], 32);
        if (pubkey[0] == 0x02 || pubkey[0] == 0x03) {
            out[0] = pubkey[0];
            return true;
        } else if (pubkey[0] == 0x04) {
            out[0] = 0x04 | (pubkey[64] & 0x01);
            return true;
        }
    }
    return false;
}

unsigned int CScriptCompressor::GetSpecialSize(unsigned int nSize) const
{
    if (nSize == 0 || nSize == 1)
        return 20;
    if (nSize == 2 || nSize == 3 || nSize == 4 || nSize == 5)
        return 32;
    return 0;
}

bool CScriptCompressor::Decompress(unsigned int nSize, const std::vector<unsigned char> &in)
{
    switch(nSize) {
    case 0x00:
        script.resize(25);
        script[0] = OP_DUP;
        script[1] = OP_HASH160;
        script[2] = 20;
        memcpy(&script[3], &in[0], 20);
        script[23] = OP_EQUALVERIFY;
        script[24] = OP_CHECKSIG;
        return true;
    case 0x01:
        script.resize(23);
        script[0] = OP_HASH160;
        script[1] = 20;
        memcpy(&script[2], &in[0], 20);
        script[22] = OP_EQUAL;
        return true;
    case 0x02:
    case 0x03:
        script.resize(35);
        script[0] = 33;
        script[1] = nSize;
        memcpy(&script[2], &in[0], 32);
        script[34] = OP_CHECKSIG;
        return true;
    case 0x04:
    case 0x05:
        unsigned char vch[33] = {};
        vch[0] = nSize - 2;
        memcpy(&vch[1], &in[0], 32);
        CPubKey pubkey(&vch[0], &vch[33]);
        if (!pubkey.Decompress())
            return false;
        assert(pubkey.size() == 65);
        script.resize(67);
        script[0] = 65;
        memcpy(&script[1], pubkey.begin(), 65);
        script[66] = OP_CHECKSIG;
        return true;
    }
    return false;
}
",16158,False,2388.9132084469434,median
"/*************************************************************************/
/*  particles_material.cpp                                               */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                      https://godotengine.org                          */
/*************************************************************************/
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
/*                                                                       */
/* 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 ""particles_material.h""

Mutex *ParticlesMaterial::material_mutex = NULL;
SelfList<ParticlesMaterial>::List *ParticlesMaterial::dirty_materials = NULL;
Map<ParticlesMaterial::MaterialKey, ParticlesMaterial::ShaderData> ParticlesMaterial::shader_map;
ParticlesMaterial::ShaderNames *ParticlesMaterial::shader_names = NULL;

void ParticlesMaterial::init_shaders() {

#ifndef NO_THREADS
	material_mutex = Mutex::create();
#endif

	dirty_materials = memnew(SelfList<ParticlesMaterial>::List);

	shader_names = memnew(ShaderNames);

	shader_names->direction = ""direction"";
	shader_names->spread = ""spread"";
	shader_names->flatness = ""flatness"";
	shader_names->initial_linear_velocity = ""initial_linear_velocity"";
	shader_names->initial_angle = ""initial_angle"";
	shader_names->angular_velocity = ""angular_velocity"";
	shader_names->orbit_velocity = ""orbit_velocity"";
	shader_names->linear_accel = ""linear_accel"";
	shader_names->radial_accel = ""radial_accel"";
	shader_names->tangent_accel = ""tangent_accel"";
	shader_names->damping = ""damping"";
	shader_names->scale = ""scale"";
	shader_names->hue_variation = ""hue_variation"";
	shader_names->anim_speed = ""anim_speed"";
	shader_names->anim_offset = ""anim_offset"";

	shader_names->initial_linear_velocity_random = ""initial_linear_velocity_random"";
	shader_names->initial_angle_random = ""initial_angle_random"";
	shader_names->angular_velocity_random = ""angular_velocity_random"";
	shader_names->orbit_velocity_random = ""orbit_velocity_random"";
	shader_names->linear_accel_random = ""linear_accel_random"";
	shader_names->radial_accel_random = ""radial_accel_random"";
	shader_names->tangent_accel_random = ""tangent_accel_random"";
	shader_names->damping_random = ""damping_random"";
	shader_names->scale_random = ""scale_random"";
	shader_names->hue_variation_random = ""hue_variation_random"";
	shader_names->anim_speed_random = ""anim_speed_random"";
	shader_names->anim_offset_random = ""anim_offset_random"";

	shader_names->angle_texture = ""angle_texture"";
	shader_names->angular_velocity_texture = ""angular_velocity_texture"";
	shader_names->orbit_velocity_texture = ""orbit_velocity_texture"";
	shader_names->linear_accel_texture = ""linear_accel_texture"";
	shader_names->radial_accel_texture = ""radial_accel_texture"";
	shader_names->tangent_accel_texture = ""tangent_accel_texture"";
	shader_names->damping_texture = ""damping_texture"";
	shader_names->scale_texture = ""scale_texture"";
	shader_names->hue_variation_texture = ""hue_variation_texture"";
	shader_names->anim_speed_texture = ""anim_speed_texture"";
	shader_names->anim_offset_texture = ""anim_offset_texture"";

	shader_names->color = ""color_value"";
	shader_names->color_ramp = ""color_ramp"";

	shader_names->emission_sphere_radius = ""emission_sphere_radius"";
	shader_names->emission_box_extents = ""emission_box_extents"";
	shader_names->emission_texture_point_count = ""emission_texture_point_count"";
	shader_names->emission_texture_points = ""emission_texture_points"";
	shader_names->emission_texture_normal = ""emission_texture_normal"";
	shader_names->emission_texture_color = ""emission_texture_color"";

	shader_names->trail_divisor = ""trail_divisor"";
	shader_names->trail_size_modifier = ""trail_size_modifier"";
	shader_names->trail_color_modifier = ""trail_color_modifier"";

	shader_names->gravity = ""gravity"";

	shader_names->lifetime_randomness = ""lifetime_randomness"";
}

void ParticlesMaterial::finish_shaders() {

#ifndef NO_THREADS
	memdelete(material_mutex);
#endif

	memdelete(dirty_materials);
	dirty_materials = NULL;

	memdelete(shader_names);
}

void ParticlesMaterial::_update_shader() {

	dirty_materials->remove(&element);

	MaterialKey mk = _compute_key();
	if (mk.key == current_key.key)
		return; //no update required in the end

	if (shader_map.has(current_key)) {
		shader_map[current_key].users--;
		if (shader_map[current_key].users == 0) {
			//deallocate shader, as it's no longer in use
			VS::get_singleton()->free(shader_map[current_key].shader);
			shader_map.erase(current_key);
		}
	}

	current_key = mk;

	if (shader_map.has(mk)) {

		VS::get_singleton()->material_set_shader(_get_material(), shader_map[mk].shader);
		shader_map[mk].users++;
		return;
	}

	//must create a shader!

	String code = ""shader_type particles;\\n"";

	code += ""uniform vec3 direction;\\n"";
	code += ""uniform float spread;\\n"";
	code += ""uniform float flatness;\\n"";
	code += ""uniform float initial_linear_velocity;\\n"";
	code += ""uniform float initial_angle;\\n"";
	code += ""uniform float angular_velocity;\\n"";
	code += ""uniform float orbit_velocity;\\n"";
	code += ""uniform float linear_accel;\\n"";
	code += ""uniform float radial_accel;\\n"";
	code += ""uniform float tangent_accel;\\n"";
	code += ""uniform float damping;\\n"";
	code += ""uniform float scale;\\n"";
	code += ""uniform float hue_variation;\\n"";
	code += ""uniform float anim_speed;\\n"";
	code += ""uniform float anim_offset;\\n"";

	code += ""uniform float initial_linear_velocity_random;\\n"";
	code += ""uniform float initial_angle_random;\\n"";
	code += ""uniform float angular_velocity_random;\\n"";
	code += ""uniform float orbit_velocity_random;\\n"";
	code += ""uniform float linear_accel_random;\\n"";
	code += ""uniform float radial_accel_random;\\n"";
	code += ""uniform float tangent_accel_random;\\n"";
	code += ""uniform float damping_random;\\n"";
	code += ""uniform float scale_random;\\n"";
	code += ""uniform float hue_variation_random;\\n"";
	code += ""uniform float anim_speed_random;\\n"";
	code += ""uniform float anim_offset_random;\\n"";
	code += ""uniform float lifetime_randomness;\\n"";

	switch (emission_shape) {
		case EMISSION_SHAPE_POINT: {
			//do none
		} break;
		case EMISSION_SHAPE_SPHERE: {
			code += ""uniform float emission_sphere_radius;\\n"";
		} break;
		case EMISSION_SHAPE_BOX: {
			code += ""uniform vec3 emission_box_extents;\\n"";
		} break;
		case EMISSION_SHAPE_DIRECTED_POINTS: {
			code += ""uniform sampler2D emission_texture_normal : hint_black;\\n"";
			[[fallthrough]];
		}
		case EMISSION_SHAPE_POINTS: {
			code += ""uniform sampler2D emission_texture_points : hint_black;\\n"";
			code += ""uniform int emission_texture_point_count;\\n"";
			if (emission_color_texture.is_valid()) {
				code += ""uniform sampler2D emission_texture_color : hint_white;\\n"";
			}
		} break;
		case EMISSION_SHAPE_MAX: { // Max value for validity check.
			break;
		}
	}

	code += ""uniform vec4 color_value : hint_color;\\n"";

	code += ""uniform int trail_divisor;\\n"";

	code += ""uniform vec3 gravity;\\n"";

	if (color_ramp.is_valid())
		code += ""uniform sampler2D color_ramp;\\n"";

	if (tex_parameters[PARAM_INITIAL_LINEAR_VELOCITY].is_valid())
		code += ""uniform sampler2D linear_velocity_texture;\\n"";
	if (tex_parameters[PARAM_ORBIT_VELOCITY].is_valid())
		code += ""uniform sampler2D orbit_velocity_texture;\\n"";
	if (tex_parameters[PARAM_ANGULAR_VELOCITY].is_valid())
		code += ""uniform sampler2D angular_velocity_texture;\\n"";
	if (tex_parameters[PARAM_LINEAR_ACCEL].is_valid())
		code += ""uniform sampler2D linear_accel_texture;\\n"";
	if (tex_parameters[PARAM_RADIAL_ACCEL].is_valid())
		code += ""uniform sampler2D radial_accel_texture;\\n"";
	if (tex_parameters[PARAM_TANGENTIAL_ACCEL].is_valid())
		code += ""uniform sampler2D tangent_accel_texture;\\n"";
	if (tex_parameters[PARAM_DAMPING].is_valid())
		code += ""uniform sampler2D damping_texture;\\n"";
	if (tex_parameters[PARAM_ANGLE].is_valid())
		code += ""uniform sampler2D angle_texture;\\n"";
	if (tex_parameters[PARAM_SCALE].is_valid())
		code += ""uniform sampler2D scale_texture;\\n"";
	if (tex_parameters[PARAM_HUE_VARIATION].is_valid())
		code += ""uniform sampler2D hue_variation_texture;\\n"";
	if (tex_parameters[PARAM_ANIM_SPEED].is_valid())
		code += ""uniform sampler2D anim_speed_texture;\\n"";
	if (tex_parameters[PARAM_ANIM_OFFSET].is_valid())
		code += ""uniform sampler2D anim_offset_texture;\\n"";

	if (trail_size_modifier.is_valid()) {
		code += ""uniform sampler2D trail_size_modifier;\\n"";
	}

	if (trail_color_modifier.is_valid()) {
		code += ""uniform sampler2D trail_color_modifier;\\n"";
	}

	//need a random function
	code += ""\\n\\n"";
	code += ""float rand_from_seed(inout uint seed) {\\n"";
	code += ""	int k;\\n"";
	code += ""	int s = int(seed);\\n"";
	code += ""	if (s == 0)\\n"";
	code += ""	s = 305420679;\\n"";
	code += ""	k = s / 127773;\\n"";
	code += ""	s = 16807 * (s - k * 127773) - 2836 * k;\\n"";
	code += ""	if (s < 0)\\n"";
	code += ""		s += 2147483647;\\n"";
	code += ""	seed = uint(s);\\n"";
	code += ""	return float(seed % uint(65536)) / 65535.0;\\n"";
	code += ""}\\n"";
	code += ""\\n"";

	code += ""float rand_from_seed_m1_p1(inout uint seed) {\\n"";
	code += ""	return rand_from_seed(seed) * 2.0 - 1.0;\\n"";
	code += ""}\\n"";
	code += ""\\n"";

	//improve seed quality
	code += ""uint hash(uint x) {\\n"";
	code += ""	x = ((x >> uint(16)) ^ x) * uint(73244475);\\n"";
	code += ""	x = ((x >> uint(16)) ^ x) * uint(73244475);\\n"";
	code += ""	x = (x >> uint(16)) ^ x;\\n"";
	code += ""	return x;\\n"";
	code += ""}\\n"";
	code += ""\\n"";

	code += ""void vertex() {\\n"";
	code += ""	uint base_number = NUMBER / uint(trail_divisor);\\n"";
	code += ""	uint alt_seed = hash(base_number + uint(1) + RANDOM_SEED);\\n"";
	code += ""	float angle_rand = rand_from_seed(alt_seed);\\n"";
	code += ""	float scale_rand = rand_from_seed(alt_seed);\\n"";
	code += ""	float hue_rot_rand = rand_from_seed(alt_seed);\\n"";
	code += ""	float anim_offset_rand = rand_from_seed(alt_seed);\\n"";
	code += ""	float pi = 3.14159;\\n"";
	code += ""	float degree_to_rad = pi / 180.0;\\n"";
	code += ""\\n"";

	if (emission_shape == EMISSION_SHAPE_POINTS || emission_shape == EMISSION_SHAPE_DIRECTED_POINTS) {
		code += ""	int point = min(emission_texture_point_count - 1, int(rand_from_seed(alt_seed) * float(emission_texture_point_count)));\\n"";
		code += ""	ivec2 emission_tex_size = textureSize(emission_texture_points, 0);\\n"";
		code += ""	ivec2 emission_tex_ofs = ivec2(point % emission_tex_size.x, point / emission_tex_size.x);\\n"";
	}
	code += ""	bool restart = false;\\n"";
	code += ""	if (CUSTOM.y > CUSTOM.w) {\\n"";
	code += ""		restart = true;\\n"";
	code += ""	}\\n\\n"";
	code += ""	if (RESTART || restart) {\\n"";

	if (tex_parameters[PARAM_INITIAL_LINEAR_VELOCITY].is_valid())
		code += ""		float tex_linear_velocity = textureLod(linear_velocity_texture, vec2(0.0, 0.0), 0.0).r;\\n"";
	else
		code += ""		float tex_linear_velocity = 0.0;\\n"";

	if (tex_parameters[PARAM_ANGLE].is_valid())
		code += ""		float tex_angle = textureLod(angle_texture, vec2(0.0, 0.0), 0.0).r;\\n"";
	else
		code += ""		float tex_angle = 0.0;\\n"";

	if (tex_parameters[PARAM_ANIM_OFFSET].is_valid())
		code += ""		float tex_anim_offset = textureLod(anim_offset_texture, vec2(0.0, 0.0), 0.0).r;\\n"";
	else
		code += ""		float tex_anim_offset = 0.0;\\n"";

	code += ""		float spread_rad = spread * degree_to_rad;\\n"";

	if (flags[FLAG_DISABLE_Z]) {

		code += ""		float angle1_rad = rand_from_seed_m1_p1(alt_seed) * spread_rad;\\n"";
		code += ""		angle1_rad += direction.x != 0.0 ? atan(direction.y, direction.x) : sign(direction.y) * (pi / 2.0);\\n"";
		code += ""		vec3 rot = vec3(cos(angle1_rad), sin(angle1_rad), 0.0);\\n"";
		code += ""		VELOCITY = rot * initial_linear_velocity * mix(1.0, rand_from_seed(alt_seed), initial_linear_velocity_random);\\n"";

	} else {
		//initiate velocity spread in 3D
		code += ""		float angle1_rad = rand_from_seed_m1_p1(alt_seed) * spread_rad;\\n"";
		code += ""		float angle2_rad = rand_from_seed_m1_p1(alt_seed) * spread_rad * (1.0 - flatness);\\n"";
		code += ""		angle1_rad += direction.z != 0.0 ? atan(direction.x, direction.z) : sign(direction.x) * (pi / 2.0);\\n"";
		code += ""		angle2_rad += direction.z != 0.0 ? atan(direction.y, abs(direction.z)) : (direction.x != 0.0 ? atan(direction.y, abs(direction.x)) : sign(direction.y) * (pi / 2.0));\\n"";
		code += ""		vec3 direction_xz = vec3(sin(angle1_rad), 0.0, cos(angle1_rad));\\n"";
		code += ""		vec3 direction_yz = vec3(0.0, sin(angle2_rad), cos(angle2_rad));\\n"";
		code += ""		direction_yz.z = direction_yz.z / max(0.0001,sqrt(abs(direction_yz.z))); // better uniform distribution\\n"";
		code += ""		vec3 vec_direction = vec3(direction_xz.x * direction_yz.z, direction_yz.y, direction_xz.z * direction_yz.z);\\n"";
		code += ""		vec_direction = normalize(vec_direction);\\n"";
		code += ""		VELOCITY = vec_direction * initial_linear_velocity * mix(1.0, rand_from_seed(alt_seed), initial_linear_velocity_random);\\n"";
	}

	code += ""		float base_angle = (initial_angle + tex_angle) * mix(1.0, angle_rand, initial_angle_random);\\n"";
	code += ""		CUSTOM.x = base_angle * degree_to_rad;\\n""; // angle
	code += ""		CUSTOM.y = 0.0;\\n""; // phase
	code += ""		CUSTOM.w = (1.0 - lifetime_randomness * rand_from_seed(alt_seed));\\n"";
	code += ""		CUSTOM.z = (anim_offset + tex_anim_offset) * mix(1.0, anim_offset_rand, anim_offset_random);\\n""; // animation offset (0-1)

	switch (emission_shape) {
		case EMISSION_SHAPE_POINT: {
			//do none
		} break;
		case EMISSION_SHAPE_SPHERE: {
			code += ""		float s = rand_from_seed(alt_seed) * 2.0 - 1.0;\\n"";
			code += ""		float t = rand_from_seed(alt_seed) * 2.0 * pi;\\n"";
			code += ""		float radius = emission_sphere_radius * sqrt(1.0 - s * s);\\n"";
			code += ""		TRANSFORM[3].xyz = vec3(radius * cos(t), radius * sin(t), emission_sphere_radius * s);\\n"";
		} break;
		case EMISSION_SHAPE_BOX: {
			code += ""		TRANSFORM[3].xyz = vec3(rand_from_seed(alt_seed) * 2.0 - 1.0, rand_from_seed(alt_seed) * 2.0 - 1.0, rand_from_seed(alt_seed) * 2.0 - 1.0) * emission_box_extents;\\n"";
		} break;
		case EMISSION_SHAPE_POINTS:
		case EMISSION_SHAPE_DIRECTED_POINTS: {
			code += ""		TRANSFORM[3].xyz = texelFetch(emission_texture_points, emission_tex_ofs, 0).xyz;\\n"";

			if (emission_shape == EMISSION_SHAPE_DIRECTED_POINTS) {
				if (flags[FLAG_DISABLE_Z]) {

					code += ""		mat2 rotm;"";
					code += ""		rotm[0] = texelFetch(emission_texture_normal, emission_tex_ofs, 0).xy;\\n"";
					code += ""		rotm[1] = rotm[0].yx * vec2(1.0, -1.0);\\n"";
					code += ""		VELOCITY.xy = rotm * VELOCITY.xy;\\n"";
				} else {
					code += ""		vec3 normal = texelFetch(emission_texture_normal, emission_tex_ofs, 0).xyz;\\n"";
					code += ""		vec3 v0 = abs(normal.z) < 0.999 ? vec3(0.0, 0.0, 1.0) : vec3(0.0, 1.0, 0.0);\\n"";
					code += ""		vec3 tangent = normalize(cross(v0, normal));\\n"";
					code += ""		vec3 bitangent = normalize(cross(tangent, normal));\\n"";
					code += ""		VELOCITY = mat3(tangent, bitangent, normal) * VELOCITY;\\n"";
				}
			}
		} break;
		case EMISSION_SHAPE_MAX: { // Max value for validity check.
			break;
		}
	}
	code += ""		VELOCITY = (EMISSION_TRANSFORM * vec4(VELOCITY, 0.0)).xyz;\\n"";
	code += ""		TRANSFORM = EMISSION_TRANSFORM * TRANSFORM;\\n"";
	if (flags[FLAG_DISABLE_Z]) {
		code += ""		VELOCITY.z = 0.0;\\n"";
		code += ""		TRANSFORM[3].z = 0.0;\\n"";
	}

	code += ""	} else {\\n"";

	code += ""		CUSTOM.y += DELTA / LIFETIME;\\n"";
	if (tex_parameters[PARAM_INITIAL_LINEAR_VELOCITY].is_valid())
		code += ""		float tex_linear_velocity = textureLod(linear_velocity_texture, vec2(CUSTOM.y, 0.0), 0.0).r;\\n"";
	else
		code += ""		float tex_linear_velocity = 0.0;\\n"";

	if (flags[FLAG_DISABLE_Z]) {

		if (tex_parameters[PARAM_ORBIT_VELOCITY].is_valid())
			code += ""		float tex_orbit_velocity = textureLod(orbit_velocity_texture, vec2(CUSTOM.y, 0.0), 0.0).r;\\n"";
		else
			code += ""		float tex_orbit_velocity = 0.0;\\n"";
	}

	if (tex_parameters[PARAM_ANGULAR_VELOCITY].is_valid())
		code += ""		float tex_angular_velocity = textureLod(angular_velocity_texture, vec2(CUSTOM.y, 0.0), 0.0).r;\\n"";
	else
		code += ""		float tex_angular_velocity = 0.0;\\n"";

	if (tex_parameters[PARAM_LINEAR_ACCEL].is_valid())
		code += ""		float tex_linear_accel = textureLod(linear_accel_texture, vec2(CUSTOM.y, 0.0), 0.0).r;\\n"";
	else
		code += ""		float tex_linear_accel = 0.0;\\n"";

	if (tex_parameters[PARAM_RADIAL_ACCEL].is_valid())
		code += ""		float tex_radial_accel = textureLod(radial_accel_texture, vec2(CUSTOM.y, 0.0), 0.0).r;\\n"";
	else
		code += ""		float tex_radial_accel = 0.0;\\n"";

	if (tex_parameters[PARAM_TANGENTIAL_ACCEL].is_valid())
		code += ""		float tex_tangent_accel = textureLod(tangent_accel_texture, vec2(CUSTOM.y, 0.0), 0.0).r;\\n"";
	else
		code += ""		float tex_tangent_accel = 0.0;\\n"";

	if (tex_parameters[PARAM_DAMPING].is_valid())
		code += ""		float tex_damping = textureLod(damping_texture, vec2(CUSTOM.y, 0.0), 0.0).r;\\n"";
	else
		code += ""		float tex_damping = 0.0;\\n"";

	if (tex_parameters[PARAM_ANGLE].is_valid())
		code += ""		float tex_angle = textureLod(angle_texture, vec2(CUSTOM.y, 0.0), 0.0).r;\\n"";
	else
		code += ""		float tex_angle = 0.0;\\n"";

	if (tex_parameters[PARAM_ANIM_SPEED].is_valid())
		code += ""		float tex_anim_speed = textureLod(anim_speed_texture, vec2(CUSTOM.y, 0.0), 0.0).r;\\n"";
	else
		code += ""		float tex_anim_speed = 0.0;\\n"";

	if (tex_parameters[PARAM_ANIM_OFFSET].is_valid())
		code += ""		float tex_anim_offset = textureLod(anim_offset_texture, vec2(CUSTOM.y, 0.0), 0.0).r;\\n"";
	else
		code += ""		float tex_anim_offset = 0.0;\\n"";

	code += ""		vec3 force = gravity;\\n"";
	code += ""		vec3 pos = TRANSFORM[3].xyz;\\n"";
	if (flags[FLAG_DISABLE_Z]) {
		code += ""		pos.z = 0.0;\\n"";
	}
	code += ""		// apply linear acceleration\\n"";
	code += ""		force += length(VELOCITY) > 0.0 ? normalize(VELOCITY) * (linear_accel + tex_linear_accel) * mix(1.0, rand_from_seed(alt_seed), linear_accel_random) : vec3(0.0);\\n"";
	code += ""		// apply radial acceleration\\n"";
	code += ""		vec3 org = EMISSION_TRANSFORM[3].xyz;\\n"";
	code += ""		vec3 diff = pos - org;\\n"";
	code += ""		force += length(diff) > 0.0 ? normalize(diff) * (radial_accel + tex_radial_accel) * mix(1.0, rand_from_seed(alt_seed), radial_accel_random) : vec3(0.0);\\n"";
	code += ""		// apply tangential acceleration;\\n"";
	if (flags[FLAG_DISABLE_Z]) {
		code += ""		force += length(diff.yx) > 0.0 ? vec3(normalize(diff.yx * vec2(-1.0, 1.0)), 0.0) * ((tangent_accel + tex_tangent_accel) * mix(1.0, rand_from_seed(alt_seed), tangent_accel_random)) : vec3(0.0);\\n"";

	} else {
		code += ""		vec3 crossDiff = cross(normalize(diff), normalize(gravity));\\n"";
		code += ""		force += length(crossDiff) > 0.0 ? normalize(crossDiff) * ((tangent_accel + tex_tangent_accel) * mix(1.0, rand_from_seed(alt_seed), tangent_accel_random)) : vec3(0.0);\\n"";
	}
	code += ""		// apply attractor forces\\n"";
	code += ""		VELOCITY += force * DELTA;\\n"";
	code += ""		// orbit velocity\\n"";
	if (flags[FLAG_DISABLE_Z]) {

		code += ""		float orbit_amount = (orbit_velocity + tex_orbit_velocity) * mix(1.0, rand_from_seed(alt_seed), orbit_velocity_random);\\n"";
		code += ""		if (orbit_amount != 0.0) {\\n"";
		code += ""		     float ang = orbit_amount * DELTA * pi * 2.0;\\n"";
		code += ""		     mat2 rot = mat2(vec2(cos(ang), -sin(ang)), vec2(sin(ang), cos(ang)));\\n"";
		code += ""		     TRANSFORM[3].xy -= diff.xy;\\n"";
		code += ""		     TRANSFORM[3].xy += rot * diff.xy;\\n"";
		code += ""		}\\n"";
	}

	if (tex_parameters[PARAM_INITIAL_LINEAR_VELOCITY].is_valid()) {
		code += ""		VELOCITY = normalize(VELOCITY) * tex_linear_velocity;\\n"";
	}
	code += ""		if (damping + tex_damping > 0.0) {\\n"";
	code += ""			float v = length(VELOCITY);\\n"";
	code += ""			float damp = (damping + tex_damping) * mix(1.0, rand_from_seed(alt_seed), damping_random);\\n"";
	code += ""			v -= damp * DELTA;\\n"";
	code += ""			if (v < 0.0) {\\n"";
	code += ""				VELOCITY = vec3(0.0);\\n"";
	code += ""			} else {\\n"";
	code += ""				VELOCITY = normalize(VELOCITY) * v;\\n"";
	code += ""			}\\n"";
	code += ""		}\\n"";
	code += ""		float base_angle = (initial_angle + tex_angle) * mix(1.0, angle_rand, initial_angle_random);\\n"";
	code += ""		base_angle += CUSTOM.y * LIFETIME * (angular_velocity + tex_angular_velocity) * mix(1.0, rand_from_seed(alt_seed) * 2.0 - 1.0, angular_velocity_random);\\n"";
	code += ""		CUSTOM.x = base_angle * degree_to_rad;\\n""; // angle
	code += ""		CUSTOM.z = (anim_offset + tex_anim_offset) * mix(1.0, anim_offset_rand, anim_offset_random) + CUSTOM.y * (anim_speed + tex_anim_speed) * mix(1.0, rand_from_seed(alt_seed), anim_speed_random);\\n""; // angle
	code += ""	}\\n"";
	// apply color
	// apply hue rotation
	if (tex_parameters[PARAM_SCALE].is_valid())
		code += ""	float tex_scale = textureLod(scale_texture, vec2(CUSTOM.y, 0.0), 0.0).r;\\n"";
	else
		code += ""	float tex_scale = 1.0;\\n"";

	if (tex_parameters[PARAM_HUE_VARIATION].is_valid())
		code += ""	float tex_hue_variation = textureLod(hue_variation_texture, vec2(CUSTOM.y, 0.0), 0.0).r;\\n"";
	else
		code += ""	float tex_hue_variation = 0.0;\\n"";

	code += ""	float hue_rot_angle = (hue_variation + tex_hue_variation) * pi * 2.0 * mix(1.0, hue_rot_rand * 2.0 - 1.0, hue_variation_random);\\n"";
	code += ""	float hue_rot_c = cos(hue_rot_angle);\\n"";
	code += ""	float hue_rot_s = sin(hue_rot_angle);\\n"";
	code += ""	mat4 hue_rot_mat = mat4(vec4(0.299, 0.587, 0.114, 0.0),\\n"";
	code += ""			vec4(0.299, 0.587, 0.114, 0.0),\\n"";
	code += ""			vec4(0.299, 0.587, 0.114, 0.0),\\n"";
	code += ""			vec4(0.000, 0.000, 0.000, 1.0)) +\\n"";
	code += ""		mat4(vec4(0.701, -0.587, -0.114, 0.0),\\n"";
	code += ""			vec4(-0.299, 0.413, -0.114, 0.0),\\n"";
	code += ""			vec4(-0.300, -0.588, 0.886, 0.0),\\n"";
	code += ""			vec4(0.000, 0.000, 0.000, 0.0)) * hue_rot_c +\\n"";
	code += ""		mat4(vec4(0.168, 0.330, -0.497, 0.0),\\n"";
	code += ""			vec4(-0.328, 0.035,  0.292, 0.0),\\n"";
	code += ""			vec4(1.250, -1.050, -0.203, 0.0),\\n"";
	code += ""			vec4(0.000, 0.000, 0.000, 0.0)) * hue_rot_s;\\n"";
	if (color_ramp.is_valid()) {
		code += ""	COLOR = hue_rot_mat * textureLod(color_ramp, vec2(CUSTOM.y, 0.0), 0.0);\\n"";
	} else {
		code += ""	COLOR = hue_rot_mat * color_value;\\n"";
	}
	if (emission_color_texture.is_valid() && (emission_shape == EMISSION_SHAPE_POINTS || emission_shape == EMISSION_SHAPE_DIRECTED_POINTS)) {
		code += ""	COLOR *= texelFetch(emission_texture_color, emission_tex_ofs, 0);\\n"";
	}
	if (trail_color_modifier.is_valid()) {
		code += ""	if (trail_divisor > 1) {\\n"";
		code += ""		COLOR *= textureLod(trail_color_modifier, vec2(float(int(NUMBER) % trail_divisor) / float(trail_divisor - 1), 0.0), 0.0);\\n"";
		code += ""	}\\n"";
	}
	code += ""\\n"";

	if (flags[FLAG_DISABLE_Z]) {

		if (flags[FLAG_ALIGN_Y_TO_VELOCITY]) {
			code += ""	if (length(VELOCITY) > 0.0) {\\n"";
			code += ""		TRANSFORM[1].xyz = normalize(VELOCITY);\\n"";
			code += ""	} else {\\n"";
			code += ""		TRANSFORM[1].xyz = normalize(TRANSFORM[1].xyz);\\n"";
			code += ""	}\\n"";
			code += ""	TRANSFORM[0].xyz = normalize(cross(TRANSFORM[1].xyz, TRANSFORM[2].xyz));\\n"";
			code += ""	TRANSFORM[2] = vec4(0.0, 0.0, 1.0, 0.0);\\n"";
		} else {
			code += ""	TRANSFORM[0] = vec4(cos(CUSTOM.x), -sin(CUSTOM.x), 0.0, 0.0);\\n"";
			code += ""	TRANSFORM[1] = vec4(sin(CUSTOM.x), cos(CUSTOM.x), 0.0, 0.0);\\n"";
			code += ""	TRANSFORM[2] = vec4(0.0, 0.0, 1.0, 0.0);\\n"";
		}

	} else {
		// orient particle Y towards velocity
		if (flags[FLAG_ALIGN_Y_TO_VELOCITY]) {
			code += ""	if (length(VELOCITY) > 0.0) {\\n"";
			code += ""		TRANSFORM[1].xyz = normalize(VELOCITY);\\n"";
			code += ""	} else {\\n"";
			code += ""		TRANSFORM[1].xyz = normalize(TRANSFORM[1].xyz);\\n"";
			code += ""	}\\n"";
			code += ""	if (TRANSFORM[1].xyz == normalize(TRANSFORM[0].xyz)) {\\n"";
			code += ""		TRANSFORM[0].xyz = normalize(cross(normalize(TRANSFORM[1].xyz), normalize(TRANSFORM[2].xyz)));\\n"";
			code += ""		TRANSFORM[2].xyz = normalize(cross(normalize(TRANSFORM[0].xyz), normalize(TRANSFORM[1].xyz)));\\n"";
			code += ""	} else {\\n"";
			code += ""		TRANSFORM[2].xyz = normalize(cross(normalize(TRANSFORM[0].xyz), normalize(TRANSFORM[1].xyz)));\\n"";
			code += ""		TRANSFORM[0].xyz = normalize(cross(normalize(TRANSFORM[1].xyz), normalize(TRANSFORM[2].xyz)));\\n"";
			code += ""	}\\n"";
		} else {
			code += ""	TRANSFORM[0].xyz = normalize(TRANSFORM[0].xyz);\\n"";
			code += ""	TRANSFORM[1].xyz = normalize(TRANSFORM[1].xyz);\\n"";
			code += ""	TRANSFORM[2].xyz = normalize(TRANSFORM[2].xyz);\\n"";
		}
		// turn particle by rotation in Y
		if (flags[FLAG_ROTATE_Y]) {
			code += ""	TRANSFORM = TRANSFORM * mat4(vec4(cos(CUSTOM.x), 0.0, -sin(CUSTOM.x), 0.0), vec4(0.0, 1.0, 0.0, 0.0), vec4(sin(CUSTOM.x), 0.0, cos(CUSTOM.x), 0.0), vec4(0.0, 0.0, 0.0, 1.0));\\n"";
		}
	}
	//scale by scale
	code += ""	float base_scale = tex_scale * mix(scale, 1.0, scale_random * scale_rand);\\n"";
	code += ""	if (base_scale < 0.000001) {\\n"";
	code += ""		base_scale = 0.000001;\\n"";
	code += ""	}\\n"";
	if (trail_size_modifier.is_valid()) {
		code += ""	if (trail_divisor > 1) {\\n"";
		code += ""		base_scale *= textureLod(trail_size_modifier, vec2(float(int(NUMBER) % trail_divisor) / float(trail_divisor - 1), 0.0), 0.0).r;\\n"";
		code += ""	}\\n"";
	}

	code += ""	TRANSFORM[0].xyz *= base_scale;\\n"";
	code += ""	TRANSFORM[1].xyz *= base_scale;\\n"";
	code += ""	TRANSFORM[2].xyz *= base_scale;\\n"";
	if (flags[FLAG_DISABLE_Z]) {
		code += ""	VELOCITY.z = 0.0;\\n"";
		code += ""	TRANSFORM[3].z = 0.0;\\n"";
	}
	code += ""	if (CUSTOM.y > CUSTOM.w) {"";
	code += ""		ACTIVE = false;\\n"";
	code += ""	}\\n"";
	code += ""}\\n"";
	code += ""\\n"";

	ShaderData shader_data;
	shader_data.shader = VS::get_singleton()->shader_create();
	shader_data.users = 1;

	VS::get_singleton()->shader_set_code(shader_data.shader, code);

	shader_map[mk] = shader_data;

	VS::get_singleton()->material_set_shader(_get_material(), shader_data.shader);
}

void ParticlesMaterial::flush_changes() {

	if (material_mutex)
		material_mutex->lock();

	while (dirty_materials->first()) {

		dirty_materials->first()->self()->_update_shader();
	}

	if (material_mutex)
		material_mutex->unlock();
}

void ParticlesMaterial::_queue_shader_change() {

	if (material_mutex)
		material_mutex->lock();

	if (!element.in_list()) {
		dirty_materials->add(&element);
	}

	if (material_mutex)
		material_mutex->unlock();
}

bool ParticlesMaterial::_is_shader_dirty() const {

	bool dirty = false;

	if (material_mutex)
		material_mutex->lock();

	dirty = element.in_list();

	if (material_mutex)
		material_mutex->unlock();

	return dirty;
}

void ParticlesMaterial::set_direction(Vector3 p_direction) {

	direction = p_direction;
	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->direction, direction);
}

Vector3 ParticlesMaterial::get_direction() const {

	return direction;
}

void ParticlesMaterial::set_spread(float p_spread) {

	spread = p_spread;
	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->spread, p_spread);
}

float ParticlesMaterial::get_spread() const {

	return spread;
}

void ParticlesMaterial::set_flatness(float p_flatness) {

	flatness = p_flatness;
	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->flatness, p_flatness);
}
float ParticlesMaterial::get_flatness() const {

	return flatness;
}

void ParticlesMaterial::set_param(Parameter p_param, float p_value) {

	ERR_FAIL_INDEX(p_param, PARAM_MAX);

	parameters[p_param] = p_value;

	switch (p_param) {
		case PARAM_INITIAL_LINEAR_VELOCITY: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->initial_linear_velocity, p_value);
		} break;
		case PARAM_ANGULAR_VELOCITY: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->angular_velocity, p_value);
		} break;
		case PARAM_ORBIT_VELOCITY: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->orbit_velocity, p_value);
		} break;
		case PARAM_LINEAR_ACCEL: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->linear_accel, p_value);
		} break;
		case PARAM_RADIAL_ACCEL: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->radial_accel, p_value);
		} break;
		case PARAM_TANGENTIAL_ACCEL: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->tangent_accel, p_value);
		} break;
		case PARAM_DAMPING: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->damping, p_value);
		} break;
		case PARAM_ANGLE: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->initial_angle, p_value);
		} break;
		case PARAM_SCALE: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->scale, p_value);
		} break;
		case PARAM_HUE_VARIATION: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->hue_variation, p_value);
		} break;
		case PARAM_ANIM_SPEED: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->anim_speed, p_value);
		} break;
		case PARAM_ANIM_OFFSET: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->anim_offset, p_value);
		} break;
		case PARAM_MAX: break; // Can't happen, but silences warning
	}
}
float ParticlesMaterial::get_param(Parameter p_param) const {

	ERR_FAIL_INDEX_V(p_param, PARAM_MAX, 0);

	return parameters[p_param];
}

void ParticlesMaterial::set_param_randomness(Parameter p_param, float p_value) {

	ERR_FAIL_INDEX(p_param, PARAM_MAX);

	randomness[p_param] = p_value;

	switch (p_param) {
		case PARAM_INITIAL_LINEAR_VELOCITY: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->initial_linear_velocity_random, p_value);
		} break;
		case PARAM_ANGULAR_VELOCITY: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->angular_velocity_random, p_value);
		} break;
		case PARAM_ORBIT_VELOCITY: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->orbit_velocity_random, p_value);
		} break;
		case PARAM_LINEAR_ACCEL: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->linear_accel_random, p_value);
		} break;
		case PARAM_RADIAL_ACCEL: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->radial_accel_random, p_value);
		} break;
		case PARAM_TANGENTIAL_ACCEL: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->tangent_accel_random, p_value);
		} break;
		case PARAM_DAMPING: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->damping_random, p_value);
		} break;
		case PARAM_ANGLE: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->initial_angle_random, p_value);
		} break;
		case PARAM_SCALE: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->scale_random, p_value);
		} break;
		case PARAM_HUE_VARIATION: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->hue_variation_random, p_value);
		} break;
		case PARAM_ANIM_SPEED: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->anim_speed_random, p_value);
		} break;
		case PARAM_ANIM_OFFSET: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->anim_offset_random, p_value);
		} break;
		case PARAM_MAX: break; // Can't happen, but silences warning
	}
}
float ParticlesMaterial::get_param_randomness(Parameter p_param) const {

	ERR_FAIL_INDEX_V(p_param, PARAM_MAX, 0);

	return randomness[p_param];
}

static void _adjust_curve_range(const Ref<Texture2D> &p_texture, float p_min, float p_max) {

	Ref<CurveTexture> curve_tex = p_texture;
	if (!curve_tex.is_valid())
		return;

	curve_tex->ensure_default_setup(p_min, p_max);
}

void ParticlesMaterial::set_param_texture(Parameter p_param, const Ref<Texture2D> &p_texture) {

	ERR_FAIL_INDEX(p_param, PARAM_MAX);

	tex_parameters[p_param] = p_texture;

	switch (p_param) {
		case PARAM_INITIAL_LINEAR_VELOCITY: {
			//do none for this one
		} break;
		case PARAM_ANGULAR_VELOCITY: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->angular_velocity_texture, p_texture);
			_adjust_curve_range(p_texture, -360, 360);
		} break;
		case PARAM_ORBIT_VELOCITY: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->orbit_velocity_texture, p_texture);
			_adjust_curve_range(p_texture, -500, 500);
		} break;
		case PARAM_LINEAR_ACCEL: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->linear_accel_texture, p_texture);
			_adjust_curve_range(p_texture, -200, 200);
		} break;
		case PARAM_RADIAL_ACCEL: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->radial_accel_texture, p_texture);
			_adjust_curve_range(p_texture, -200, 200);
		} break;
		case PARAM_TANGENTIAL_ACCEL: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->tangent_accel_texture, p_texture);
			_adjust_curve_range(p_texture, -200, 200);
		} break;
		case PARAM_DAMPING: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->damping_texture, p_texture);
			_adjust_curve_range(p_texture, 0, 100);
		} break;
		case PARAM_ANGLE: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->angle_texture, p_texture);
			_adjust_curve_range(p_texture, -360, 360);
		} break;
		case PARAM_SCALE: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->scale_texture, p_texture);
			_adjust_curve_range(p_texture, 0, 1);
		} break;
		case PARAM_HUE_VARIATION: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->hue_variation_texture, p_texture);
			_adjust_curve_range(p_texture, -1, 1);
		} break;
		case PARAM_ANIM_SPEED: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->anim_speed_texture, p_texture);
			_adjust_curve_range(p_texture, 0, 200);
		} break;
		case PARAM_ANIM_OFFSET: {
			VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->anim_offset_texture, p_texture);
		} break;
		case PARAM_MAX: break; // Can't happen, but silences warning
	}

	_queue_shader_change();
}
Ref<Texture2D> ParticlesMaterial::get_param_texture(Parameter p_param) const {

	ERR_FAIL_INDEX_V(p_param, PARAM_MAX, Ref<Texture2D>());

	return tex_parameters[p_param];
}

void ParticlesMaterial::set_color(const Color &p_color) {

	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->color, p_color);
	color = p_color;
}

Color ParticlesMaterial::get_color() const {

	return color;
}

void ParticlesMaterial::set_color_ramp(const Ref<Texture2D> &p_texture) {

	color_ramp = p_texture;
	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->color_ramp, p_texture);
	_queue_shader_change();
	_change_notify();
}

Ref<Texture2D> ParticlesMaterial::get_color_ramp() const {

	return color_ramp;
}

void ParticlesMaterial::set_flag(Flags p_flag, bool p_enable) {
	ERR_FAIL_INDEX(p_flag, FLAG_MAX);
	flags[p_flag] = p_enable;
	_queue_shader_change();
	if (p_flag == FLAG_DISABLE_Z) {
		_change_notify();
	}
}

bool ParticlesMaterial::get_flag(Flags p_flag) const {
	ERR_FAIL_INDEX_V(p_flag, FLAG_MAX, false);
	return flags[p_flag];
}

void ParticlesMaterial::set_emission_shape(EmissionShape p_shape) {
	ERR_FAIL_INDEX(p_shape, EMISSION_SHAPE_MAX);
	emission_shape = p_shape;
	_change_notify();
	_queue_shader_change();
}

void ParticlesMaterial::set_emission_sphere_radius(float p_radius) {

	emission_sphere_radius = p_radius;
	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_sphere_radius, p_radius);
}

void ParticlesMaterial::set_emission_box_extents(Vector3 p_extents) {

	emission_box_extents = p_extents;
	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_box_extents, p_extents);
}

void ParticlesMaterial::set_emission_point_texture(const Ref<Texture2D> &p_points) {

	emission_point_texture = p_points;
	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_texture_points, p_points);
}

void ParticlesMaterial::set_emission_normal_texture(const Ref<Texture2D> &p_normals) {

	emission_normal_texture = p_normals;
	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_texture_normal, p_normals);
}

void ParticlesMaterial::set_emission_color_texture(const Ref<Texture2D> &p_colors) {

	emission_color_texture = p_colors;
	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_texture_color, p_colors);
	_queue_shader_change();
}

void ParticlesMaterial::set_emission_point_count(int p_count) {

	emission_point_count = p_count;
	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->emission_texture_point_count, p_count);
}

ParticlesMaterial::EmissionShape ParticlesMaterial::get_emission_shape() const {

	return emission_shape;
}

float ParticlesMaterial::get_emission_sphere_radius() const {

	return emission_sphere_radius;
}
Vector3 ParticlesMaterial::get_emission_box_extents() const {

	return emission_box_extents;
}
Ref<Texture2D> ParticlesMaterial::get_emission_point_texture() const {

	return emission_point_texture;
}
Ref<Texture2D> ParticlesMaterial::get_emission_normal_texture() const {

	return emission_normal_texture;
}

Ref<Texture2D> ParticlesMaterial::get_emission_color_texture() const {

	return emission_color_texture;
}

int ParticlesMaterial::get_emission_point_count() const {

	return emission_point_count;
}

void ParticlesMaterial::set_trail_divisor(int p_divisor) {

	trail_divisor = p_divisor;
	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->trail_divisor, p_divisor);
}

int ParticlesMaterial::get_trail_divisor() const {

	return trail_divisor;
}

void ParticlesMaterial::set_trail_size_modifier(const Ref<CurveTexture> &p_trail_size_modifier) {

	trail_size_modifier = p_trail_size_modifier;

	Ref<CurveTexture> curve = trail_size_modifier;
	if (curve.is_valid()) {
		curve->ensure_default_setup();
	}

	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->trail_size_modifier, curve);
	_queue_shader_change();
}

Ref<CurveTexture> ParticlesMaterial::get_trail_size_modifier() const {

	return trail_size_modifier;
}

void ParticlesMaterial::set_trail_color_modifier(const Ref<GradientTexture> &p_trail_color_modifier) {

	trail_color_modifier = p_trail_color_modifier;
	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->trail_color_modifier, p_trail_color_modifier);
	_queue_shader_change();
}

Ref<GradientTexture> ParticlesMaterial::get_trail_color_modifier() const {

	return trail_color_modifier;
}

void ParticlesMaterial::set_gravity(const Vector3 &p_gravity) {

	gravity = p_gravity;
	Vector3 gset = gravity;
	if (gset == Vector3()) {
		gset = Vector3(0, -0.000001, 0); //as gravity is used as upvector in some calculations
	}
	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->gravity, gset);
}

Vector3 ParticlesMaterial::get_gravity() const {

	return gravity;
}

void ParticlesMaterial::set_lifetime_randomness(float p_lifetime) {

	lifetime_randomness = p_lifetime;
	VisualServer::get_singleton()->material_set_param(_get_material(), shader_names->lifetime_randomness, lifetime_randomness);
}

float ParticlesMaterial::get_lifetime_randomness() const {

	return lifetime_randomness;
}

RID ParticlesMaterial::get_shader_rid() const {

	ERR_FAIL_COND_V(!shader_map.has(current_key), RID());
	return shader_map[current_key].shader;
}

void ParticlesMaterial::_validate_property(PropertyInfo &property) const {

	if (property.name == ""color"" && color_ramp.is_valid()) {
		property.usage = 0;
	}

	if (property.name == ""emission_sphere_radius"" && emission_shape != EMISSION_SHAPE_SPHERE) {
		property.usage = 0;
	}

	if (property.name == ""emission_box_extents"" && emission_shape != EMISSION_SHAPE_BOX) {
		property.usage = 0;
	}

	if ((property.name == ""emission_point_texture"" || property.name == ""emission_color_texture"") && (emission_shape < EMISSION_SHAPE_POINTS)) {
		property.usage = 0;
	}

	if (property.name == ""emission_normal_texture"" && emission_shape != EMISSION_SHAPE_DIRECTED_POINTS) {
		property.usage = 0;
	}

	if (property.name == ""emission_point_count"" && (emission_shape != EMISSION_SHAPE_POINTS && emission_shape != EMISSION_SHAPE_DIRECTED_POINTS)) {
		property.usage = 0;
	}

	if (property.name.begins_with(""orbit_"") && !flags[FLAG_DISABLE_Z]) {
		property.usage = 0;
	}
}

Shader::Mode ParticlesMaterial::get_shader_mode() const {

	return Shader::MODE_PARTICLES;
}

void ParticlesMaterial::_bind_methods() {

	ClassDB::bind_method(D_METHOD(""set_direction"", ""degrees""), &ParticlesMaterial::set_direction);
	ClassDB::bind_method(D_METHOD(""get_direction""), &ParticlesMaterial::get_direction);

	ClassDB::bind_method(D_METHOD(""set_spread"", ""degrees""), &ParticlesMaterial::set_spread);
	ClassDB::bind_method(D_METHOD(""get_spread""), &ParticlesMaterial::get_spread);

	ClassDB::bind_method(D_METHOD(""set_flatness"", ""amount""), &ParticlesMaterial::set_flatness);
	ClassDB::bind_method(D_METHOD(""get_flatness""), &ParticlesMaterial::get_flatness);

	ClassDB::bind_method(D_METHOD(""set_param"", ""param"", ""value""), &ParticlesMaterial::set_param);
	ClassDB::bind_method(D_METHOD(""get_param"", ""param""), &ParticlesMaterial::get_param);

	ClassDB::bind_method(D_METHOD(""set_param_randomness"", ""param"", ""randomness""), &ParticlesMaterial::set_param_randomness);
	ClassDB::bind_method(D_METHOD(""get_param_randomness"", ""param""), &ParticlesMaterial::get_param_randomness);

	ClassDB::bind_method(D_METHOD(""set_param_texture"", ""param"", ""texture""), &ParticlesMaterial::set_param_texture);
	ClassDB::bind_method(D_METHOD(""get_param_texture"", ""param""), &ParticlesMaterial::get_param_texture);

	ClassDB::bind_method(D_METHOD(""set_color"", ""color""), &ParticlesMaterial::set_color);
	ClassDB::bind_method(D_METHOD(""get_color""), &ParticlesMaterial::get_color);

	ClassDB::bind_method(D_METHOD(""set_color_ramp"", ""ramp""), &ParticlesMaterial::set_color_ramp);
	ClassDB::bind_method(D_METHOD(""get_color_ramp""), &ParticlesMaterial::get_color_ramp);

	ClassDB::bind_method(D_METHOD(""set_flag"", ""flag"", ""enable""), &ParticlesMaterial::set_flag);
	ClassDB::bind_method(D_METHOD(""get_flag"", ""flag""), &ParticlesMaterial::get_flag);

	ClassDB::bind_method(D_METHOD(""set_emission_shape"", ""shape""), &ParticlesMaterial::set_emission_shape);
	ClassDB::bind_method(D_METHOD(""get_emission_shape""), &ParticlesMaterial::get_emission_shape);

	ClassDB::bind_method(D_METHOD(""set_emission_sphere_radius"", ""radius""), &ParticlesMaterial::set_emission_sphere_radius);
	ClassDB::bind_method(D_METHOD(""get_emission_sphere_radius""), &ParticlesMaterial::get_emission_sphere_radius);

	ClassDB::bind_method(D_METHOD(""set_emission_box_extents"", ""extents""), &ParticlesMaterial::set_emission_box_extents);
	ClassDB::bind_method(D_METHOD(""get_emission_box_extents""), &ParticlesMaterial::get_emission_box_extents);

	ClassDB::bind_method(D_METHOD(""set_emission_point_texture"", ""texture""), &ParticlesMaterial::set_emission_point_texture);
	ClassDB::bind_method(D_METHOD(""get_emission_point_texture""), &ParticlesMaterial::get_emission_point_texture);

	ClassDB::bind_method(D_METHOD(""set_emission_normal_texture"", ""texture""), &ParticlesMaterial::set_emission_normal_texture);
	ClassDB::bind_method(D_METHOD(""get_emission_normal_texture""), &ParticlesMaterial::get_emission_normal_texture);

	ClassDB::bind_method(D_METHOD(""set_emission_color_texture"", ""texture""), &ParticlesMaterial::set_emission_color_texture);
	ClassDB::bind_method(D_METHOD(""get_emission_color_texture""), &ParticlesMaterial::get_emission_color_texture);

	ClassDB::bind_method(D_METHOD(""set_emission_point_count"", ""point_count""), &ParticlesMaterial::set_emission_point_count);
	ClassDB::bind_method(D_METHOD(""get_emission_point_count""), &ParticlesMaterial::get_emission_point_count);

	ClassDB::bind_method(D_METHOD(""set_trail_divisor"", ""divisor""), &ParticlesMaterial::set_trail_divisor);
	ClassDB::bind_method(D_METHOD(""get_trail_divisor""), &ParticlesMaterial::get_trail_divisor);

	ClassDB::bind_method(D_METHOD(""set_trail_size_modifier"", ""texture""), &ParticlesMaterial::set_trail_size_modifier);
	ClassDB::bind_method(D_METHOD(""get_trail_size_modifier""), &ParticlesMaterial::get_trail_size_modifier);

	ClassDB::bind_method(D_METHOD(""set_trail_color_modifier"", ""texture""), &ParticlesMaterial::set_trail_color_modifier);
	ClassDB::bind_method(D_METHOD(""get_trail_color_modifier""), &ParticlesMaterial::get_trail_color_modifier);

	ClassDB::bind_method(D_METHOD(""get_gravity""), &ParticlesMaterial::get_gravity);
	ClassDB::bind_method(D_METHOD(""set_gravity"", ""accel_vec""), &ParticlesMaterial::set_gravity);

	ClassDB::bind_method(D_METHOD(""set_lifetime_randomness"", ""randomness""), &ParticlesMaterial::set_lifetime_randomness);
	ClassDB::bind_method(D_METHOD(""get_lifetime_randomness""), &ParticlesMaterial::get_lifetime_randomness);

	ADD_GROUP(""Time"", """");
	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, ""lifetime_randomness"", PROPERTY_HINT_RANGE, ""0,1,0.01""), ""set_lifetime_randomness"", ""get_lifetime_randomness"");
	ADD_GROUP(""Trail"", ""trail_"");
	ADD_PROPERTY(PropertyInfo(Variant::INT, ""trail_divisor"", PROPERTY_HINT_RANGE, ""1,1000000,1""), ""set_trail_divisor"", ""get_trail_divisor"");
	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, ""trail_size_modifier"", PROPERTY_HINT_RESOURCE_TYPE, ""CurveTexture""), ""set_trail_size_modifier"", ""get_trail_size_modifier"");
	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, ""trail_color_modifier"", PROPERTY_HINT_RESOURCE_TYPE, ""GradientTexture""), ""set_trail_color_modifier"", ""get_trail_color_modifier"");
	ADD_GROUP(""Emission Shape"", ""emission_"");
	ADD_PROPERTY(PropertyInfo(Variant::INT, ""emission_shape"", PROPERTY_HINT_ENUM, ""Point,Sphere,Box,Points,Directed Points""), ""set_emission_shape"", ""get_emission_shape"");
	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, ""emission_sphere_radius"", PROPERTY_HINT_RANGE, ""0.01,128,0.01,or_greater""), ""set_emission_sphere_radius"", ""get_emission_sphere_radius"");
	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, ""emission_box_extents""), ""set_emission_box_extents"", ""get_emission_box_extents"");
	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, ""emission_point_texture"", PROPERTY_HINT_RESOURCE_TYPE, ""Texture2D""), ""set_emission_point_texture"", ""get_emission_point_texture"");
	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, ""emission_normal_texture"", PROPERTY_HINT_RESOURCE_TYPE, ""Texture2D""), ""set_emission_normal_texture"", ""get_emission_normal_texture"");
	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, ""emission_color_texture"", PROPERTY_HINT_RESOURCE_TYPE, ""Texture2D""), ""set_emission_color_texture"", ""get_emission_color_texture"");
	ADD_PROPERTY(PropertyInfo(Variant::INT, ""emission_point_count"", PROPERTY_HINT_RANGE, ""0,1000000,1""), ""set_emission_point_count"", ""get_emission_point_count"");
	ADD_GROUP(""Flags"", ""flag_"");
	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, ""flag_align_y""), ""set_flag"", ""get_flag"", FLAG_ALIGN_Y_TO_VELOCITY);
	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, ""flag_rotate_y""), ""set_flag"", ""get_flag"", FLAG_ROTATE_Y);
	ADD_PROPERTYI(PropertyInfo(Variant::BOOL, ""flag_disable_z""), ""set_flag"", ""get_flag"", FLAG_DISABLE_Z);
	ADD_GROUP(""Direction"", """");
	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, ""direction""), ""set_direction"", ""get_direction"");
	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, ""spread"", PROPERTY_HINT_RANGE, ""0,180,0.01""), ""set_spread"", ""get_spread"");
	ADD_PROPERTY(PropertyInfo(Variant::FLOAT, ""flatness"", PROPERTY_HINT_RANGE, ""0,1,0.01""), ""set_flatness"", ""get_flatness"");
	ADD_GROUP(""Gravity"", """");
	ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, ""gravity""), ""set_gravity"", ""get_gravity"");
	ADD_GROUP(""Initial Velocity"", ""initial_"");
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""initial_velocity"", PROPERTY_HINT_RANGE, ""0,1000,0.01,or_lesser,or_greater""), ""set_param"", ""get_param"", PARAM_INITIAL_LINEAR_VELOCITY);
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""initial_velocity_random"", PROPERTY_HINT_RANGE, ""0,1,0.01""), ""set_param_randomness"", ""get_param_randomness"", PARAM_INITIAL_LINEAR_VELOCITY);
	ADD_GROUP(""Angular Velocity"", ""angular_"");
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""angular_velocity"", PROPERTY_HINT_RANGE, ""-720,720,0.01,or_lesser,or_greater""), ""set_param"", ""get_param"", PARAM_ANGULAR_VELOCITY);
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""angular_velocity_random"", PROPERTY_HINT_RANGE, ""0,1,0.01""), ""set_param_randomness"", ""get_param_randomness"", PARAM_ANGULAR_VELOCITY);
	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, ""angular_velocity_curve"", PROPERTY_HINT_RESOURCE_TYPE, ""CurveTexture""), ""set_param_texture"", ""get_param_texture"", PARAM_ANGULAR_VELOCITY);
	ADD_GROUP(""Orbit Velocity"", ""orbit_"");
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""orbit_velocity"", PROPERTY_HINT_RANGE, ""-1000,1000,0.01,or_lesser,or_greater""), ""set_param"", ""get_param"", PARAM_ORBIT_VELOCITY);
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""orbit_velocity_random"", PROPERTY_HINT_RANGE, ""0,1,0.01""), ""set_param_randomness"", ""get_param_randomness"", PARAM_ORBIT_VELOCITY);
	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, ""orbit_velocity_curve"", PROPERTY_HINT_RESOURCE_TYPE, ""CurveTexture""), ""set_param_texture"", ""get_param_texture"", PARAM_ORBIT_VELOCITY);
	ADD_GROUP(""Linear Accel"", ""linear_"");
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""linear_accel"", PROPERTY_HINT_RANGE, ""-100,100,0.01,or_lesser,or_greater""), ""set_param"", ""get_param"", PARAM_LINEAR_ACCEL);
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""linear_accel_random"", PROPERTY_HINT_RANGE, ""0,1,0.01""), ""set_param_randomness"", ""get_param_randomness"", PARAM_LINEAR_ACCEL);
	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, ""linear_accel_curve"", PROPERTY_HINT_RESOURCE_TYPE, ""CurveTexture""), ""set_param_texture"", ""get_param_texture"", PARAM_LINEAR_ACCEL);
	ADD_GROUP(""Radial Accel"", ""radial_"");
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""radial_accel"", PROPERTY_HINT_RANGE, ""-100,100,0.01,or_lesser,or_greater""), ""set_param"", ""get_param"", PARAM_RADIAL_ACCEL);
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""radial_accel_random"", PROPERTY_HINT_RANGE, ""0,1,0.01""), ""set_param_randomness"", ""get_param_randomness"", PARAM_RADIAL_ACCEL);
	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, ""radial_accel_curve"", PROPERTY_HINT_RESOURCE_TYPE, ""CurveTexture""), ""set_param_texture"", ""get_param_texture"", PARAM_RADIAL_ACCEL);
	ADD_GROUP(""Tangential Accel"", ""tangential_"");
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""tangential_accel"", PROPERTY_HINT_RANGE, ""-100,100,0.01,or_lesser,or_greater""), ""set_param"", ""get_param"", PARAM_TANGENTIAL_ACCEL);
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""tangential_accel_random"", PROPERTY_HINT_RANGE, ""0,1,0.01""), ""set_param_randomness"", ""get_param_randomness"", PARAM_TANGENTIAL_ACCEL);
	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, ""tangential_accel_curve"", PROPERTY_HINT_RESOURCE_TYPE, ""CurveTexture""), ""set_param_texture"", ""get_param_texture"", PARAM_TANGENTIAL_ACCEL);
	ADD_GROUP(""Damping"", """");
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""damping"", PROPERTY_HINT_RANGE, ""0,100,0.01,or_greater""), ""set_param"", ""get_param"", PARAM_DAMPING);
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""damping_random"", PROPERTY_HINT_RANGE, ""0,1,0.01""), ""set_param_randomness"", ""get_param_randomness"", PARAM_DAMPING);
	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, ""damping_curve"", PROPERTY_HINT_RESOURCE_TYPE, ""CurveTexture""), ""set_param_texture"", ""get_param_texture"", PARAM_DAMPING);
	ADD_GROUP(""Angle"", """");
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""angle"", PROPERTY_HINT_RANGE, ""-720,720,0.1,or_lesser,or_greater""), ""set_param"", ""get_param"", PARAM_ANGLE);
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""angle_random"", PROPERTY_HINT_RANGE, ""0,1,0.01""), ""set_param_randomness"", ""get_param_randomness"", PARAM_ANGLE);
	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, ""angle_curve"", PROPERTY_HINT_RESOURCE_TYPE, ""CurveTexture""), ""set_param_texture"", ""get_param_texture"", PARAM_ANGLE);
	ADD_GROUP(""Scale"", """");
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""scale"", PROPERTY_HINT_RANGE, ""0,1000,0.01,or_greater""), ""set_param"", ""get_param"", PARAM_SCALE);
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""scale_random"", PROPERTY_HINT_RANGE, ""0,1,0.01""), ""set_param_randomness"", ""get_param_randomness"", PARAM_SCALE);
	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, ""scale_curve"", PROPERTY_HINT_RESOURCE_TYPE, ""CurveTexture""), ""set_param_texture"", ""get_param_texture"", PARAM_SCALE);
	ADD_GROUP(""Color"", """");
	ADD_PROPERTY(PropertyInfo(Variant::COLOR, ""color""), ""set_color"", ""get_color"");
	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, ""color_ramp"", PROPERTY_HINT_RESOURCE_TYPE, ""GradientTexture""), ""set_color_ramp"", ""get_color_ramp"");

	ADD_GROUP(""Hue Variation"", ""hue_"");
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""hue_variation"", PROPERTY_HINT_RANGE, ""-1,1,0.01""), ""set_param"", ""get_param"", PARAM_HUE_VARIATION);
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""hue_variation_random"", PROPERTY_HINT_RANGE, ""0,1,0.01""), ""set_param_randomness"", ""get_param_randomness"", PARAM_HUE_VARIATION);
	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, ""hue_variation_curve"", PROPERTY_HINT_RESOURCE_TYPE, ""CurveTexture""), ""set_param_texture"", ""get_param_texture"", PARAM_HUE_VARIATION);
	ADD_GROUP(""Animation"", ""anim_"");
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""anim_speed"", PROPERTY_HINT_RANGE, ""0,128,0.01,or_greater""), ""set_param"", ""get_param"", PARAM_ANIM_SPEED);
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""anim_speed_random"", PROPERTY_HINT_RANGE, ""0,1,0.01""), ""set_param_randomness"", ""get_param_randomness"", PARAM_ANIM_SPEED);
	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, ""anim_speed_curve"", PROPERTY_HINT_RESOURCE_TYPE, ""CurveTexture""), ""set_param_texture"", ""get_param_texture"", PARAM_ANIM_SPEED);
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""anim_offset"", PROPERTY_HINT_RANGE, ""0,1,0.01""), ""set_param"", ""get_param"", PARAM_ANIM_OFFSET);
	ADD_PROPERTYI(PropertyInfo(Variant::FLOAT, ""anim_offset_random"", PROPERTY_HINT_RANGE, ""0,1,0.01""), ""set_param_randomness"", ""get_param_randomness"", PARAM_ANIM_OFFSET);
	ADD_PROPERTYI(PropertyInfo(Variant::OBJECT, ""anim_offset_curve"", PROPERTY_HINT_RESOURCE_TYPE, ""CurveTexture""), ""set_param_texture"", ""get_param_texture"", PARAM_ANIM_OFFSET);

	BIND_ENUM_CONSTANT(PARAM_INITIAL_LINEAR_VELOCITY);
	BIND_ENUM_CONSTANT(PARAM_ANGULAR_VELOCITY);
	BIND_ENUM_CONSTANT(PARAM_ORBIT_VELOCITY);
	BIND_ENUM_CONSTANT(PARAM_LINEAR_ACCEL);
	BIND_ENUM_CONSTANT(PARAM_RADIAL_ACCEL);
	BIND_ENUM_CONSTANT(PARAM_TANGENTIAL_ACCEL);
	BIND_ENUM_CONSTANT(PARAM_DAMPING);
	BIND_ENUM_CONSTANT(PARAM_ANGLE);
	BIND_ENUM_CONSTANT(PARAM_SCALE);
	BIND_ENUM_CONSTANT(PARAM_HUE_VARIATION);
	BIND_ENUM_CONSTANT(PARAM_ANIM_SPEED);
	BIND_ENUM_CONSTANT(PARAM_ANIM_OFFSET);
	BIND_ENUM_CONSTANT(PARAM_MAX);

	BIND_ENUM_CONSTANT(FLAG_ALIGN_Y_TO_VELOCITY);
	BIND_ENUM_CONSTANT(FLAG_ROTATE_Y);
	BIND_ENUM_CONSTANT(FLAG_DISABLE_Z);
	BIND_ENUM_CONSTANT(FLAG_MAX);

	BIND_ENUM_CONSTANT(EMISSION_SHAPE_POINT);
	BIND_ENUM_CONSTANT(EMISSION_SHAPE_SPHERE);
	BIND_ENUM_CONSTANT(EMISSION_SHAPE_BOX);
	BIND_ENUM_CONSTANT(EMISSION_SHAPE_POINTS);
	BIND_ENUM_CONSTANT(EMISSION_SHAPE_DIRECTED_POINTS);
	BIND_ENUM_CONSTANT(EMISSION_SHAPE_MAX);
}

ParticlesMaterial::ParticlesMaterial() :
		element(this) {

	set_direction(Vector3(1, 0, 0));
	set_spread(45);
	set_flatness(0);
	set_param(PARAM_INITIAL_LINEAR_VELOCITY, 0);
	set_param(PARAM_ANGULAR_VELOCITY, 0);
	set_param(PARAM_ORBIT_VELOCITY, 0);
	set_param(PARAM_LINEAR_ACCEL, 0);
	set_param(PARAM_RADIAL_ACCEL, 0);
	set_param(PARAM_TANGENTIAL_ACCEL, 0);
	set_param(PARAM_DAMPING, 0);
	set_param(PARAM_ANGLE, 0);
	set_param(PARAM_SCALE, 1);
	set_param(PARAM_HUE_VARIATION, 0);
	set_param(PARAM_ANIM_SPEED, 0);
	set_param(PARAM_ANIM_OFFSET, 0);
	set_emission_shape(EMISSION_SHAPE_POINT);
	set_emission_sphere_radius(1);
	set_emission_box_extents(Vector3(1, 1, 1));
	set_trail_divisor(1);
	set_gravity(Vector3(0, -9.8, 0));
	set_lifetime_randomness(0);
	emission_point_count = 1;

	for (int i = 0; i < PARAM_MAX; i++) {
		set_param_randomness(Parameter(i), 0);
	}

	for (int i = 0; i < FLAG_MAX; i++) {
		flags[i] = false;
	}

	set_color(Color(1, 1, 1, 1));

	current_key.key = 0;
	current_key.invalid_key = 1;

	_queue_shader_change();
}

ParticlesMaterial::~ParticlesMaterial() {

	if (material_mutex)
		material_mutex->lock();

	if (shader_map.has(current_key)) {
		shader_map[current_key].users--;
		if (shader_map[current_key].users == 0) {
			//deallocate shader, as it's no longer in use
			VS::get_singleton()->free(shader_map[current_key].shader);
			shader_map.erase(current_key);
		}

		VS::get_singleton()->material_set_shader(_get_material(), RID());
	}

	if (material_mutex)
		material_mutex->unlock();
}
",16234,True,2773.0489694356,median
"[[release-notes-7.2.1]]
== {es} version 7.2.1

Also see <<breaking-changes-7.2,Breaking changes in 7.2>>.

[[enhancement-7.2.1]]
[float]
=== Enhancements

Infra/Core::
* Add default CLI JVM options {pull}44545[#44545] (issue: {issue}42021[#42021])

Infra/Plugins::
* Do not checksum all bytes at once in plugin install {pull}44649[#44649] (issue: {issue}44545[#44545])

Machine Learning::
* Improve message when native controller cannot connect {pull}43565[#43565] (issue: {issue}42341[#42341])
* Introduce a setting for the process connect timeout {pull}43234[#43234]

[[bug-7.2.1]]
[float]
=== Bug fixes

Analysis::
* Issue deprecation warnings for preconfigured delimited_payload_filter {pull}43684[#43684] (issues: {issue}26625[#26625], {issue}43568[#43568])

Authentication::
* Fix credential encoding for OIDC token request {pull}43808[#43808] (issue: {issue}43709[#43709])

Data Frame::
* Reorder format priorities in dest mapping {pull}43602[#43602]
* Adjust error message {pull}43455[#43455]
* Size the GET stats search by number of Ids requested {pull}43206[#43206] (issue: {issue}43203[#43203])

Distributed::
* Fix DefaultShardOperationFailedException subclass xcontent serialization {pull}43435[#43435] (issue: {issue}43423[#43423])

Engine::
* AsyncIOProcessor preserve thread context {pull}43729[#43729]

Features/CAT APIs::
* Fix indices shown in _cat/indices {pull}43286[#43286] (issues: {issue}33888[#33888], {issue}38824[#38824], {issue}39933[#39933])

Features/ILM::
* Account for node versions during allocation in ILM Shrink {pull}43300[#43300] (issue: {issue}41879[#41879])

Features/Indices APIs::
* Check shard limit after applying index templates {pull}44619[#44619] (issues: {issue}34021[#34021], {issue}44567[#44567], {issue}44619[#44619])
* Validate index settings after applying templates {pull}44612[#44612] (issues: {issue}34021[#34021], {issue}44567[#44567])
* Prevent NullPointerException in TransportRolloverAction {pull}43353[#43353] (issue: {issue}43296[#43296])

Infra/Packaging::
* Restore setting up temp dir for windows service {pull}44541[#44541]
* Fix the bundled jdk flag to be passed through windows startup {pull}43502[#43502]

Machine Learning::
* Fix datafeed checks when a concrete remote index is present {pull}43923[#43923]
* Don't persist model state at the end of lookback if the lookback did not generate any input {ml-pull}527[#527] (issue: {ml-issue}519[#519])
* Don't write model size stats when job is closed without any input {ml-pull}516[#516] (issue: {ml-issue}394[#394])

Mapping::
* Prevent types deprecation warning for indices.exists requests {pull}43963[#43963] (issue: {issue}43905[#43905])
* Add include_type_name in indices.exitst REST API spec {pull}43910[#43910] (issue: {issue}43905[#43905])
* Fix index_prefix sub field name on nested text fields {pull}43862[#43862] (issue: {issue}43741[#43741])

Network::
* Reconnect remote cluster when seeds are changed {pull}43379[#43379] (issue: {issue}37799[#37799])

SQL::
* Fix NPE in case of subsequent scrolled requests for a CSV/TSV formatted response {pull}43365[#43365] (issue: {issue}43327[#43327])
* Increase hard limit for sorting on aggregates {pull}43220[#43220] (issue: {issue}43168[#43168])

Search::
* Fix wrong logic in `match_phrase` query with multi-word synonyms {pull}43941[#43941] (issue: {issue}43308[#43308])
* Fix UOE on search requests that match a sparse role query {pull}43668[#43668] (issue: {issue}42857[#42857])
* Fix propagation of enablePositionIncrements in QueryStringQueryBuilder {pull}43578[#43578] (issue: {issue}43574[#43574])
* Fix round up of date range without rounding {pull}43303[#43303] (issue: {issue}43277[#43277])

Security::
* SecurityIndexSearcherWrapper doesn't always carry over caches and similarity {pull}43436[#43436]


[[release-notes-7.2.0]]
== {es} version 7.2.0

Also see <<breaking-changes-7.2,Breaking changes in 7.2>>.

[[breaking-7.2.0]]
[float]
=== Breaking changes

Cluster Coordination::
* Reject port ranges in `discovery.seed_hosts` {pull}41404[#41404] (issue: {issue}40786[#40786])


[[breaking-java-7.2.0]]
[float]
=== Breaking Java changes

Infra/Plugins::
* Remove IndexStore and DirectoryService {pull}42446[#42446]


[[deprecation-7.2.0]]
[float]
=== Deprecations

Authorization::
* Deprecate permission over aliases {pull}38059[#38059]

Features/Features::
* Add deprecation check for ILM poll interval <1s {pull}41096[#41096] (issue: {issue}39163[#39163])

Mapping::
* Enforce Completion Context Limit {pull}38675[#38675] (issue: {issue}32741[#32741])

Reindex::
* Reindex from remote deprecation of escaped index {pull}41005[#41005] (issue: {issue}40303[#40303])

Search::
* Deprecate using 0 value for `min_children` in `has_child` query #41548 {pull}41555[#41555] (issue: {issue}41548[#41548])
* Deprecate support for first line empty in msearch API {pull}41442[#41442] (issue: {issue}41011[#41011])

Security::
* Deprecate the native realm migration tool {pull}42142[#42142]

[[feature-7.2.0]]
[float]
=== New features

Authentication::
* Add an OpenID Connect authentication realm {pull}40674[#40674]

Distributed::
* Add support for replicating closed indices {pull}39499[#39499] (issues: {issue}33888[#33888], {issue}33903[#33903], {issue}37359[#37359], {issue}37413[#37413], {issue}38024[#38024], {issue}38326[#38326], {issue}38327[#38327], {issue}38329[#38329], {issue}38421[#38421], {issue}38631[#38631], {issue}38767[#38767], {issue}38854[#38854], {issue}38955[#38955], {issue}39006[#39006], {issue}39110[#39110], {issue}39186[#39186], {issue}39249[#39249], {issue}39364[#39364])

Infra/Scripting::
* Add painless string split function (splitOnToken) {pull}39772[#39772] (issue: {issue}20952[#20952])
* Add a Painless Context REST API {pull}39382[#39382]

Machine Learning::
* Add data frame feature {pull}38934[#38934]

Ranking::
* Expose proximity boosting {pull}39385[#39385] (issue: {issue}33382[#33382])
* Add randomScore function in script_score query {pull}40186[#40186] (issue: {issue}31461[#31461])

SQL::
* Add initial geo support {pull}42031[#42031] (issues: {issue}29872[#29872], {issue}37206[#37206])
* Implement CASE... WHEN... THEN... ELSE... END {pull}41349[#41349] (issue: {issue}36200[#36200])
* Introduce MAD (MedianAbsoluteDeviation) aggregation {pull}40048[#40048] (issue: {issue}39597[#39597])
* Introduce SQL TIME data type {pull}39802[#39802] (issue: {issue}38174[#38174])
* Introduce the columnar option for REST requests {pull}39287[#39287] (issue: {issue}37702[#37702])

Snapshot/Restore::
* Allow snapshotting replicated closed indices {pull}39644[#39644] (issue: {issue}33888[#33888])

Suggesters::
* Search as you type fieldmapper {pull}35600[#35600] (issue: {issue}33160[#33160])

Features/Ingest::
* Add HTML strip processor {pull}41888[#41888]

Search::
* Add an option to force the numeric type of a field sort {pull}38095[#38095] (issue: {issue}32601[#32601])


[[enhancement-7.2.0]]
[float]
=== Enhancements

Aggregations::
* Use the breadth first collection mode for significant terms aggs. {pull}29042[#29042] (issue: {issue}28652[#28652])
* Disallow null/empty or duplicate composite sources {pull}41359[#41359] (issue: {issue}32414[#32414])
* Move top-level pipeline aggs out of QuerySearchResult {pull}40319[#40319] (issue: {issue}40177[#40177])
* Remove throws IOException from PipelineAggregationBuilder#create {pull}40222[#40222]
* Better error messages when pipelines reference incompatible aggs {pull}40068[#40068] (issues: {issue}25273[#25273], {issue}30152[#30152])
* Do not allow Sampler to allocate more than maxDoc size, better CB accounting {pull}39381[#39381] (issue: {issue}34269[#34269])
* Force selection of calendar or fixed intervals in date histo agg {pull}33727[#33727]

Allocation::
* Reset failed allocation counter before executing routing commands {pull}41050[#41050] (issue: {issue}39546[#39546])
* Supporting automatic release of index blocks. Closes #39334 {pull}40338[#40338] (issue: {issue}39334[#39334])

Analysis::
* Add flag to declare token filters as updateable {pull}36103[#36103] (issue: {issue}29051[#29051])

Authentication::
* Hash token values for storage {pull}41792[#41792] (issues: {issue}39631[#39631], {issue}40765[#40765])
* Security Tokens moved to a new separate index {pull}40742[#40742] (issue: {issue}34454[#34454])
* Support concurrent refresh of refresh tokens {pull}39631[#39631] (issue: {issue}36872[#36872])
* Add enabled status for token and api key service {pull}38687[#38687] (issue: {issue}38535[#38535])

Authorization::
* Support mustache templates in role mappings {pull}39984[#39984] (issue: {issue}36567[#36567])
* Add .code_internal-* index pattern to kibana user {pull}42247[#42247]
* Add granular API key privileges {pull}41488[#41488] (issue: {issue}40031[#40031])
* Add Kibana application privileges for monitoring and ml reserved roles {pull}40651[#40651]
* Support roles with application privileges against wildcard applications {pull}40398[#40398]

CCR::
* Replay history of operations in remote recovery {pull}39153[#39153] (issues: {issue}35975[#35975], {issue}39000[#39000])

CRUD::
* Add details to BulkShardRequest#getDescription() {pull}41711[#41711]
* Add version-based validation to reindex requests {pull}38504[#38504] (issue: {issue}37855[#37855])

Cluster Coordination::
* Add GET /_cluster/master endpoint {pull}40047[#40047]
* Only connect to new nodes on new cluster state {pull}39629[#39629] (issues: {issue}29025[#29025], {issue}31547[#31547])
* Add has_voting_exclusions flag to cluster health output {pull}38568[#38568]

Data Frame::
* Persist and restore checkpoint and position {pull}41942[#41942] (issue: {issue}41752[#41752])
* Complete the Data Frame task on stop {pull}41752[#41752]
* Data Frame stop all {pull}41156[#41156]
* Data Frame HLRC Get Stats API {pull}40327[#40327]
* Data Frame HLRC Get API {pull}40209[#40209]
* Data Frame HLRC Preview API {pull}40206[#40206]
* Data Frame HLRC start & stop APIs {pull}40154[#40154] (issue: {issue}29546[#29546])
* Add Data Frame client to the Java HLRC {pull}39921[#39921]

Discovery-Plugins::
* Upgrade SDK and test discovery-ec2 credential providers {pull}41732[#41732]

Distributed::
* Prevent in-place downgrades and invalid upgrades {pull}41731[#41731]
* Add index name to cluster block exception {pull}41489[#41489] (issue: {issue}40870[#40870])
* Noop peer recoveries on closed index {pull}41400[#41400] (issue: {issue}33888[#33888])
* Do not trim unsafe commits when open readonly engine {pull}41041[#41041] (issue: {issue}33888[#33888])
* Avoid background sync on relocated primary {pull}40800[#40800] (issue: {issue}40731[#40731])
* No mapper service and index caches for replicated closed indices {pull}40423[#40423]
* Add support for replicating closed indices {pull}39499[#39499] (issues: {issue}33888[#33888], {issue}33903[#33903], {issue}37359[#37359], {issue}37413[#37413], {issue}38024[#38024], {issue}38326[#38326], {issue}38327[#38327], {issue}38329[#38329], {issue}38421[#38421], {issue}38631[#38631], {issue}38767[#38767], {issue}38854[#38854], {issue}38955[#38955], {issue}39006[#39006], {issue}39110[#39110], {issue}39186[#39186], {issue}39249[#39249], {issue}39364[#39364])

Docs Infrastructure::
* Docs: Simplifying setup by using module configuration variant syntax {pull}40879[#40879]

Engine::
* Use reader attributes to control term dict memory useage {pull}42838[#42838] (issue: {issue}38390[#38390])
* Simplify initialization of max_seq_no of updates {pull}41161[#41161] (issues: {issue}33842[#33842], {issue}40249[#40249])
* Adjust init map size of user data of index commit {pull}40965[#40965]
* Don't mark shard as refreshPending on stats fetching {pull}40458[#40458] (issues: {issue}33835[#33835], {issue}33847[#33847])
* Reject illegal flush parameters {pull}40213[#40213] (issue: {issue}36342[#36342])
* Always fail engine if delete operation fails {pull}40117[#40117] (issue: {issue}33256[#33256])
* Combine overriddenOps and skippedOps in translog {pull}39771[#39771] (issue: {issue}33317[#33317])
* Return cached segments stats if `include_unloaded_segments` is true {pull}39698[#39698] (issue: {issue}39512[#39512])
* Allow inclusion of unloaded segments in stats {pull}39512[#39512]
* Never block on scheduled refresh if a refresh is running {pull}39462[#39462]
* Expose external refreshes through the stats API {pull}38643[#38643] (issue: {issue}36712[#36712])
* Make setting index.translog.sync_interval be dynamic {pull}37382[#37382] (issue: {issue}32763[#32763])

Features/CAT APIs::
* Add start and stop time to cat recovery API {pull}40378[#40378]
* Return 0 for negative ""free"" and ""total"" memory reported by the OS {pull}42725[#42725] (issue: {issue}42157[#42157])

Features/Indices APIs::
* Introduce aliases version {pull}41397[#41397] (issue: {issue}41396[#41396])
* Improve error message for absence of indices {pull}39789[#39789] (issues: {issue}38964[#38964], {issue}39296[#39296])
* Improved error message for absence of indices closes #38964 {pull}39296[#39296]

Features/Java High Level REST Client::
* Added param ignore_throttled=false when indicesOptions.ignoreThrottle… {pull}42393[#42393] (issue: {issue}42358[#42358])
* Ignore 409 conflict in reindex responses {pull}39543[#39543]

Features/Monitoring::
* Add packaging to cluster stats response {pull}41048[#41048] (issue: {issue}39378[#39378])

Geo::
* Improve accuracy for Geo Centroid Aggregation {pull}41033[#41033] (issue: {issue}41032[#41032])
* Add support for z values to libs/geo classes {pull}38921[#38921]
* Add ST_WktToSQL function {pull}35416[#35416] (issue: {issue}29872[#29872])

Infra/Core::
* Validate non-secure settings are not in keystore {pull}42209[#42209] (issue: {issue}41831[#41831])
* Implement XContentParser.genericMap and XContentParser.genericMapOrdered methods {pull}42059[#42059]
* Remove manual parsing of JVM options {pull}41962[#41962] (issue: {issue}30684[#30684])
* Clarify some ToXContent implementations behaviour {pull}41000[#41000] (issue: {issue}16347[#16347])
* Remove String interning from `o.e.index.Index`. {pull}40350[#40350] (issue: {issue}40263[#40263])
* Do not swallow exceptions in TimedRunnable {pull}39856[#39856] (issue: {issue}36137[#36137])

Infra/Logging::
* Reduce garbage from allocations in DeprecationLogger {pull}38780[#38780] (issues: {issue}35754[#35754], {issue}37411[#37411], {issue}37530[#37530])

Infra/Packaging::
* Clearer error message - installing windows service {pull}33804[#33804]

Infra/Resiliency::
* Limit max direct memory size to half of heap size {pull}42006[#42006] (issues: {issue}41954[#41954], {issue}41962[#41962])

Infra/Scripting::
* Add implicit this for class binding in Painless {pull}40285[#40285]
* Whitelist geo methods for Painless {pull}40180[#40180] (issue: {issue}24946[#24946])

Machine Learning::
* Improve message misformation error in file structure finder {pull}42175[#42175]
* Improve hard_limit audit message {pull}42086[#42086] (issue: {issue}38034[#38034])
* Add validation that rejects duplicate detectors in PutJobAction {pull}40967[#40967] (issue: {issue}39704[#39704])
* Add created_by info to usage stats {pull}40518[#40518] (issue: {issue}38403[#38403])
* Data frame transforms config HLRC objects {pull}39691[#39691]
* Use scaling thread pool and xpack.ml.max_open_jobs cluster-wide dynamic {pull}39320[#39320] (issue: {issue}29809[#29809])
* Add task recovery on node change  {pull}39416[#39416]
* Stop tasks on failure {pull}39203[#39203]
* Add _preview endpoint {pull}38924[#38924]
* Use hardened compiler options to build 3rd party libraries {ml-pull}453[#453]
* Only select more complex trend models for forecasting if there is evidence that they are needed
{ml-pull}463[#463]
* Improve residual model selection {ml-pull}468[#468]
* Stop linking to libcrypt on Linux {ml-pull}480[#480]
* Improvements to hard_limit audit message {ml-pull}486[#486]
* Increase maximum forecast interval from 8 weeks to a limit based on the amount
of data seen, up to a maximum of 10 years {ml-pull}214[#214] and
{pull}41082[#41082] (issue: {issue}41103[#41103])

Mapping::
* Updates max dimensions for sparse_vector and dense_vector to 1024. {pull}40597[#40597] (issue: {issue}40492[#40492])
* Add ignore_above in ICUCollationKeywordFieldMapper {pull}40414[#40414] (issue: {issue}40413[#40413])
* Adding a soft limit to the field name length. Closes #33651 {pull}40309[#40309] (issue: {issue}33651[#33651])

Network::
* Update ciphers for TLSv1.3 and JDK11 if available {pull}42082[#42082] (issues: {issue}38646[#38646], {issue}41385[#41385], {issue}41808[#41808])
* Show SSL usage when security is not disabled {pull}40672[#40672] (issue: {issue}37433[#37433])
* Optimize Bulk Message Parsing and Message Length Parsing {pull}39634[#39634] (issue: {issue}39286[#39286])
* Netty transport accept plaintext connections {pull}39532[#39532] (issue: {issue}39531[#39531])
* Chunk + Throttle Netty Writes {pull}39286[#39286]

Ranking::
* Improve error message for ln/log with negative results in function score {pull}41609[#41609] (issue: {issue}41509[#41509])

Recovery::
* Peer recovery should flush at the end {pull}41660[#41660] (issues: {issue}33888[#33888], {issue}39588[#39588], {issue}40024[#40024])
* Peer recovery should not indefinitely retry on mapping error {pull}41099[#41099] (issue: {issue}40913[#40913])
* Init global checkpoint after copy commit in peer recovery {pull}40823[#40823] (issue: {issue}33888[#33888])
* Ensure sendBatch not called recursively {pull}39988[#39988]

Reindex::
* Reindex from Remote allow date math {pull}40303[#40303] (issue: {issue}23533[#23533])

SQL::
* Implement IIF(<cond>, <result1>, <result2>) {pull}41420[#41420] (issue: {issue}40917[#40917])
* Use field caps inside DESCRIBE TABLE as well {pull}41377[#41377] (issue: {issue}34071[#34071])
* Implement CURRENT_TIME/CURTIME functions {pull}40662[#40662] (issue: {issue}40648[#40648])
* Polish behavior of SYS TABLES command {pull}40535[#40535] (issue: {issue}40348[#40348])
* Adjust the precision and scale for drivers {pull}40467[#40467] (issue: {issue}40357[#40357])
* Polish parsing of CAST expression {pull}40428[#40428]
* Fix classpath discovery on Java 10+ {pull}40420[#40420] (issue: {issue}40388[#40388])
* Spec tests now use classpath discovery {pull}40388[#40388] (issue: {issue}40358[#40358])
* Implement `::` cast operator {pull}38774[#38774] (issue: {issue}38717[#38717])

Search::
* Fix range query edge cases {pull}41160[#41160] (issue: {issue}40937[#40937])
* Add stopword support to IntervalBuilder {pull}39637[#39637]
* Shortcut counts on exists queries {pull}39570[#39570] (issue: {issue}37475[#37475])
* Completion suggestions to be reduced once instead of twice {pull}39255[#39255]
* Rename SearchRequest#withLocalReduction {pull}39108[#39108]
* Tie break search shard iterator comparisons on cluster alias {pull}38853[#38853]
* Clean up ShardSearchLocalRequest {pull}38574[#38574]
* Handle unmapped fields in _field_caps API {pull}34071[#34071]
* Make 0 as invalid value for `min_children` in `has_child` query {pull}33073[#33073] (issue: {issue}32949[#32949])
* Analyze numbers, dates and ips with a whitespace analyzer in text queries {pull}27395[#27395]
* Add date and date_nanos conversion to the numeric_type sort option {pull}40199[#40199]
* Add `use_field` option to intervals query {pull}40157[#40157]
* Add overlapping, before, after filters to intervals query {pull}38999[#38999]

Security::
* Support concurrent refresh of refresh tokens {pull}38382[#38382] (issue: {issue}36872[#36872])

Snapshot/Restore::
* Remove IndexShard dependency from Repository  {pull}42213[#42213]
* Add shared access signature authentication support {pull}42117[#42117]
* Support multiple repositories in get snapshot request {pull}41799[#41799] (issue: {issue}41210[#41210])
* Implement Bulk Deletes for GCS Repository {pull}41368[#41368] (issue: {issue}40322[#40322])
* Add Bulk Delete Api to BlobStore {pull}40322[#40322] (issues: {issue}40144[#40144], {issue}40250[#40250])
* Async Snapshot Repository Deletes {pull}40144[#40144] (issues: {issue}39656[#39656], {issue}39657[#39657])
* Allow snapshotting replicated closed indices {pull}39644[#39644] (issue: {issue}33888[#33888])
* Add support for S3 intelligent tiering (#38836) {pull}39376[#39376] (issue: {issue}38836[#38836])

Store::
* Log missing file exception when failing to read metadata snapshot {pull}32920[#32920]

Suggesters::
* Tie-break completion suggestions with same score and surface form {pull}39564[#39564]



[[bug-7.2.0]]
[float]
=== Bug fixes

Aggregations::
* Update error message for allowed characters in aggregation names {pull}41573[#41573] (issue: {issue}41567[#41567])
* Fix FiltersAggregation NPE when `filters` is empty {pull}41459[#41459] (issue: {issue}41408[#41408])
* Fix unmapped field handling in the composite aggregation {pull}41280[#41280]

Allocation::
* Avoid bubbling up failures from a shard that is recovering {pull}42287[#42287] (issues: {issue}30919[#30919], {issue}40107[#40107])
* Changed the position of reset counter {pull}39678[#39678] (issue: {issue}39546[#39546])

Analysis::
* Always use IndexAnalyzers in analyze transport action {pull}40769[#40769] (issue: {issue}29021[#29021])
* Fix anaylze NullPointerException when AnalyzeTokenList tokens is null {pull}39332[#39332]
* Fix anaylze NullPointerException when AnalyzeTokenList tokens is null {pull}39180[#39180]

Authentication::
* Refresh remote JWKs on all errors {pull}42850[#42850]
* Fix refresh remote JWKS logic  {pull}42662[#42662]
* Fix settings prefix for realm truststore password {pull}42336[#42336] (issues: {issue}30241[#30241], {issue}41663[#41663])
* Merge claims from userinfo and ID Token correctly {pull}42277[#42277]
* Do not refresh realm cache unless required {pull}42169[#42169] (issue: {issue}35218[#35218])
* Amend `prepareIndexIfNeededThenExecute` for security token refresh {pull}41697[#41697]
* Fix token Invalidation when retries exhausted {pull}39799[#39799]

Authorization::
* _cat/indices with Security, hide names when wildcard {pull}38824[#38824] (issue: {issue}37190[#37190])

CCR::
* CCR should not replicate private/internal settings {pull}43067[#43067] (issue: {issue}41268[#41268])

CRUD::
* Fix NPE when rejecting bulk updates {pull}42923[#42923]

Cluster Coordination::
* Reset state recovery after successful recovery {pull}42576[#42576] (issue: {issue}39172[#39172])
* Omit non-masters in ClusterFormationFailureHelper {pull}41344[#41344]

Data Frame::
* Rewrite start and stop to answer with acknowledged {pull}42589[#42589] (issue: {issue}42450[#42450])
* Set DF task state to stopped when stopping   {pull}42516[#42516] (issue: {issue}42441[#42441])
* Add support for fixed_interval, calendar_interval, remove interval {pull}42427[#42427] (issues: {issue}33727[#33727], {issue}42297[#42297])

Distributed::
* Avoid loading retention leases while writing them {pull}42620[#42620] (issue: {issue}41430[#41430])
* Do not use ifSeqNo for update requests on mixed cluster {pull}42596[#42596] (issue: {issue}42561[#42561])
* Prevent order being lost for _nodes API filters {pull}42045[#42045] (issue: {issue}41885[#41885])
* Ensure flush happen before closing an index {pull}40184[#40184] (issue: {issue}36342[#36342])

Engine::
* Account soft deletes for committed segments {pull}43126[#43126] (issue: {issue}43103[#43103])
* Fix assertion error when caching the result of a search in a read-only index {pull}41900[#41900] (issue: {issue}41795[#41795])
* Close and acquire commit during reset engine fix {pull}41584[#41584] (issue: {issue}38561[#38561])

Features/ILM::
* Make ILM force merging best effort {pull}43246[#43246] (issues: {issue}42824[#42824], {issue}43245[#43245])
* Narrow period of Shrink action in which ILM prevents stopping {pull}43254[#43254] (issue: {issue}43253[#43253])

Features/Indices APIs::
* Add pre-upgrade check to test cluster routing allocation is enabled {pull}39340[#39340] (issue: {issue}39339[#39339])

Features/Ingest::
* Build local year inside DateFormat lambda {pull}42120[#42120]

Features/Java High Level REST Client::
* Fixes a bug in AnalyzeRequest.toXContent() {pull}42795[#42795] (issues: {issue}39670[#39670], {issue}42197[#42197])
* StackOverflowError when calling BulkRequest#add {pull}41672[#41672]
* HLRC: Convert xpack methods to client side objects {pull}40705[#40705] (issue: {issue}40511[#40511])
* Rest-High-Level-Client:fix uri encode bug when url path start with '/' {pull}34436[#34436] (issue: {issue}34433[#34433])

Features/Watcher::
* NullPointerException when creating a watch with Jira action (#41922) {pull}42081[#42081]
* Fix minor watcher bug, unmute test, add additional debug logging {pull}41765[#41765] (issues: {issue}29893[#29893], {issue}30777[#30777], {issue}33291[#33291], {issue}35361[#35361])
* Fix Watcher deadlock that can cause in-abilty to index documents. {pull}41418[#41418] (issue: {issue}41390[#41390])

Geo::
* Improve error message when polygons contains twice the same point in no-consecutive position {pull}41051[#41051] (issue: {issue}40998[#40998])

Highlighting::
* Bug fix for AnnotatedTextHighlighter - port of 39525 {pull}39749[#39749] (issue: {issue}39525[#39525])

Infra/Core::
* Fix roundUp parsing with composite patterns {pull}43080[#43080] (issue: {issue}42835[#42835])
* scheduleAtFixedRate would hang {pull}42993[#42993] (issue: {issue}38441[#38441])
* Only ignore IOException when fsyncing on dirs {pull}42972[#42972] (issue: {issue}42950[#42950])
* Fix node close stopwatch usage {pull}41918[#41918]
* Make ISO8601 date parser accept timezone when time does not have seconds {pull}41896[#41896]
* Allow unknown task time in QueueResizingEsTPE {pull}41810[#41810] (issue: {issue}41448[#41448])
* Parse composite patterns using ClassicFormat.parseObject {pull}40100[#40100] (issue: {issue}39916[#39916])

Infra/Packaging::
* Don't create tempdir for cli scripts {pull}41913[#41913] (issue: {issue}34445[#34445])
* Cleanup plugin bin directories {pull}41907[#41907] (issue: {issue}18109[#18109])
* Update lintian overrides {pull}41561[#41561] (issue: {issue}17185[#17185])
* Resolve JAVA_HOME at windows service install time {pull}39714[#39714] (issue: {issue}30720[#30720])

Infra/Settings::
* Handle UTF-8 values in the keystore {pull}39496[#39496]
* Handle empty input in AddStringKeyStoreCommand {pull}39490[#39490] (issue: {issue}39413[#39413])

Machine Learning::
* Fix possible race condition when closing an opening job {pull}42506[#42506]
* Exclude analysis fields with core field names from anomaly results {pull}41093[#41093] (issue: {issue}39406[#39406])

Mapping::
* Fix possible NPE in put mapping validators {pull}43000[#43000] (issue: {issue}37675[#37675])
* Fix merging of text field mappers {pull}40627[#40627]
* Fix an off-by-one error in the vector field dimension limit. {pull}40489[#40489]
* Fix not Recognizing Disabled Object Mapper {pull}39862[#39862] (issue: {issue}39456[#39456])
* Avoid copying the field alias lookup structure unnecessarily. {pull}39726[#39726]
* Handle NaNs when detrending seasonal components {ml-pull}408[#408]

Network::
* Don't require TLS for single node clusters {pull}42826[#42826]
* Handle WRAP ops during SSL read {pull}41611[#41611]
* SSLDriver can transition to CLOSED in handshake {pull}41458[#41458]
* Handle Bulk Requests on Write Threadpool {pull}40866[#40866] (issues: {issue}39128[#39128], {issue}39658[#39658])

Percolator::
* Fixed ignoring name parameter for percolator queries {pull}42598[#42598] (issue: {issue}40405[#40405])

Recovery::
* Use translog to estimate number of operations in recovery {pull}42211[#42211] (issue: {issue}38904[#38904])
* Recovery with syncId should verify seqno infos {pull}41265[#41265]
* Retain history for peer recovery using leases {pull}39133[#39133]

Reindex::
* Remote reindex failure parse fix {pull}42928[#42928]
* Fix concurrent search and index delete {pull}42621[#42621] (issue: {issue}28053[#28053])
* Propogate version in reindex from remote search {pull}42412[#42412] (issue: {issue}31908[#31908])

Rollup::
* Fix max boundary for rollup jobs that use a delay {pull}42158[#42158]
* Cleanup exceptions thrown during RollupSearch {pull}41272[#41272] (issue: {issue}38015[#38015])
* Validate timezones based on rules not string comparision {pull}36237[#36237] (issue: {issue}36229[#36229])

SQL::
* Fix wrong results when sorting on aggregate {pull}43154[#43154] (issue: {issue}42851[#42851])
* Cover the Integer type when extracting values from _source {pull}42859[#42859] (issue: {issue}42858[#42858])
* Fix precedence of `::` psql like CAST operator {pull}40665[#40665]

Search::
* Fix IntervalBuilder#analyzeText to never return `null` {pull}42750[#42750] (issue: {issue}42587[#42587])
* Fix sorting on nested field with unmapped {pull}42451[#42451] (issue: {issue}33644[#33644])
* Always set terminated_early if terminate_after is set in the search request {pull}40839[#40839] (issue: {issue}33949[#33949])
* more_like_this query to throw an error if the like fields is not provided {pull}40632[#40632]
* Fixing 503 Service Unavailable errors during fetch phase  {pull}39086[#39086]
* Fix IndexSearcherWrapper visibility {pull}39071[#39071] (issue: {issue}30758[#30758])

Snapshot/Restore::
* Fix Azure List by Prefix Bug {pull}42713[#42713]
* Remove Harmful Exists Check from BlobStoreFormat {pull}41898[#41898] (issue: {issue}41882[#41882])
* Restricts naming for repositories {pull}41008[#41008] (issue: {issue}40817[#40817])
* SNAPSHOT: More Resilient Writes to Blob Stores {pull}36927[#36927] (issue: {issue}25281[#25281])

Suggesters::
* Handle min_doc_freq in suggesters {pull}40840[#40840] (issue: {issue}16764[#16764])


[[upgrade-7.2.0]]
[float]
=== Upgrades

Features/Watcher::
* Replace javax activation with jakarta activation {pull}40247[#40247]
* Replace java mail with jakarta mail {pull}40088[#40088]

Infra/Core::
* Update to joda time 2.10.2 {pull}42199[#42199]

Network::
* Upgrade to Netty 4.1.35 {pull}41499[#41499]



",12204,True,2951.651122637338,median
"// Copyright (c) 2011 The LevelDB Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file. See the AUTHORS file for names of contributors.

#include <dirent.h>
#include <fcntl.h>
#include <fnmatch.h>
#include <fts.h>
#include <glob.h>
#include <pthread.h>
#include <sys/resource.h>
#include <sys/stat.h>
#include <sys/statvfs.h>
#include <sys/time.h>
#include <sys/uio.h>
#include <sys/utsname.h>
#include <unistd.h>

#include <algorithm>
#include <cerrno>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <map>
#include <memory>
#include <numeric>
#include <ostream>
#include <string>
#include <type_traits>
#include <utility>
#include <vector>

#include <gflags/gflags.h>
#include <glog/logging.h>

#include ""kudu/gutil/atomicops.h""
#include ""kudu/gutil/basictypes.h""
#include ""kudu/gutil/bind.h""
#include ""kudu/gutil/bind_helpers.h""
#include ""kudu/gutil/macros.h""
#include ""kudu/gutil/map-util.h""
#include ""kudu/gutil/once.h""
#include ""kudu/gutil/port.h""
#include ""kudu/gutil/stringprintf.h""
#include ""kudu/gutil/strings/split.h""
#include ""kudu/gutil/strings/substitute.h""
#include ""kudu/gutil/strings/util.h""
#include ""kudu/util/array_view.h""
#include ""kudu/util/debug/trace_event.h""
#include ""kudu/util/env.h""
#include ""kudu/util/errno.h""
#include ""kudu/util/fault_injection.h""
#include ""kudu/util/flag_tags.h""
#include ""kudu/util/flags.h""
#include ""kudu/util/logging.h""
#include ""kudu/util/malloc.h""
#include ""kudu/util/monotime.h""
#include ""kudu/util/path_util.h""
#include ""kudu/util/scoped_cleanup.h""
#include ""kudu/util/slice.h""
#include ""kudu/util/status.h""
#include ""kudu/util/stopwatch.h""
#include ""kudu/util/thread_restrictions.h""
#include ""kudu/util/trace.h""

#if defined(__APPLE__)
#include <mach-o/dyld.h>
#include <sys/sysctl.h>
#else
#include <linux/falloc.h>
#include <linux/fiemap.h>
#include <linux/fs.h>
#include <linux/ioctl.h>
#include <linux/kernel.h>
#include <linux/magic.h>
#include <linux/types.h>
#include <sys/ioctl.h>
#include <sys/sysinfo.h>
#include <sys/vfs.h>
#endif  // defined(__APPLE__)

using base::subtle::Atomic64;
using base::subtle::Barrier_AtomicIncrement;
using std::accumulate;
using std::string;
using std::unique_ptr;
using std::vector;
using strings::Substitute;

// Copied from falloc.h. Useful for older kernels that lack support for
// hole punching; fallocate(2) will return EOPNOTSUPP.
#ifndef FALLOC_FL_KEEP_SIZE
#define FALLOC_FL_KEEP_SIZE 0x01 /* default is extend size */
#endif
#ifndef FALLOC_FL_PUNCH_HOLE
#define FALLOC_FL_PUNCH_HOLE  0x02 /* de-allocates range */
#endif


#ifndef __APPLE__
// These struct and ioctl definitions were copied verbatim from xfsprogs.
typedef struct xfs_flock64 {
        __s16           l_type;
        __s16           l_whence;
        __s64           l_start;
        __s64           l_len;          /* len == 0 means until end of file */
        __s32           l_sysid;
        __u32           l_pid;
        __s32           l_pad[4];       /* reserve area                     */
} xfs_flock64_t;
#define XFS_IOC_UNRESVSP64      _IOW ('X', 43, struct xfs_flock64)
#endif

// OSX does not have fdatasync or fread_unlocked.
#ifdef __APPLE__
#define fdatasync fsync
#define fread_unlocked fread
#endif

// With some probability, if 'filename_expr' matches the glob pattern specified
// by the 'env_inject_eio_globs' flag, calls RETURN_NOT_OK on 'error_expr'.
#define MAYBE_RETURN_EIO(filename_expr, error_expr) do { \\
  const string& f_ = (filename_expr); \\
  MAYBE_RETURN_FAILURE(FLAGS_env_inject_eio, \\
      ShouldInject(f_, FLAGS_env_inject_eio_globs) ? (error_expr) : Status::OK()); \\
} while (0)

bool ShouldInject(const string& candidate, const string& glob_patterns) {
  // Never inject on /proc/ file accesses regardless of the configured flag,
  // since it's not possible for /proc to ""go bad"".
  //
  // NB: it's important that this is done here _before_ consulting glob_patterns
  // since some background threads read /proc/ after gflags have already been
  // destructed.
  if (HasPrefixString(candidate, ""/proc/"")) {
    return false;
  }

  vector<string> globs = strings::Split(glob_patterns, "","", strings::SkipEmpty());
  for (const auto& glob : globs) {
    if (fnmatch(glob.c_str(), candidate.c_str(), 0) == 0) {
      return true;
    }
  }
  return false;
}

// See KUDU-588 for details.
DEFINE_bool(env_use_fsync, false,
            ""Use fsync(2) instead of fdatasync(2) for synchronizing dirty ""
            ""data to disk."");
TAG_FLAG(env_use_fsync, advanced);
TAG_FLAG(env_use_fsync, evolving);

// See KUDU-2052 for details.
DEFINE_bool(env_use_ioctl_hole_punch_on_xfs, true,
            ""Use the XFS_IOC_UNRESVSP64 ioctl instead of fallocate(2) to ""
            ""punch holes on XFS filesystems."");
TAG_FLAG(env_use_ioctl_hole_punch_on_xfs, advanced);
TAG_FLAG(env_use_ioctl_hole_punch_on_xfs, experimental);

DEFINE_bool(crash_on_eio, false,
            ""Kill the process if an I/O operation results in EIO. If false, ""
            ""I/O resulting in EIOs will return the status IOError and leave ""
            ""error-handling up to the caller."");
TAG_FLAG(crash_on_eio, advanced);
TAG_FLAG(crash_on_eio, experimental);

DEFINE_bool(never_fsync, false,
            ""Never fsync() anything to disk. This is used by certain test cases to ""
            ""speed up runtime. This is very unsafe to use in production."");
TAG_FLAG(never_fsync, advanced);
TAG_FLAG(never_fsync, unsafe);

DEFINE_int32(env_inject_short_read_bytes, 0,
             ""The number of bytes less than the requested bytes to read"");
TAG_FLAG(env_inject_short_read_bytes, hidden);
DEFINE_int32(env_inject_short_write_bytes, 0,
             ""The number of bytes less than the requested bytes to write"");
TAG_FLAG(env_inject_short_write_bytes, hidden);

DEFINE_double(env_inject_eio, 0.0,
              ""Fraction of the time that operations on certain files will fail ""
              ""with the posix code EIO."");
TAG_FLAG(env_inject_eio, hidden);
DEFINE_string(env_inject_eio_globs, ""*"",
              ""Comma-separated list of glob patterns specifying files on which ""
              ""I/O will fail. By default, all files may cause a failure."");
TAG_FLAG(env_inject_eio_globs, hidden);

DEFINE_string(env_inject_lock_failure_globs, """",
              ""Comma-separated list of glob patterns specifying files on which ""
              ""attempts to obtain a file lock will fail. By default, no files ""
              ""will fail."");
TAG_FLAG(env_inject_lock_failure_globs, hidden);

static __thread uint64_t thread_local_id;
static Atomic64 cur_thread_local_id_;

namespace kudu {

const char* const Env::kInjectedFailureStatusMsg = ""INJECTED FAILURE"";

namespace {

struct FreeDeleter {
  inline void operator()(void* ptr) const {
    free(ptr);
  }
};

#if defined(__APPLE__)
// Simulates Linux's fallocate file preallocation API on OS X.
int fallocate(int fd, int mode, off_t offset, off_t len) {
  CHECK_EQ(mode, 0);
  off_t size = offset + len;

  struct stat stat;
  int ret = fstat(fd, &stat);
  if (ret < 0) {
    return ret;
  }

  if (stat.st_blocks * 512 < size) {
    // The offset field seems to have no effect; the file is always allocated
    // with space from 0 to the size. This is probably because OS X does not
    // support sparse files.
    fstore_t store = {F_ALLOCATECONTIG, F_PEOFPOSMODE, 0, size};
    if (fcntl(fd, F_PREALLOCATE, &store) < 0) {
      LOG(INFO) << ""Unable to allocate contiguous disk space, attempting non-contiguous allocation"";
      store.fst_flags = F_ALLOCATEALL;
      ret = fcntl(fd, F_PREALLOCATE, &store);
      if (ret < 0) {
        return ret;
      }
    }
  }

  if (stat.st_size < size) {
    // fcntl does not change the file size, so set it if necessary.
    int ret;
    RETRY_ON_EINTR(ret, ftruncate(fd, size));
    return ret;
  }
  return 0;
}

// Simulates Linux's preadv API on OS X.
ssize_t preadv(int fd, const struct iovec* iovec, int count, off_t offset) {
  ssize_t total_read_bytes = 0;
  for (int i = 0; i < count; i++) {
    ssize_t r;
    RETRY_ON_EINTR(r, pread(fd, iovec[i].iov_base, iovec[i].iov_len, offset));
    if (r < 0) {
      return r;
    }
    total_read_bytes += r;
    if (static_cast<size_t>(r) < iovec[i].iov_len) {
      break;
    }
    offset += iovec[i].iov_len;
  }
  return total_read_bytes;
}

// Simulates Linux's pwritev API on OS X.
ssize_t pwritev(int fd, const struct iovec* iovec, int count, off_t offset) {
  ssize_t total_written_bytes = 0;
  for (int i = 0; i < count; i++) {
    ssize_t r;
    RETRY_ON_EINTR(r, pwrite(fd, iovec[i].iov_base, iovec[i].iov_len, offset));
    if (r < 0) {
      return r;
    }
    total_written_bytes += r;
    if (static_cast<size_t>(r) < iovec[i].iov_len) {
      break;
    }
    offset += iovec[i].iov_len;
  }
  return total_written_bytes;
}
#endif


// Close file descriptor when object goes out of scope.
class ScopedFdCloser {
 public:
  explicit ScopedFdCloser(int fd)
    : fd_(fd) {
  }

  ~ScopedFdCloser() {
    ThreadRestrictions::AssertIOAllowed();
    int err;
    RETRY_ON_EINTR(err, ::close(fd_));
    if (PREDICT_FALSE(err != 0)) {
      PLOG(WARNING) << ""Failed to close fd "" << fd_;
    }
  }

 private:
  const int fd_;
};

Status IOError(const string& context, int err_number) {
  switch (err_number) {
    case ENOENT:
      return Status::NotFound(context, ErrnoToString(err_number), err_number);
    case EEXIST:
      return Status::AlreadyPresent(context, ErrnoToString(err_number), err_number);
    case EOPNOTSUPP:
      return Status::NotSupported(context, ErrnoToString(err_number), err_number);
    case EIO:
      if (FLAGS_crash_on_eio) {
        // TODO(awong): This is very, very coarse-grained. A more comprehensive
        // approach is described in KUDU-616.
        LOG(FATAL) << ""Fatal I/O error, context: "" << context;
      } else {
        LOG(ERROR) << ""I/O error, context: "" << context;
      }
  }
  return Status::IOError(context, ErrnoToString(err_number), err_number);
}

Status DoSync(int fd, const string& filename) {
  MAYBE_RETURN_EIO(filename, IOError(Env::kInjectedFailureStatusMsg, EIO));

  ThreadRestrictions::AssertIOAllowed();
  if (FLAGS_never_fsync) return Status::OK();
  if (FLAGS_env_use_fsync) {
    TRACE_COUNTER_SCOPE_LATENCY_US(""fsync_us"");
    TRACE_COUNTER_INCREMENT(""fsync"", 1);
    if (fsync(fd) < 0) {
      return IOError(filename, errno);
    }
  } else {
    TRACE_COUNTER_INCREMENT(""fdatasync"", 1);
    TRACE_COUNTER_SCOPE_LATENCY_US(""fdatasync_us"");
    if (fdatasync(fd) < 0) {
      return IOError(filename, errno);
    }
  }
  return Status::OK();
}

Status DoOpen(const string& filename, Env::OpenMode mode, int* fd) {
  MAYBE_RETURN_EIO(filename, IOError(Env::kInjectedFailureStatusMsg, EIO));
  ThreadRestrictions::AssertIOAllowed();
  int flags = O_RDWR;
  switch (mode) {
    case Env::CREATE_OR_OPEN_WITH_TRUNCATE:
      flags |= O_CREAT | O_TRUNC;
      break;
    case Env::CREATE_OR_OPEN:
      flags |= O_CREAT;
      break;
    case Env::MUST_CREATE:
      flags |= O_CREAT | O_EXCL;
      break;
    case Env::MUST_EXIST:
      break;
    default:
      return Status::NotSupported(Substitute(""Unknown create mode $0"", mode));
  }
  int f;
  RETRY_ON_EINTR(f, open(filename.c_str(), flags, 0666));
  if (f < 0) {
    return IOError(filename, errno);
  }
  *fd = f;
  return Status::OK();
}

Status DoReadV(int fd, const string& filename, uint64_t offset,
               ArrayView<Slice> results) {
  MAYBE_RETURN_EIO(filename, IOError(Env::kInjectedFailureStatusMsg, EIO));
  ThreadRestrictions::AssertIOAllowed();

  // Convert the results into the iovec vector to request
  // and calculate the total bytes requested
  size_t bytes_req = 0;
  size_t iov_size = results.size();
  struct iovec iov[iov_size];
  for (size_t i = 0; i < iov_size; i++) {
    Slice& result = results[i];
    bytes_req += result.size();
    iov[i] = { result.mutable_data(), result.size() };
  }

  uint64_t cur_offset = offset;
  size_t completed_iov = 0;
  size_t rem = bytes_req;
  while (rem > 0) {
    // Never request more than IOV_MAX in one request
    size_t iov_count = std::min(iov_size - completed_iov, static_cast<size_t>(IOV_MAX));
    ssize_t r;
    RETRY_ON_EINTR(r, preadv(fd, iov + completed_iov, iov_count, cur_offset));

    // Fake a short read for testing
    if (PREDICT_FALSE(FLAGS_env_inject_short_read_bytes > 0 && rem == bytes_req)) {
      DCHECK_LT(FLAGS_env_inject_short_read_bytes, r);
      r -= FLAGS_env_inject_short_read_bytes;
    }

    if (PREDICT_FALSE(r < 0)) {
      // An error: return a non-ok status.
      return IOError(filename, errno);
    }
    if (PREDICT_FALSE(r == 0)) {
      // EOF.
      return Status::EndOfFile(
          Substitute(""EOF trying to read $0 bytes at offset $1"", bytes_req, offset));
    }
    if (PREDICT_TRUE(r == rem)) {
      // All requested bytes were read. This is almost always the case.
      return Status::OK();
    }
    DCHECK_LE(r, rem);
    // Adjust iovec vector based on bytes read for the next request
    ssize_t bytes_rem = r;
    for (size_t i = completed_iov; i < iov_size; i++) {
      if (bytes_rem >= iov[i].iov_len) {
        // The full length of this iovec was read
        completed_iov++;
        bytes_rem -= iov[i].iov_len;
      } else {
        // Partially read this result.
        // Adjust the iov_len and iov_base to request only the missing data.
        iov[i].iov_base = static_cast<uint8_t *>(iov[i].iov_base) + bytes_rem;
        iov[i].iov_len -= bytes_rem;
        break; // Don't need to adjust remaining iovec's
      }
    }
    cur_offset += r;
    rem -= r;
  }
  DCHECK_EQ(0, rem);
  return Status::OK();
}

Status DoWriteV(int fd, const string& filename, uint64_t offset, ArrayView<const Slice> data) {
  MAYBE_RETURN_EIO(filename, IOError(Env::kInjectedFailureStatusMsg, EIO));
  ThreadRestrictions::AssertIOAllowed();

  // Convert the results into the iovec vector to request
  // and calculate the total bytes requested.
  size_t bytes_req = 0;
  size_t iov_size = data.size();
  struct iovec iov[iov_size];
  for (size_t i = 0; i < iov_size; i++) {
    const Slice& result = data[i];
    bytes_req += result.size();
    iov[i] = { const_cast<uint8_t*>(result.data()), result.size() };
  }

  uint64_t cur_offset = offset;
  size_t completed_iov = 0;
  size_t rem = bytes_req;
  while (rem > 0) {
    // Never request more than IOV_MAX in one request.
    size_t iov_count = std::min(iov_size - completed_iov, static_cast<size_t>(IOV_MAX));
    ssize_t w;
    RETRY_ON_EINTR(w, pwritev(fd, iov + completed_iov, iov_count, cur_offset));

    // Fake a short write for testing.
    if (PREDICT_FALSE(FLAGS_env_inject_short_write_bytes > 0 && rem == bytes_req)) {
      DCHECK_LT(FLAGS_env_inject_short_write_bytes, w);
      w -= FLAGS_env_inject_short_read_bytes;
    }

    if (PREDICT_FALSE(w < 0)) {
      // An error: return a non-ok status.
      return IOError(filename, errno);
    }

    DCHECK_LE(w, rem);

    if (PREDICT_TRUE(w == rem)) {
      // All requested bytes were read. This is almost always the case.
      return Status::OK();
    }
    // Adjust iovec vector based on bytes read for the next request.
    ssize_t bytes_rem = w;
    for (size_t i = completed_iov; i < iov_size; i++) {
      if (bytes_rem >= iov[i].iov_len) {
        // The full length of this iovec was written.
        completed_iov++;
        bytes_rem -= iov[i].iov_len;
      } else {
        // Partially wrote this result.
        // Adjust the iov_len and iov_base to write only the missing data.
        iov[i].iov_base = static_cast<uint8_t *>(iov[i].iov_base) + bytes_rem;
        iov[i].iov_len -= bytes_rem;
        break; // Don't need to adjust remaining iovec's.
      }
    }
    cur_offset += w;
    rem -= w;
  }
  DCHECK_EQ(0, rem);
  return Status::OK();
}

Status DoIsOnXfsFilesystem(const string& path, bool* result) {
#ifdef __APPLE__
  *result = false;
#else
  struct statfs buf;
  int ret;
  RETRY_ON_EINTR(ret, statfs(path.c_str(), &buf));
  if (ret == -1) {
    return IOError(Substitute(""statfs: $0"", path), errno);
  }
  // This magic number isn't defined in any header but is the value of the
  // US-ASCII string 'XFSB' expressed in hexadecimal.
  *result = (buf.f_type == 0x58465342);
#endif
  return Status::OK();
}

const char* ResourceLimitTypeToString(Env::ResourceLimitType t) {
  switch (t) {
    case Env::ResourceLimitType::OPEN_FILES_PER_PROCESS:
      return ""open files per process"";
    case Env::ResourceLimitType::RUNNING_THREADS_PER_EUID:
      return ""running threads per effective uid"";
    default: LOG(FATAL) << ""Unknown resource limit type"";
  }
  __builtin_unreachable();
}

int ResourceLimitTypeToUnixRlimit(Env::ResourceLimitType t) {
  switch (t) {
    case Env::ResourceLimitType::OPEN_FILES_PER_PROCESS: return RLIMIT_NOFILE;
    case Env::ResourceLimitType::RUNNING_THREADS_PER_EUID: return RLIMIT_NPROC;
    default: LOG(FATAL) << ""Unknown resource limit type: "" << t;
  }
  __builtin_unreachable();
}

#ifdef __APPLE__
const char* ResourceLimitTypeToMacosRlimit(Env::ResourceLimitType t) {
  switch (t) {
    case Env::ResourceLimitType::OPEN_FILES_PER_PROCESS:
      return ""kern.maxfilesperproc"";
    case Env::ResourceLimitType::RUNNING_THREADS_PER_EUID:
      return ""kern.maxprocperuid"";
    default: LOG(FATAL) << ""Unknown resource limit type: "" << t;
  }
  __builtin_unreachable();
}
#endif

class PosixSequentialFile: public SequentialFile {
 private:
  const string filename_;
  FILE* const file_;

 public:
  PosixSequentialFile(string fname, FILE* f)
      : filename_(std::move(fname)), file_(f) {}
  ~PosixSequentialFile() {
    int err;
    RETRY_ON_EINTR(err, fclose(file_));
    if (PREDICT_FALSE(err != 0)) {
      PLOG(WARNING) << ""Failed to close "" << filename_;
    }
  }

  virtual Status Read(Slice* result) OVERRIDE {
    MAYBE_RETURN_EIO(filename_, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();
    size_t r;
    STREAM_RETRY_ON_EINTR(r, file_, fread_unlocked(result->mutable_data(), 1,
                                                   result->size(), file_));
    if (r < result->size()) {
      if (feof(file_)) {
        // We leave status as ok if we hit the end of the file.
        // We need to adjust the slice size.
        result->truncate(r);
      } else {
        // A partial read with an error: return a non-ok status.
        return IOError(filename_, errno);
      }
    }
    return Status::OK();
  }

  virtual Status Skip(uint64_t n) OVERRIDE {
    MAYBE_RETURN_EIO(filename_, IOError(Env::kInjectedFailureStatusMsg, EIO));
    TRACE_EVENT1(""io"", ""PosixSequentialFile::Skip"", ""path"", filename_);
    ThreadRestrictions::AssertIOAllowed();
    if (fseek(file_, n, SEEK_CUR)) {
      return IOError(filename_, errno);
    }
    return Status::OK();
  }

  virtual const string& filename() const OVERRIDE { return filename_; }
};

// pread() based random-access
class PosixRandomAccessFile: public RandomAccessFile {
 private:
  const string filename_;
  const int fd_;

 public:
  PosixRandomAccessFile(string fname, int fd)
      : filename_(std::move(fname)), fd_(fd) {}
  ~PosixRandomAccessFile() {
    int err;
    RETRY_ON_EINTR(err, close(fd_));
    if (PREDICT_FALSE(err != 0)) {
      PLOG(WARNING) << ""Failed to close "" << filename_;
    }
  }

  virtual Status Read(uint64_t offset, Slice result) const OVERRIDE {
    return DoReadV(fd_, filename_, offset, ArrayView<Slice>(&result, 1));
  }

  virtual Status ReadV(uint64_t offset, ArrayView<Slice> results) const OVERRIDE {
    return DoReadV(fd_, filename_, offset, results);
  }

  virtual Status Size(uint64_t *size) const OVERRIDE {
    MAYBE_RETURN_EIO(filename_, IOError(Env::kInjectedFailureStatusMsg, EIO));
    TRACE_EVENT1(""io"", ""PosixRandomAccessFile::Size"", ""path"", filename_);
    ThreadRestrictions::AssertIOAllowed();
    struct stat st;
    if (fstat(fd_, &st) == -1) {
      return IOError(filename_, errno);
    }
    *size = st.st_size;
    return Status::OK();
  }

  virtual const string& filename() const OVERRIDE { return filename_; }

  virtual size_t memory_footprint() const OVERRIDE {
    return kudu_malloc_usable_size(this) + filename_.capacity();
  }
};

// Use non-memory mapped POSIX files to write data to a file.
//
// TODO (perf) investigate zeroing a pre-allocated allocated area in
// order to further improve Sync() performance.
class PosixWritableFile : public WritableFile {
 public:
  PosixWritableFile(string fname, int fd, uint64_t file_size,
                    bool sync_on_close)
      : filename_(std::move(fname)),
        fd_(fd),
        sync_on_close_(sync_on_close),
        filesize_(file_size),
        pre_allocated_size_(0),
        pending_sync_(false),
        closed_(false) {}

  ~PosixWritableFile() {
    WARN_NOT_OK(Close(), ""Failed to close "" + filename_);
  }

  virtual Status Append(const Slice& data) OVERRIDE {
    return AppendV(ArrayView<const Slice>(&data, 1));
  }

  virtual Status AppendV(ArrayView<const Slice> data) OVERRIDE {
    ThreadRestrictions::AssertIOAllowed();
    RETURN_NOT_OK(DoWriteV(fd_, filename_, filesize_, data));
    // Calculate the amount of data written
    size_t bytes_written = accumulate(data.begin(), data.end(), static_cast<size_t>(0),
                                      [&](int sum, const Slice& curr) {
                                        return sum + curr.size();
                                      });
    filesize_ += bytes_written;
    pending_sync_ = true;
    return Status::OK();
  }

  virtual Status PreAllocate(uint64_t size) OVERRIDE {
    MAYBE_RETURN_EIO(filename_, IOError(Env::kInjectedFailureStatusMsg, EIO));

    TRACE_EVENT1(""io"", ""PosixWritableFile::PreAllocate"", ""path"", filename_);
    ThreadRestrictions::AssertIOAllowed();
    uint64_t offset = std::max(filesize_, pre_allocated_size_);
    int ret;
    RETRY_ON_EINTR(ret, fallocate(fd_, 0, offset, size));
    if (ret != 0) {
      if (errno == EOPNOTSUPP) {
        KLOG_FIRST_N(WARNING, 1) << ""The filesystem does not support fallocate()."";
      } else if (errno == ENOSYS) {
        KLOG_FIRST_N(WARNING, 1) << ""The kernel does not implement fallocate()."";
      } else {
        return IOError(filename_, errno);
      }
    }
    pre_allocated_size_ = offset + size;
    return Status::OK();
  }

  virtual Status Close() OVERRIDE {
    if (closed_) {
      return Status::OK();
    }
    TRACE_EVENT1(""io"", ""PosixWritableFile::Close"", ""path"", filename_);
    ThreadRestrictions::AssertIOAllowed();
    MAYBE_RETURN_EIO(filename_, IOError(Env::kInjectedFailureStatusMsg, EIO));
    Status s;

    // If we've allocated more space than we used, truncate to the
    // actual size of the file and perform Sync().
    if (filesize_ < pre_allocated_size_) {
      int ret;
      RETRY_ON_EINTR(ret, ftruncate(fd_, filesize_));
      if (ret != 0) {
        s = IOError(filename_, errno);
        pending_sync_ = true;
      }
    }

    if (sync_on_close_) {
      Status sync_status = Sync();
      if (!sync_status.ok()) {
        LOG(ERROR) << ""Unable to Sync "" << filename_ << "": "" << sync_status.ToString();
        if (s.ok()) {
          s = sync_status;
        }
      }
    }

    int ret;
    RETRY_ON_EINTR(ret, close(fd_));
    if (ret < 0) {
      if (s.ok()) {
        s = IOError(filename_, errno);
      }
    }

    closed_ = true;
    return s;
  }

  virtual Status Flush(FlushMode mode) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixWritableFile::Flush"", ""path"", filename_);
    MAYBE_RETURN_EIO(filename_, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();
#if defined(__linux__)
    int flags = SYNC_FILE_RANGE_WRITE;
    if (mode == FLUSH_SYNC) {
      flags |= SYNC_FILE_RANGE_WAIT_BEFORE;
      flags |= SYNC_FILE_RANGE_WAIT_AFTER;
    }
    if (sync_file_range(fd_, 0, 0, flags) < 0) {
      return IOError(filename_, errno);
    }
#else
    if (mode == FLUSH_SYNC && fsync(fd_) < 0) {
      return IOError(filename_, errno);
    }
#endif
    return Status::OK();
  }

  virtual Status Sync() OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixWritableFile::Sync"", ""path"", filename_);
    ThreadRestrictions::AssertIOAllowed();
    LOG_SLOW_EXECUTION(WARNING, 1000, Substitute(""sync call for $0"", filename_)) {
      if (pending_sync_) {
        pending_sync_ = false;
        RETURN_NOT_OK(DoSync(fd_, filename_));
      }
    }
    return Status::OK();
  }

  virtual uint64_t Size() const OVERRIDE {
    return filesize_;
  }

  virtual const string& filename() const OVERRIDE { return filename_; }

 private:
  const string filename_;
  const int fd_;
  const bool sync_on_close_;

  uint64_t filesize_;
  uint64_t pre_allocated_size_;
  bool pending_sync_;
  bool closed_;
};

class PosixRWFile : public RWFile {
 public:
  PosixRWFile(string fname, int fd, bool sync_on_close)
      : filename_(std::move(fname)),
        fd_(fd),
        sync_on_close_(sync_on_close),
        is_on_xfs_(false),
        closed_(false) {}

  ~PosixRWFile() {
    WARN_NOT_OK(Close(), ""Failed to close "" + filename_);
  }

  virtual Status Read(uint64_t offset, Slice result) const OVERRIDE {
    return DoReadV(fd_, filename_, offset, ArrayView<Slice>(&result, 1));
  }

  virtual Status ReadV(uint64_t offset, ArrayView<Slice> results) const OVERRIDE {
    return DoReadV(fd_, filename_, offset, results);
  }

  virtual Status Write(uint64_t offset, const Slice& data) OVERRIDE {
    return WriteV(offset, ArrayView<const Slice>(&data, 1));
  }

  virtual Status WriteV(uint64_t offset, ArrayView<const Slice> data) OVERRIDE {
    return DoWriteV(fd_, filename_, offset, data);
  }

  virtual Status PreAllocate(uint64_t offset,
                             size_t length,
                             PreAllocateMode mode) OVERRIDE {
    MAYBE_RETURN_EIO(filename_, IOError(Env::kInjectedFailureStatusMsg, EIO));

    TRACE_EVENT1(""io"", ""PosixRWFile::PreAllocate"", ""path"", filename_);
    ThreadRestrictions::AssertIOAllowed();
    int falloc_mode = 0;
    if (mode == DONT_CHANGE_FILE_SIZE) {
      falloc_mode = FALLOC_FL_KEEP_SIZE;
    }
    int ret;
    RETRY_ON_EINTR(ret, fallocate(fd_, falloc_mode, offset, length));
    if (ret != 0) {
      if (errno == EOPNOTSUPP) {
        KLOG_FIRST_N(WARNING, 1) << ""The filesystem does not support fallocate()."";
      } else if (errno == ENOSYS) {
        KLOG_FIRST_N(WARNING, 1) << ""The kernel does not implement fallocate()."";
      } else {
        return IOError(filename_, errno);
      }
    }
    return Status::OK();
  }

  virtual Status Truncate(uint64_t length) OVERRIDE {
    TRACE_EVENT2(""io"", ""PosixRWFile::Truncate"", ""path"", filename_, ""length"", length);
    MAYBE_RETURN_EIO(filename_, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();
    int ret;
    RETRY_ON_EINTR(ret, ftruncate(fd_, length));
    if (ret != 0) {
      int err = errno;
      return Status::IOError(Substitute(""Unable to truncate file $0"", filename_),
                             Substitute(""ftruncate() failed: $0"", ErrnoToString(err)),
                             err);
    }
    return Status::OK();
  }

  virtual Status PunchHole(uint64_t offset, size_t length) OVERRIDE {
#if defined(__linux__)
    TRACE_EVENT1(""io"", ""PosixRWFile::PunchHole"", ""path"", filename_);
    MAYBE_RETURN_EIO(filename_, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();

    // KUDU-2052: xfs in el6 systems induces an fsync in the kernel whenever it
    // performs a hole punch through the fallocate() syscall, even if the file
    // range was already punched out. The older xfs-specific hole punching
    // ioctl doesn't do this, despite eventually executing the same xfs code.
    // To keep the code simple, we'll use this ioctl on any xfs system (not
    // just on el6) and fallocate() on all other filesystems.
    //
    // Note: the cast to void* here (and back to PosixRWFile*, in InitIsOnXFS)
    // is needed to avoid an undefined behavior warning from UBSAN.
    once_.Init(&InitIsOnXFS, reinterpret_cast<void*>(this));
    if (is_on_xfs_ && FLAGS_env_use_ioctl_hole_punch_on_xfs) {
      xfs_flock64_t cmd;
      memset(&cmd, 0, sizeof(cmd));
      cmd.l_start = offset;
      cmd.l_len = length;
      if (ioctl(fd_, XFS_IOC_UNRESVSP64, &cmd) < 0) {
        return IOError(filename_, errno);
      }
    } else {
      int ret;
      RETRY_ON_EINTR(ret, fallocate(
          fd_, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE, offset, length));
      if (ret != 0) {
        return IOError(filename_, errno);
      }
    }
    return Status::OK();
#else
    return Status::NotSupported(""Hole punching not supported on this platform"");
#endif
  }

  virtual Status Flush(FlushMode mode, uint64_t offset, size_t length) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixRWFile::Flush"", ""path"", filename_);
    MAYBE_RETURN_EIO(filename_, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();
#if defined(__linux__)
    int flags = SYNC_FILE_RANGE_WRITE;
    if (mode == FLUSH_SYNC) {
      flags |= SYNC_FILE_RANGE_WAIT_AFTER;
    }
    if (sync_file_range(fd_, offset, length, flags) < 0) {
      return IOError(filename_, errno);
    }
#else
    if (mode == FLUSH_SYNC && fsync(fd_) < 0) {
      return IOError(filename_, errno);
    }
#endif
    return Status::OK();
  }

  virtual Status Sync() OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixRWFile::Sync"", ""path"", filename_);
    ThreadRestrictions::AssertIOAllowed();
    LOG_SLOW_EXECUTION(WARNING, 1000, Substitute(""sync call for $0"", filename())) {
      RETURN_NOT_OK(DoSync(fd_, filename_));
    }
    return Status::OK();
  }

  virtual Status Close() OVERRIDE {
    if (closed_) {
      return Status::OK();
    }
    TRACE_EVENT1(""io"", ""PosixRWFile::Close"", ""path"", filename_);
    MAYBE_RETURN_EIO(filename_, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();
    Status s;

    if (sync_on_close_) {
      s = Sync();
      if (!s.ok()) {
        LOG(ERROR) << ""Unable to Sync "" << filename_ << "": "" << s.ToString();
      }
    }

    int ret;
    RETRY_ON_EINTR(ret, close(fd_));
    if (ret < 0) {
      if (s.ok()) {
        s = IOError(filename_, errno);
      }
    }

    closed_ = true;
    return s;
  }

  virtual Status Size(uint64_t* size) const OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixRWFile::Size"", ""path"", filename_);
    MAYBE_RETURN_EIO(filename_, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();
    struct stat st;
    if (fstat(fd_, &st) == -1) {
      return IOError(filename_, errno);
    }
    *size = st.st_size;
    return Status::OK();
  }

  virtual Status GetExtentMap(ExtentMap* out) const OVERRIDE {
#if !defined(__linux__)
    return Status::NotSupported(""GetExtentMap not supported on this platform"");
#else
    TRACE_EVENT1(""io"", ""PosixRWFile::GetExtentMap"", ""path"", filename_);
    MAYBE_RETURN_EIO(filename_, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();

    // This allocation size is arbitrary.
    static const int kBufSize = 4096;
    uint8_t buf[kBufSize] = { 0 };

    struct fiemap* fm = reinterpret_cast<struct fiemap*>(buf);
    struct fiemap_extent* fme = &fm->fm_extents[0];
    int avail_extents_in_buffer = (kBufSize - sizeof(*fm)) / sizeof(*fme);
    bool saw_last_extent = false;
    ExtentMap extents;
    do {
      // Fetch another block of extents.
      fm->fm_length = FIEMAP_MAX_OFFSET;
      fm->fm_extent_count = avail_extents_in_buffer;
      if (ioctl(fd_, FS_IOC_FIEMAP, fm) == -1) {
        return IOError(filename_, errno);
      }

      // No extents returned, this file must have no extents.
      if (fm->fm_mapped_extents == 0) {
        break;
      }

      // Parse the extent block.
      uint64_t last_extent_end_offset;
      for (int i = 0; i < fm->fm_mapped_extents; i++) {
        if (fme[i].fe_flags & FIEMAP_EXTENT_LAST) {
          // This should really be the last extent.
          CHECK_EQ(fm->fm_mapped_extents - 1, i);

          saw_last_extent = true;
        }
        InsertOrDie(&extents, fme[i].fe_logical, fme[i].fe_length);
        VLOG(3) << Substitute(""File $0 extent $1: o $2, l $3 $4"",
                              filename_, i,
                              fme[i].fe_logical, fme[i].fe_length,
                              saw_last_extent ? ""(final)"" : """");
        last_extent_end_offset = fme[i].fe_logical + fme[i].fe_length;
        if (saw_last_extent) {
          break;
        }
      }

      fm->fm_start = last_extent_end_offset;
    } while (!saw_last_extent);

    out->swap(extents);
    return Status::OK();
#endif
  }

  virtual const string& filename() const OVERRIDE {
    return filename_;
  }

 private:
  static void InitIsOnXFS(void* arg) {
    PosixRWFile* rwf = reinterpret_cast<PosixRWFile*>(arg);
    bool result;
    Status s = DoIsOnXfsFilesystem(rwf->filename_, &result);
    if (s.ok()) {
      rwf->is_on_xfs_ = result;
    } else {
      KLOG_EVERY_N_SECS(WARNING, 1) <<
          Substitute(""Could not determine whether file is on xfs, assuming not: $0"",
                     s.ToString());
    }
  }

  const string filename_;
  const int fd_;
  const bool sync_on_close_;

  GoogleOnceDynamic once_;
  bool is_on_xfs_;
  bool closed_;
};

int LockOrUnlock(int fd, bool lock) {
  ThreadRestrictions::AssertIOAllowed();
  errno = 0;
  struct flock f;
  memset(&f, 0, sizeof(f));
  f.l_type = (lock ? F_WRLCK : F_UNLCK);
  f.l_whence = SEEK_SET;
  f.l_start = 0;
  f.l_len = 0;        // Lock/unlock entire file
  int ret;
  RETRY_ON_EINTR(ret, fcntl(fd, F_SETLK, &f));
  return ret;
}

class PosixFileLock : public FileLock {
 public:
  int fd_;
};

class PosixEnv : public Env {
 public:
  ~PosixEnv() {
    fprintf(stderr, ""Destroying Env::Default()\\n"");
    exit(1);
  }

  virtual Status NewSequentialFile(const string& fname,
                                   unique_ptr<SequentialFile>* result) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixEnv::NewSequentialFile"", ""path"", fname);
    MAYBE_RETURN_EIO(fname, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();
    FILE* f;
    POINTER_RETRY_ON_EINTR(f, fopen(fname.c_str(), ""r""));
    if (f == nullptr) {
      return IOError(fname, errno);
    }
    result->reset(new PosixSequentialFile(fname, f));
    return Status::OK();
  }

  virtual Status NewRandomAccessFile(const string& fname,
                                     unique_ptr<RandomAccessFile>* result) OVERRIDE {
    return NewRandomAccessFile(RandomAccessFileOptions(), fname, result);
  }

  virtual Status NewRandomAccessFile(const RandomAccessFileOptions& opts,
                                     const string& fname,
                                     unique_ptr<RandomAccessFile>* result) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixEnv::NewRandomAccessFile"", ""path"", fname);
    MAYBE_RETURN_EIO(fname, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();
    int fd;
    RETRY_ON_EINTR(fd, open(fname.c_str(), O_RDONLY));
    if (fd < 0) {
      return IOError(fname, errno);
    }

    result->reset(new PosixRandomAccessFile(fname, fd));
    return Status::OK();
  }

  virtual Status NewWritableFile(const string& fname,
                                 unique_ptr<WritableFile>* result) OVERRIDE {
    return NewWritableFile(WritableFileOptions(), fname, result);
  }

  virtual Status NewWritableFile(const WritableFileOptions& opts,
                                 const string& fname,
                                 unique_ptr<WritableFile>* result) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixEnv::NewWritableFile"", ""path"", fname);
    int fd;
    RETURN_NOT_OK(DoOpen(fname, opts.mode, &fd));
    return InstantiateNewWritableFile(fname, fd, opts, result);
  }

  virtual Status NewTempWritableFile(const WritableFileOptions& opts,
                                     const string& name_template,
                                     string* created_filename,
                                     unique_ptr<WritableFile>* result) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixEnv::NewTempWritableFile"", ""template"", name_template);
    int fd = 0;
    string tmp_filename;
    RETURN_NOT_OK(MkTmpFile(name_template, &fd, &tmp_filename));
    RETURN_NOT_OK(InstantiateNewWritableFile(tmp_filename, fd, opts, result));
    created_filename->swap(tmp_filename);
    return Status::OK();
  }

  virtual Status NewRWFile(const string& fname,
                           unique_ptr<RWFile>* result) OVERRIDE {
    return NewRWFile(RWFileOptions(), fname, result);
  }

  virtual Status NewRWFile(const RWFileOptions& opts,
                           const string& fname,
                           unique_ptr<RWFile>* result) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixEnv::NewRWFile"", ""path"", fname);
    int fd;
    RETURN_NOT_OK(DoOpen(fname, opts.mode, &fd));
    result->reset(new PosixRWFile(fname, fd, opts.sync_on_close));
    return Status::OK();
  }

  virtual Status NewTempRWFile(const RWFileOptions& opts, const string& name_template,
                               string* created_filename, unique_ptr<RWFile>* res) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixEnv::NewTempRWFile"", ""template"", name_template);
    int fd = 0;
    RETURN_NOT_OK(MkTmpFile(name_template, &fd, created_filename));
    res->reset(new PosixRWFile(*created_filename, fd, opts.sync_on_close));
    return Status::OK();
  }

  virtual bool FileExists(const string& fname) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixEnv::FileExists"", ""path"", fname);
    ThreadRestrictions::AssertIOAllowed();
    return access(fname.c_str(), F_OK) == 0;
  }

  virtual Status GetChildren(const string& dir, vector<string>* result) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixEnv::GetChildren"", ""path"", dir);
    MAYBE_RETURN_EIO(dir, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();
    result->clear();
    DIR* d = opendir(dir.c_str());
    if (d == nullptr) {
      return IOError(dir, errno);
    }
    struct dirent* entry;
    // TODO: lint: Consider using readdir_r(...) instead of readdir(...) for improved thread safety.
    while ((entry = readdir(d)) != nullptr) {
      result->push_back(entry->d_name);
    }
    closedir(d);
    return Status::OK();
  }

  virtual Status DeleteFile(const string& fname) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixEnv::DeleteFile"", ""path"", fname);
    MAYBE_RETURN_EIO(fname, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();
    Status result;
    if (unlink(fname.c_str()) != 0) {
      result = IOError(fname, errno);
    }
    return result;
  }

  virtual Status CreateDir(const string& name) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixEnv::CreateDir"", ""path"", name);
    MAYBE_RETURN_EIO(name, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();
    Status result;
    if (mkdir(name.c_str(), 0777) != 0) {
      result = IOError(name, errno);
    }
    return result;
  }

  virtual Status DeleteDir(const string& name) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixEnv::DeleteDir"", ""path"", name);
    MAYBE_RETURN_EIO(name, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();
    Status result;
    if (rmdir(name.c_str()) != 0) {
      result = IOError(name, errno);
    }
    return result;
  }

  Status GetCurrentWorkingDir(string* cwd) const override {
    TRACE_EVENT0(""io"", ""PosixEnv::GetCurrentWorkingDir"");
    ThreadRestrictions::AssertIOAllowed();
    unique_ptr<char[], FreeDeleter> wd(getcwd(nullptr, 0));
    if (!wd) {
      return IOError(""getcwd()"", errno);
    }
    cwd->assign(wd.get());

    MAYBE_RETURN_EIO(*cwd, IOError(Env::kInjectedFailureStatusMsg, EIO));
    return Status::OK();
  }

  Status ChangeDir(const string& dest) override {
    TRACE_EVENT1(""io"", ""PosixEnv::ChangeDir"", ""dest"", dest);
    MAYBE_RETURN_EIO(dest, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();
    Status result;
    if (chdir(dest.c_str()) != 0) {
      result = IOError(dest, errno);
    }
    return result;
  }

  virtual Status SyncDir(const string& dirname) OVERRIDE {
    TRACE_EVENT1(""io"", ""SyncDir"", ""path"", dirname);
    MAYBE_RETURN_EIO(dirname, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();
    if (FLAGS_never_fsync) return Status::OK();
    int dir_fd;
    RETRY_ON_EINTR(dir_fd, open(dirname.c_str(), O_DIRECTORY|O_RDONLY));
    if (dir_fd < 0) {
      return IOError(dirname, errno);
    }
    ScopedFdCloser fd_closer(dir_fd);
    if (fsync(dir_fd) != 0) {
      return IOError(dirname, errno);
    }
    return Status::OK();
  }

  virtual Status DeleteRecursively(const string &name) OVERRIDE {
    return Walk(name, POST_ORDER, Bind(&PosixEnv::DeleteRecursivelyCb,
                                       Unretained(this)));
  }

  virtual Status GetFileSize(const string& fname, uint64_t* size) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixEnv::GetFileSize"", ""path"", fname);
    MAYBE_RETURN_EIO(fname, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();
    Status s;
    struct stat sbuf;
    if (stat(fname.c_str(), &sbuf) != 0) {
      s = IOError(fname, errno);
    } else {
      *size = sbuf.st_size;
    }
    return s;
  }

  virtual Status GetFileSizeOnDisk(const string& fname, uint64_t* size) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixEnv::GetFileSizeOnDisk"", ""path"", fname);
    MAYBE_RETURN_EIO(fname, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();
    Status s;
    struct stat sbuf;
    if (stat(fname.c_str(), &sbuf) != 0) {
      s = IOError(fname, errno);
    } else {
      // From stat(2):
      //
      //   The st_blocks field indicates the number of blocks allocated to
      //   the file, 512-byte units. (This may be smaller than st_size/512
      //   when the file has holes.)
      *size = sbuf.st_blocks * 512;
    }
    return s;
  }

  virtual Status GetFileSizeOnDiskRecursively(const string& root,
                                              uint64_t* bytes_used) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixEnv::GetFileSizeOnDiskRecursively"", ""path"", root);
    uint64_t total = 0;
    RETURN_NOT_OK(Walk(root, Env::PRE_ORDER,
                       Bind(&PosixEnv::GetFileSizeOnDiskRecursivelyCb,
                            Unretained(this), &total)));
    *bytes_used = total;
    return Status::OK();
  }

  virtual Status GetBlockSize(const string& fname, uint64_t* block_size) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixEnv::GetBlockSize"", ""path"", fname);
    MAYBE_RETURN_EIO(fname, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();
    Status s;
    struct stat sbuf;
    if (stat(fname.c_str(), &sbuf) != 0) {
      s = IOError(fname, errno);
    } else {
      *block_size = sbuf.st_blksize;
    }
    return s;
  }

  virtual Status GetFileModifiedTime(const string& fname, int64_t* timestamp) override {
    TRACE_EVENT1(""io"", ""PosixEnv::GetFileModifiedTime"", ""fname"", fname);
    MAYBE_RETURN_EIO(fname, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();

    struct stat s;
    if (stat(fname.c_str(), &s) != 0) {
      return IOError(fname, errno);
    }
#ifdef __APPLE__
    *timestamp = s.st_mtimespec.tv_sec * 1000000 + s.st_mtimespec.tv_nsec / 1000;
#else
    *timestamp = s.st_mtim.tv_sec * 1000000 + s.st_mtim.tv_nsec / 1000;
#endif
    return Status::OK();
  }

  // Local convenience function for safely running statvfs().
  static Status StatVfs(const string& path, struct statvfs* buf) {
    MAYBE_RETURN_EIO(path, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();
    int ret;
    RETRY_ON_EINTR(ret, statvfs(path.c_str(), buf));
    if (ret == -1) {
      return IOError(Substitute(""statvfs: $0"", path), errno);
    }
    return Status::OK();
  }

  virtual Status GetSpaceInfo(const string& path, SpaceInfo* space_info) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixEnv::GetSpaceInfo"", ""path"", path);
    struct statvfs buf;
    RETURN_NOT_OK(StatVfs(path, &buf));
    space_info->capacity_bytes = buf.f_frsize * buf.f_blocks;
    space_info->free_bytes = buf.f_frsize * buf.f_bavail;
    return Status::OK();
  }

  virtual Status RenameFile(const string& src, const string& target) OVERRIDE {
    TRACE_EVENT2(""io"", ""PosixEnv::RenameFile"", ""src"", src, ""dst"", target);
    MAYBE_RETURN_EIO(src, IOError(Env::kInjectedFailureStatusMsg, EIO));
    MAYBE_RETURN_EIO(target, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();
    Status result;
    if (rename(src.c_str(), target.c_str()) != 0) {
      result = IOError(src, errno);
    }
    return result;
  }

  virtual Status LockFile(const string& fname, FileLock** lock) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixEnv::LockFile"", ""path"", fname);
    MAYBE_RETURN_EIO(fname, IOError(Env::kInjectedFailureStatusMsg, EIO));
    if (ShouldInject(fname, FLAGS_env_inject_lock_failure_globs)) {
      return IOError(""lock "" + fname, EAGAIN);
    }
    ThreadRestrictions::AssertIOAllowed();
    *lock = nullptr;
    Status result;
    int fd;
    RETRY_ON_EINTR(fd, open(fname.c_str(), O_RDWR | O_CREAT, 0666));
    if (fd < 0) {
      result = IOError(fname, errno);
    } else if (LockOrUnlock(fd, true) == -1) {
      result = IOError(""lock "" + fname, errno);
      int err;
      RETRY_ON_EINTR(err, close(fd));
      if (PREDICT_FALSE(err != 0)) {
        PLOG(WARNING) << ""Failed to close fd "" << fd;
      }
    } else {
      auto my_lock = new PosixFileLock;
      my_lock->fd_ = fd;
      *lock = my_lock;
    }
    return result;
  }

  virtual Status UnlockFile(FileLock* lock) OVERRIDE {
    TRACE_EVENT0(""io"", ""PosixEnv::UnlockFile"");
    ThreadRestrictions::AssertIOAllowed();
    unique_ptr<PosixFileLock> my_lock(reinterpret_cast<PosixFileLock*>(lock));
    Status result;
    if (LockOrUnlock(my_lock->fd_, false) == -1) {
      result = IOError(""unlock"", errno);
    }
    int err;
    RETRY_ON_EINTR(err, close(my_lock->fd_));
    if (PREDICT_FALSE(err != 0)) {
      PLOG(WARNING) << ""Failed to close fd "" << my_lock->fd_;
    }
    return result;
  }

  virtual Status GetTestDirectory(string* result) OVERRIDE {
    string dir;
    const char* env = getenv(""TEST_TMPDIR"");
    if (env && env[0] != '\\0') {
      dir = env;
    } else {
      char buf[100];
      snprintf(buf, sizeof(buf), ""/tmp/kudutest-%d"", static_cast<int>(geteuid()));
      dir = buf;
    }
    // Directory may already exist
    ignore_result(CreateDir(dir));
    // /tmp may be a symlink, so canonicalize the path.
    return Canonicalize(dir, result);
  }

  virtual uint64_t gettid() OVERRIDE {
    // Platform-independent thread ID.  We can't use pthread_self here,
    // because that function returns a totally opaque ID, which can't be
    // compared via normal means.
    if (thread_local_id == 0) {
      thread_local_id = Barrier_AtomicIncrement(&cur_thread_local_id_, 1);
    }
    return thread_local_id;
  }

  virtual uint64_t NowMicros() OVERRIDE {
    struct timeval tv;
    gettimeofday(&tv, nullptr);
    return static_cast<uint64_t>(tv.tv_sec) * 1000000 + tv.tv_usec;
  }

  virtual void SleepForMicroseconds(int micros) OVERRIDE {
    ThreadRestrictions::AssertWaitAllowed();
    SleepFor(MonoDelta::FromMicroseconds(micros));
  }

  virtual Status GetExecutablePath(string* path) OVERRIDE {
    MAYBE_RETURN_EIO(""/proc/self/exe"", IOError(Env::kInjectedFailureStatusMsg, EIO));
    uint32_t size = 64;
    uint32_t len = 0;
    while (true) {
      unique_ptr<char[]> buf(new char[size]);
#if defined(__linux__)
      int rc = readlink(""/proc/self/exe"", buf.get(), size);
      if (rc == -1) {
        return IOError(""Unable to determine own executable path"", errno);
      } else if (rc >= size) {
        // The buffer wasn't large enough
        size *= 2;
        continue;
      }
      len = rc;
#elif defined(__APPLE__)
      if (_NSGetExecutablePath(buf.get(), &size) != 0) {
        // The buffer wasn't large enough; 'size' has been updated.
        continue;
      }
      len = strlen(buf.get());
#else
#error Unsupported platform
#endif

      path->assign(buf.get(), len);
      break;
    }
    return Status::OK();
  }

  virtual Status IsDirectory(const string& path, bool* is_dir) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixEnv::IsDirectory"", ""path"", path);
    MAYBE_RETURN_EIO(path, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();
    Status s;
    struct stat sbuf;
    if (stat(path.c_str(), &sbuf) != 0) {
      s = IOError(path, errno);
    } else {
      *is_dir = S_ISDIR(sbuf.st_mode);
    }
    return s;
  }

  virtual Status Walk(const string& root, DirectoryOrder order, const WalkCallback& cb) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixEnv::Walk"", ""path"", root);
    MAYBE_RETURN_EIO(root, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();
    // Some sanity checks
    CHECK_NE(root, ""/"");
    CHECK_NE(root, ""./"");
    CHECK_NE(root, ""."");
    CHECK_NE(root, """");

    // FTS requires a non-const copy of the name. strdup it and free() when
    // we leave scope.
    unique_ptr<char[], FreeDeleter> name_dup(strdup(root.c_str()));
    char* paths[] = { name_dup.get(), nullptr };

    // FTS_NOCHDIR is important here to make this thread-safe.
    FTS* ret;
    POINTER_RETRY_ON_EINTR(ret, fts_open(
        paths, FTS_PHYSICAL | FTS_XDEV | FTS_NOCHDIR, nullptr));
    if (ret == nullptr) {
      return IOError(root, errno);
    }
    unique_ptr<FTS, FtsCloser> tree(ret);

    FTSENT* ent = nullptr;
    bool had_errors = false;
    while ((ent = fts_read(tree.get())) != nullptr) {
      bool doCb = false;
      FileType type = DIRECTORY_TYPE;
      switch (ent->fts_info) {
        case FTS_D:         // Directory in pre-order
          if (order == PRE_ORDER) {
            doCb = true;
          }
          break;
        case FTS_DP:        // Directory in post-order
          if (order == POST_ORDER) {
            doCb = true;
          }
          break;
        case FTS_F:         // A regular file
        case FTS_SL:        // A symbolic link
        case FTS_SLNONE:    // A broken symbolic link
        case FTS_DEFAULT:   // Unknown type of file
          doCb = true;
          type = FILE_TYPE;
          break;

        case FTS_DNR:
        case FTS_ERR:
        case FTS_NS:
          LOG(WARNING) << ""Unable to access file "" << ent->fts_path
                       << "" during walk: "" << strerror(ent->fts_errno);
          had_errors = true;
          break;

        default:
          LOG(WARNING) << ""Unable to access file "" << ent->fts_path
                       << "" during walk (code "" << ent->fts_info << "")"";
          break;
      }
      if (doCb) {
        if (!cb.Run(type, DirName(ent->fts_path), ent->fts_name).ok()) {
          had_errors = true;
        }
      }
    }

    if (had_errors) {
      return Status::IOError(root, ""One or more errors occurred"");
    }
    return Status::OK();
  }

  Status Glob(const string& path_pattern, vector<string>* paths) override {
    TRACE_EVENT1(""io"", ""PosixEnv::Glob"", ""path_pattern"", path_pattern);
    ThreadRestrictions::AssertIOAllowed();

    glob_t result;
    auto cleanup = MakeScopedCleanup([&] { globfree(&result); });

    errno = 0;
    int ret = glob(path_pattern.c_str(), GLOB_TILDE | GLOB_ERR , NULL, &result);
    switch (ret) {
      case 0: break;
      case GLOB_NOMATCH: return Status::OK();
      case GLOB_NOSPACE: return Status::RuntimeError(""glob out of memory"");
      default: {
        string err = (errno != 0) ? ErrnoToString(errno) : ""unknown error"";
        return Status::IOError(Substitute(""glob failed for $0: $1"",
                                          path_pattern,
                                          err));
      }
    }

    for (size_t i = 0; i < result.gl_pathc; ++i) {
      paths->emplace_back(result.gl_pathv[i]);
    }
    return Status::OK();
  }

  virtual Status Canonicalize(const string& path, string* result) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixEnv::Canonicalize"", ""path"", path);
    MAYBE_RETURN_EIO(path, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();
    unique_ptr<char[], FreeDeleter> r(realpath(path.c_str(), nullptr));
    if (!r) {
      return IOError(Substitute(""Unable to canonicalize $0"", path), errno);
    }
    *result = string(r.get());
    return Status::OK();
  }

  virtual Status GetTotalRAMBytes(int64_t* ram) OVERRIDE {
#if defined(__APPLE__)
    int mib[2];
    size_t length = sizeof(*ram);

    // Get the Physical memory size
    mib[0] = CTL_HW;
    mib[1] = HW_MEMSIZE;
    CHECK_ERR(sysctl(mib, 2, ram, &length, nullptr, 0)) << ""sysctl CTL_HW HW_MEMSIZE failed"";
#else
    struct sysinfo info;
    if (sysinfo(&info) < 0) {
      return IOError(""sysinfo() failed"", errno);
    }
    *ram = info.totalram;
#endif
    return Status::OK();
  }

  virtual uint64_t GetResourceLimit(ResourceLimitType t) OVERRIDE {
    static_assert(std::is_unsigned<rlim_t>::value, ""rlim_t must be unsigned"");
    static_assert(RLIM_INFINITY > 0, ""RLIM_INFINITY must be positive"");

    // There's no reason for this to ever fail.
    struct rlimit l;
    PCHECK(getrlimit(ResourceLimitTypeToUnixRlimit(t), &l) == 0);
    return l.rlim_cur;
  }

  virtual void IncreaseResourceLimit(ResourceLimitType t) OVERRIDE {
    // There's no reason for this to ever fail; any process should have
    // sufficient privilege to increase its soft limit up to the hard limit.
    //
    // This change is logged because it is process-wide.

    int rlimit_type = ResourceLimitTypeToUnixRlimit(t);
    struct rlimit l;
    PCHECK(getrlimit(rlimit_type, &l) == 0);
#if defined(__APPLE__)
    // OS X 10.11 can return RLIM_INFINITY from getrlimit, but allows rlim_cur and
    // rlim_max to be raised only as high as the value of the maxfilesperproc
    // kernel variable. Empirically, this value is 10240 across all tested macOS
    // versions. Testing on OS X 10.10 and macOS 10.12 revealed that getrlimit
    // returns the true limits (not RLIM_INFINITY), rlim_max can *not* be raised
    // (when running as non-root), and rlim_cur can only be raised as high as
    // rlim_max (this is consistent with Linux).
    // TLDR; OS X 10.11 is whack.
    if (l.rlim_max == RLIM_INFINITY) {
      uint32_t limit;
      size_t len = sizeof(limit);
      PCHECK(sysctlbyname(ResourceLimitTypeToMacosRlimit(t), &limit, &len,
                          nullptr, 0) == 0);
      // Make sure no uninitialized bits are present in the result.
      DCHECK_EQ(sizeof(limit), len);
      l.rlim_max = limit;
    }
#endif
    const char* rlimit_str = ResourceLimitTypeToString(t);
    if (l.rlim_cur < l.rlim_max) {
      LOG(INFO) << Substitute(""Raising this process' $0 limit from $1 to $2"",
                              rlimit_str, l.rlim_cur, l.rlim_max);
      l.rlim_cur = l.rlim_max;
      PCHECK(setrlimit(rlimit_type, &l) == 0);
    } else {
      LOG(INFO) << Substitute(""Not raising this process' $0 limit of $1; it ""
          ""is already as high as it can go"", rlimit_str, l.rlim_cur);
    }
  }

  virtual Status IsOnExtFilesystem(const string& path, bool* result) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixEnv::IsOnExtFilesystem"", ""path"", path);
    MAYBE_RETURN_EIO(path, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();

#ifdef __APPLE__
    *result = false;
#else
    struct statfs buf;
    int ret;
    RETRY_ON_EINTR(ret, statfs(path.c_str(), &buf));
    if (ret == -1) {
      return IOError(Substitute(""statfs: $0"", path), errno);
    }
    *result = (buf.f_type == EXT4_SUPER_MAGIC);
#endif
    return Status::OK();
  }

  virtual Status IsOnXfsFilesystem(const string& path, bool* result) OVERRIDE {
    TRACE_EVENT1(""io"", ""PosixEnv::IsOnXfsFilesystem"", ""path"", path);
    MAYBE_RETURN_EIO(path, IOError(Env::kInjectedFailureStatusMsg, EIO));
    ThreadRestrictions::AssertIOAllowed();
    return DoIsOnXfsFilesystem(path, result);
  }

  virtual string GetKernelRelease() OVERRIDE {
    // There's no reason for this to ever fail.
    struct utsname u;
    PCHECK(uname(&u) == 0);
    return string(u.release);
  }

  Status EnsureFileModeAdheresToUmask(const string& path) override {
    MAYBE_RETURN_EIO(path, IOError(Env::kInjectedFailureStatusMsg, EIO));
    struct stat s;
    if (stat(path.c_str(), &s) != 0) {
      return IOError(""stat"", errno);
    }
    CHECK_NE(g_parsed_umask, -1);
    if (s.st_mode & g_parsed_umask) {
      uint32_t old_perms = s.st_mode & ACCESSPERMS;
      uint32_t new_perms = old_perms & ~g_parsed_umask;
      LOG(WARNING) << ""Path "" << path << "" has permissions ""
                   << StringPrintf(""%03o"", old_perms)
                   << "" which are less restrictive than current umask value ""
                   << StringPrintf(""%03o"", g_parsed_umask)
                   << "": resetting permissions to ""
                   << StringPrintf(""%03o"", new_perms);
      if (chmod(path.c_str(), new_perms) != 0) {
        return IOError(""chmod"", errno);
      }
    }
    return Status::OK();
  }

  Status IsFileWorldReadable(const string& path, bool* result) override {
    ThreadRestrictions::AssertIOAllowed();
    TRACE_EVENT1(""io"", ""PosixEnv::IsFileWorldReadable"", ""path"", path);
    MAYBE_RETURN_EIO(path, IOError(Env::kInjectedFailureStatusMsg, EIO));
    struct stat s;
    if (stat(path.c_str(), &s) != 0) {
      return IOError(""stat"", errno);
    }
    *result = (s.st_mode & S_IROTH) != 0;
    return Status::OK();
  }

  virtual Status CreateSymLink(const string& src, const string& dst) override {
    ThreadRestrictions::AssertIOAllowed();
    TRACE_EVENT2(""io"", ""PosixEnv::CreateSymLink"", ""src"", src, ""dst"", dst);
    MAYBE_RETURN_EIO(dst, IOError(Env::kInjectedFailureStatusMsg, EIO));
    Status result;
    if (symlink(src.c_str(), dst.c_str()) != 0) {
      result = IOError(dst, errno);
    }
    return result;
  }

 private:
  // unique_ptr Deleter implementation for fts_close
  struct FtsCloser {
    void operator()(FTS *fts) const {
      if (fts) {
        int err;
        RETRY_ON_EINTR(err, fts_close(fts));
        if (PREDICT_FALSE(err != 0)) {
          PLOG(WARNING) << ""Failed to close fts"";
        }
      }
    }
  };

  Status MkTmpFile(const string& name_template, int* fd, string* created_filename) {
    ThreadRestrictions::AssertIOAllowed();
    unique_ptr<char[]> fname(new char[name_template.size() + 1]);
    ::snprintf(fname.get(), name_template.size() + 1, ""%s"", name_template.c_str());
    MAYBE_RETURN_EIO(fname.get(), IOError(Env::kInjectedFailureStatusMsg, EIO));
    int created_fd = mkstemp(fname.get());
    if (created_fd < 0) {
      return IOError(Substitute(""Call to mkstemp() failed on name template $0"", name_template),
                     errno);
    }
    // mkstemp defaults to making files with permissions 0600. But, if the
    // user configured a more permissive umask, then we ensure that the
    // resulting file gets the desired (wider) permissions.
    uint32_t new_perms = 0666 & ~g_parsed_umask;
    if (new_perms != 0600) {
      CHECK_ERR(fchmod(created_fd, new_perms));
    }
    *fd = created_fd;
    *created_filename = fname.get();
    return Status::OK();
  }

  Status InstantiateNewWritableFile(const string& fname,
                                    int fd,
                                    const WritableFileOptions& opts,
                                    unique_ptr<WritableFile>* result) {
    uint64_t file_size = 0;
    if (opts.mode == MUST_EXIST) {
      RETURN_NOT_OK(GetFileSize(fname, &file_size));
    }
    result->reset(new PosixWritableFile(fname, fd, file_size, opts.sync_on_close));
    return Status::OK();
  }

  Status DeleteRecursivelyCb(FileType type, const string& dirname, const string& basename) {
    string full_path = JoinPathSegments(dirname, basename);
    Status s;
    switch (type) {
      case FILE_TYPE:
        s = DeleteFile(full_path);
        WARN_NOT_OK(s, ""Could not delete file"");
        return s;
      case DIRECTORY_TYPE:
        s = DeleteDir(full_path);
        WARN_NOT_OK(s, ""Could not delete directory"");
        return s;
      default:
        LOG(FATAL) << ""Unknown file type: "" << type;
        return Status::OK();
    }
  }

  Status GetFileSizeOnDiskRecursivelyCb(uint64_t* bytes_used,
                                        Env::FileType type,
                                        const string& dirname,
                                        const string& basename) {
    uint64_t file_bytes_used = 0;
    switch (type) {
      case Env::FILE_TYPE:
        RETURN_NOT_OK(GetFileSizeOnDisk(
            JoinPathSegments(dirname, basename), &file_bytes_used));
        *bytes_used += file_bytes_used;
        break;
      case Env::DIRECTORY_TYPE:
        // Ignore directory space consumption as it varies from filesystem to
        // filesystem.
        break;
      default:
        LOG(FATAL) << ""Unknown file type: "" << type;
    }
    return Status::OK();
  }
};

}  // namespace

static pthread_once_t once = PTHREAD_ONCE_INIT;
static Env* default_env;
static void InitDefaultEnv() { default_env = new PosixEnv; }

Env* Env::Default() {
  pthread_once(&once, InitDefaultEnv);
  return default_env;
}

std::ostream& operator<<(std::ostream& o, Env::ResourceLimitType t) {
  return o << ResourceLimitTypeToString(t);
}

}  // namespace kudu
",16355,True,3192.0854966896836,median
"---
title: Appendice C. Risorse su Internet
part: Parte V. Appendici
prev: books/handbook/bibliography
next: books/handbook/pgpkeys
---

[appendix]
[[eresources]]
= Risorse su Internet
:doctype: book
:toc: macro
:toclevels: 1
:icons: font
:sectnums:
:sectnumlevels: 6
:sectnumoffset: C
:partnums:
:source-highlighter: rouge
:experimental:
:images-path: books/handbook/eresources/

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::[]

Il rapido sviluppo di FreeBSD rende la carta stampata un mezzo non pratico per poterne seguire l'evoluzione. Le risorse in rete sono il migliore, se non l'unico, modo per tenersi informati sulle novità di questo sistema. Dal momento che FreeBSD è il prodotto del lavoro di volontari, la comunità degli utenti generalmente si presta anche ad una funzione di ""supporto tecnico"" di varia natura, con l'email e le news USENET come il mezzo più efficace per entrare in contatto con queste comunità.

I più frequentati punti di ritrovo della comunità FreeBSD sono esposti di seguito. Se aveste conoscenza di altre risorse non menzionate in questa sede, vi preghiamo di darne informazione a {freebsd-doc} cosicchè possano essere incluse.

[[eresources-mail]]
== Mailing Lists

Anche se molti sviluppatori di FreeBSD leggono USENET, non può esservi garanzia di ottenere risposta alle proprie domande in tempi brevi (e in generale non può esservi garanzia di ottenere alcuna risposta) semplicemente scrivendo ad uno dei mail-group di `comp.unix.bsd.freebsd.*`. Indirizzando i propri messaggi alla mailing list appropriata si raggiungerà una audience più concentrata ed informata, permettendo risposte più precise (o quanto meno più sollecite).

Gli argomenti delle varie liste sono elencati all'inizio del documento. _Si prega di leggere gli argomenti_ prima di unirsi o scrivere ad una lista. La maggior parte dei sottoscrittori di liste ricevono ogni giorno svariate centinaia di messaggi, e mantenendo argomenti e regole di comportamento cerchiamo di tenere alto il rapporto segnale/rumore della lista. Venir meno a queste regole vorrebbe dire il fallimento della mailing list come mezzo efficace di comunicazione per il progetto.

[NOTE]
====
_Se vuoi verificare la tua abilità nel spedire alle liste di FreeBSD, manda un messaggio testuale a {freebsd-test}._ Per favore non mandare messaggi di prova a altre liste.
====

Se hai alcuni dubbi su quale lista postare una questione, leggi extref:{freebsd-questions-article}[Come ottenere i migliori risultati dalla mailing list FreeBSD-questions].

Prima di postare su qualsiasi lista, per favore impara a come usare al meglio le mailing list, ad esempio come evitare discussioni che vengono richieste di frequente, leggendo il documento (FAQ) extref:{mailing-list-faq}[Le Questioni Maggiormente Richieste sulle Mailing List].

Vengono tenuti archivi per tutte le mailing list, e questi possono essere esplorati usando il link:https://www.FreeBSD.org/search/[FreeBSD World Wide Web server]. L'archivio esplorabile per parole chiave costituisce un mezzo eccellente per trovare risposte a domande poste di frequente e dovrebbe essere consultato prima di spedire una domanda.

[[eresources-summary]]
=== Sommario delle liste

_Liste generiche:_ Le seguenti sono liste generiche a cui tutti sono invitati (e incoraggiati) a partecipare:

[.informaltable]
[cols=""1,1"", frame=""none"", options=""header""]
|===
| Lista
| Argomento

|link:{cvs-all-url}[cvs-all]
|Cambiamenti apportati all'albero dei sorgenti di FreeBSD

|link:{freebsd-advocacy-url}[freebsd-advocacy]
|Evangelismo FreeBSD

|{freebsd-announce}
|Eventi importanti e annunci di progetti

|link:{freebsd-arch-url}[freebsd-arch]
|Discussioni sull'architettura ed il design

|link:{freebsd-bugbusters-url}[freebsd-bugbusters]
|Discussioni incentrate sul mantenimento del database dei report dei problemi di FreeBSD e progetti correlati

|link:{freebsd-bugs-url}[freebsd-bugs]
|Report sui bug

|link:{freebsd-chat-url}[freebsd-chat]
|Argomenti non-tecnici di interesse della comunità FreeBSD

|{freebsd-current}
|Discussioni sull'utilizzo di FreeBSD.current;

|link:{freebsd-isp-url}[freebsd-isp]
|Argomenti di interesse degli Internet Service Providers che usano FreeBSD

|link:{freebsd-jobs-url}[freebsd-jobs]
|Opportunità di lavoro e consulenza relative a FreeBSD

|link:{freebsd-policy-url}[freebsd-policy]
|Le decisioni sulla politica da adottare del core degli sviluppatori FreeBSD. Toni pacati e sola lettura

|link:{freebsd-questions-url}[freebsd-questions]
|Domande degli utenti e assistenza tecnica

|{freebsd-security-notifications}
|Notifiche sulla sicurezza

|{freebsd-stable}
|Discussioni sull'uso di FreeBSD.stable;

|{freebsd-test}
|Dove spedire i tuoi messaggi di test, lasciando in pace le altre liste
|===

_Liste tecniche:_ le seguenti liste sono a carattere tecnico. Dovreste leggere attentamente gli argomenti elencati di seguito prima di unirvi o spedirvi mail, poichè ci sono strette linee di condotta per il loro uso ed il loro contenuto.

[.informaltable]
[cols=""1,1"", frame=""none"", options=""header""]
|===
| Lista
| Argomento

|{freebsd-acpi}
|Sviluppo di ACPI e della gestione dell'energia

|link:{freebsd-afs-url}[freebsd-afs]
|Il porting di AFS su FreeBSD

|link:{freebsd-aic7xxx-url}[freebsd-aic7xxx]
|Sviluppare drivers per Adaptec(R) AIC 7xxx

|link:{alpha-url}[alpha]
|Il porting di FreeBSD su Alpha

|link:{freebsd-amd64-url}[freebsd-amd64]
|Il porting di FreeBSD sui sistemi AMD64

|link:{freebsd-apache-url}[freebsd-apache]
|Discussioni sui port relativi ad Apache

|link:{freebsd-arm-url}[freebsd-arm]
|Il porting di FreeBSD su processori ARM(R)

|link:{freebsd-atm-url}[freebsd-atm]
|Usare reti ATM con FreeBSD

|link:{freebsd-audit-url}[freebsd-audit]
|Il progetto di audit del codice sorgente

|link:{freebsd-binup-url}[freebsd-binup]
|Il design e lo sviluppo del sistema di aggiornamento dei binari

|link:{freebsd-bluetooth-url}[freebsd-bluetooth]
|Usare la tecnologia Bluetooth(R) su FreeBSD

|link:{freebsd-cluster-url}[freebsd-cluster]
|Usare FreeBSD in cluster

|link:{freebsd-cvsweb-url}[freebsd-cvsweb]
|Il mantenimento di CVSweb

|link:{freebsd-database-url}[freebsd-database]
|Discussioni sull'uso e lo sviluppo di database sotto FreeBSD

|link:{freebsd-doc-url}[freebsd-doc]
|Creare documenti su FreeBSD

|link:{freebsd-drivers-url}[freebsd-drivers]
|Scrivere driver di dispositivi per FreeBSD

|link:{freebsd-eclipse-url}[freebsd-eclipse]
|Utenti FreeBSD di Eclipse IDE, strumenti, applicazioni client e port.

|link:{freebsd-embedded-url}[freebsd-embedded]
|Come usare FreeBSD in applicazioni embedded

|link:{freebsd-emulation-url}[freebsd-emulation]
|L'emulazione di altri sistemi operativi come Linux/MS-DOS(R)/Windows(R)

|link:{freebsd-eol-url}[freebsd-eol]
|Supporto per il software relativo a FreeBSD che non è più supportato dal progetto FreeBSD.

|link:{freebsd-firewire-url}[freebsd-firewire]
|Discussioni tecniche sui FreeBSD FireWire(R) (iLink, IEEE 1394)

|link:{freebsd-fs-url}[freebsd-fs]
|I file system

|link:{freebsd-geom-url}[freebsd-geom]
|Discussioni e implementazioni riguardanti GEOM

|link:{freebsd-gnome-url}[freebsd-gnome]
|Il porting di GNOME e delle applicazioni GNOME

|link:{freebsd-hackers-url}[freebsd-hackers]
|Discussioni tecniche generiche

|link:{freebsd-hardware-url}[freebsd-hardware]
|Discussioni tecniche generiche sull'hardware e FreeBSD

|link:{freebsd-i18n-url}[freebsd-i18n]
|L'internazionalizzazione di FreeBSD

|link:{freebsd-ia32-url}[freebsd-ia32]
|FreeBSD sulla piattaforma IA-32 (Intel(R) x86)

|link:{freebsd-ia64-url}[freebsd-ia64]
|Il porting di FreeBSD ai futuri sistemi Intel(R) IA64

|link:{freebsd-ipfw-url}[freebsd-ipfw]
|Discussioni tecniche sul redesign del codice del firewall

|link:{freebsd-isdn-url}[freebsd-isdn]
|Sviluppatori ISDN

|link:{freebsd-jail-url}[freebsd-jail]
|Discussioni sul metodo man:jail[8]

|link:{freebsd-java-url}[freebsd-java]
|Sviluppatori Java(TM) e persone coinvolte nel port delle JDK(TM) sotto FreeBSD

|link:{freebsd-kde-url}[freebsd-kde]
|Il porting di KDE e delle applicazioni KDE

|link:{freebsd-lfs-url}[freebsd-lfs]
|Il porting di LFS sotto FreeBSD

|link:{freebsd-libh-url}[freebsd-libh]
|Il sistema di installazione e di gestione dei pacchetti di seconda generazione

|link:{freebsd-mips-url}[freebsd-mips]
|Il porting di FreeBSD su MIPS(R)

|link:{freebsd-mobile-url}[freebsd-mobile]
|Discussioni sui portatili

|link:{freebsd-mozilla-url}[freebsd-mozilla]
|Il porting di Mozilla sotto FreeBSD

|{freebsd-multimedia}
|Applicazioni multimediali

|link:{freebsd-new-bus-url}[freebsd-new-bus]
|Discussioni tecniche sull'architettura bus

|link:{freebsd-net-url}[freebsd-net]
|Discussione sul networking e codice sorgente TCP/IP

|link:{freebsd-openoffice-url}[freebsd-openoffice]
|Il porting di OpenOffice.org e StarOffice(TM) su FreeBSD

|link:{freebsd-performance-url}[freebsd-performance]
|Questioni relative alla calibrazione delle prestazioni per installazioni a ad alta performance o carico elevato

|link:{freebsd-perl-url}[freebsd-perl]
|Mantenimento di un numero di port relativi a perl

|link:{freebsd-pf-url}[freebsd-pf]
|Discussioni sul sistema di firewall packet filter

|link:{freebsd-platforms-url}[freebsd-platforms]
|Riguardo al porting di FreeBSD su architetture non Intel(R)

|link:{freebsd-ports-url}[freebsd-ports]
|Discussione sulla collezione dei port

|link:{freebsd-ports-bugs-url}[freebsd-ports-bugs]
|Discussione sui bug/PR relativi ai port

|link:{freebsd-ppc-url}[freebsd-ppc]
|Il porting di FreeBSD su PowerPC(R)

|link:{freebsd-proliant-url}[freebsd-proliant]
|Discussioni tecniche di FreeBSD su piattaforme server HP ProLiant

|link:{freebsd-python-url}[freebsd-python]
|Discussioni riguardo Python su FreeBSD.

|link:{qa-url}[qa]
|Discussione su certificati di qualità, solitamente sotto una release

|link:{freebsd-rc-url}[freebsd-rc]
|Discussione sul sistema [.filename]#rc.d# e relativo sviluppo

|link:{freebsd-realtime-url}[freebsd-realtime]
|Sviluppo di estensioni realtime su FreeBSD

|link:{freebsd-scsi-url}[freebsd-scsi]
|Il sottosistema SCSI

|{freebsd-security}
|Questioni relative alla sicurezza di FreeBSD

|link:{freebsd-small-url}[freebsd-small]
|L'uso di FreeBSD in applicazioni embedded (obsoleto; usare al suo posto link:{freebsd-embedded-url}[freebsd-embedded])

|link:{smp-url}[smp]
|Discussioni di design per sistemi a multiprocessore [a]simmetrico

|link:{freebsd-sparc64-url}[freebsd-sparc64]
|Il porting di FreeBSD su architetture SPARC(R)

|link:{freebsd-standards-url}[freebsd-standards]
|La coerenza di FreeBSD agli standards C99 e POSIX(R)

|link:{freebsd-sun4v-url}[freebsd-sun4v]
|Il porting di FreeBSD su sistemi T1 UltraSPARC(R)

|link:{freebsd-testing-url}[freebsd-testing]
|Test di stabilità e performance di FreeBSD

|link:{freebsd-threads-url}[freebsd-threads]
|Threading in FreeBSD

|link:{freebsd-tokenring-url}[freebsd-tokenring]
|Supporto per il token-ring in FreeBSD

|link:{freebsd-usb-url}[freebsd-usb]
|Supporto USB in FreeBSD

|link:{freebsd-vuxml-url}[freebsd-vuxml]
|Discussioni sull'infrastruttura VuXML

|link:{freebsd-x11-url}[freebsd-x11]
|Mantenimento e supporto di X11 su FreeBSD
|===

_Liste limitate:_ Le seguenti liste sono adatte ad un audience più specializzata (ed esigente) e probabilmente non sono di interesse del pubblico generico. È inoltre buona norma frequentare le liste tecniche prima di unirsi ad una di queste liste così da comprendere l'etichetta di comunicazione richiesta.

[.informaltable]
[cols=""1,1"", frame=""none"", options=""header""]
|===
| Lista
| Argomento

|link:{freebsd-hubs-url}[freebsd-hubs]
|Per coloro che gestiscono mirrors (supporto infrastrutturale)

|link:{freebsd-user-groups-url}[freebsd-user-groups]
|Coordinamento dei gruppi utenti

|link:{freebsd-vendors-url}[freebsd-vendors]
|Coordinamento dei venditori pre-release

|link:{freebsd-www-url}[freebsd-www]
|Coloro che mantengono il sito link:https://www.FreeBSD.org/it/[www.FreeBSD.org]
|===

_Liste digest:_ Tutte le liste sopracitate sono anche consultabili come digest. Una volta iscritto a una lista, puoi cambiare le tue opzioni digest nella sezione delle opzioni del tuo account.

_Liste CVS:_ Le liste seguenti sono per le persone interessate a vedere i messaggi di log delle modifiche alle varie aree dell'albero dei sorgenti. Sono liste a _Sola Lettura_ e non si dovrebbero inviare messaggi ad esse.

[.informaltable]
[cols=""1,1,1"", frame=""none"", options=""header""]
|===
| Lista
| Area dei sorgenti
| Descrizione dell'area

|link:{cvs-all-url}[cvs-all]
|[.filename]#/usr/(CVSROOT\\|doc\\|ports\\|projects\\|src)#
|Tutte le modifiche in ogni parte dell'albero (unione di tutte le altre liste di commit CVS)

|link:{cvs-doc-url}[cvs-doc]
|[.filename]#/usr/(doc\\|www)#
|Tutte le modifiche all'albero doc e www

|link:{cvs-ports-url}[cvs-ports]
|[.filename]#/usr/ports#
|Tutte le modifiche all'albero ports

|link:{cvs-projects-url}[cvs-projects]
|[.filename]#/usr/projects#
|Tutte le modifiche all'albero projects

|link:{cvs-src-url}[cvs-src]
|[.filename]#/usr/src#
|Tutte le modifiche all'albero src
|===

[[eresources-subscribe]]
=== Come iscriversi

Per iscriverti ad una lista, clicca sul nome della lista qui sopra o vai su {mailing-lists-url} e clicca sulla lista a cui sei interessato. La pagina delle liste dovrebbe contenere tutte le informazioni necessarie all'iscrizione.

Per mandare un messaggio ad una lista basta inviare una mail a mailto:listname@FreeBSD.org[listname@FreeBSD.org]. Sarà poi redisribuita a tutti i membri della lista.

Per disiscriverti da una lista, clicca sull'URL che trovi in fondo a ogni email ricevuta dalla lista. È anche possibile inviare un'email a mailto:listname-unsubscribe@FreeBSD.org[listname-unsubscribe@FreeBSD.org] per disiscriverti.

A costo di ripeterci, vorremmo che i membri della lista tecnica tenessero la discussione su un tono tecnico. Se sei solo interessato ad annunci importanti, allora è preferibile che ti iscrivi alla {freebsd-announce}, creata apposta per traffico non frequente.

[[eresources-charters]]
=== Argomenti delle liste

_Tutte_ le mailing list FreeBSD hanno alcune regole base che tutti gli utenti devono seguire. La mancata aderenza a queste regole comporterà due (2) avvisi scritti dal PostMaster FreeBSD mailto:postmaster@FreeBSD.org[postmaster@FreeBSD.org], dopo dei quali, ad una terza trasgressione, il membro sarà espulso da tutte le mailing list di FreeBSD e gli sarà impedita qualsiasi futura iscrizione. Siamo mortificati del fatto che queste regole e misure siano necessarie, ma al giorno d'oggi Internet è diventato, a quanto pare, un'ambiente alquanto disordinato, e molti paiono scordarsi di quanto siano fragili alcuni suoi meccanismi.

Regole della strada:

* L'argomento di ogni messaaggio dovrebbe aderire all'argomento della lista a cui è inviato, ad esempio se la lista è a carattere tecnico, i vostri messaggi dovrebbero contenere discussioni tecniche. Chiacchiericci continui ed irrilevanti vanno a discapito del valore della lista per tutti i suoi membri e non saranno tollerati. Per discussioni libere senza restrizioni sull'argomento, la {freebsd-chat} è liberamente fruibile e dovrebbe essere usata per questo.
* Non bisognerebbe scrivere a più di due mailing list, ed anche a due solo e soltanto se un motivo reale e concreto esiste. Per molte liste, esiste già un grande traffico di messaggi che si sovrappongono ed eccetto per i mix più esoterici (ad esempio ""-stable & -scsi""), non c'è alcun motivo di scrivere a più di una lista alla volta. Se un messaggio è inviato in modo tale che molte mailing list appaiono nella linea `Cc`, allora la linea `Cc` dovrebbe essere suddivisa prima di inviare nuovi messaggi. _Voi siete del tutto responsabili per i vostri messaggi inviati in modo errato, non importa di chi sia la causa._
* Attacchi personali ed insulti (nel contesto di una discussione) non sono permessi, e questa regola comprende membri e sviluppatori. Gravi violazioni della netiquette, come citare o inviare messaggi altrui quando il permesso a farlo non c'era e non sarebbe giunto sono altamente disapprovate ma non sanzionate direttamente. _Comunque_, ci sono pochissimi casi in cui questi messaggi sarebbero pertinenti all'argomento della lista, quindi tali comportamenti probabilmente otterrebbero un avviso (o un espulsione) del Postmaster, solo per quel motivo.
* Pubblicità di prodotti non-FreeBSD è altamente proibita e comportertà un'espulsione immediata se è chiaro che il trasgressore sta inviando pubblicità spam.

_Argomenti delle singole liste:_

{freebsd-acpi}::
_Sviluppo di ACPI e della gestione dell'energia_

link:{freebsd-afs-url}[freebsd-afs]::
_Andrew File System_
+
Questa è la lista per le discussioni sul porting e l'uso dell' AFS da CMU/Transarc.

{freebsd-announce}::
_Eventi importanti/pietre miliari_
+
Questa è la mailing list per le persone interessate soltanto in annunci occasionali di eventi significativi riguardanti FreeBSD. Contiene annunci riguardo snapshots e altre release. Contiene annunci su nuove potenzialità di FreeBSD. Può contenere richieste di volontari etc. È una mailing list dal poco traffico, strettamente regolata.

link:{freebsd-arch-url}[freebsd-arch]::
_Discussione sull'architettura e la progettazione_
+
Questa lista è per la discussione dell'architettura FreeBSD. I messaggi saranno mantenuti strettamente tecnici di natura. Esempi di possibili argomenti:

** Come modificare il processo di build per avere molti build personalizzati in funzione allo stesso tempo.
** Cosa deve essere modificato nel VFS per far funzionare i layers Heimann.
** Come modificare l'interfaccia dei device driver per poter usare gli stessi driver senza problemi su molti buses e architetture.
** Come scrivere un driver di rete.

link:{freebsd-audit-url}[freebsd-audit]::
_Progetto di audit del sorgente_
+
Questa è la mailing list per il progetto di audit del codice FreeBSD. Anche se in origine era intesa per cambiamenti relativi alla sicurezza, le sue caratteristiche sono state estese per includere ogni cambiamento al codice.
+
Questa lista è piena di discussioni di patch, e probabilmente di non grandissimo interesse per l'utente medio FreeBSD. Discussioni sulla sicurezza non relative ad una particolare modifica del codice si tengono in FreeBSD-security. Nel frattempo tutti gli svilupatori sono incoraggiati a spedire le proprie patch a questa lista per correzioni, specialmente se toccano parte del sistema dove un bug può influenzare negativamente l'integrità del sistema.

link:{freebsd-binup-url}[freebsd-binup]::
_Aggiornamento dei binari FreeBSD_
+
Questa lista esiste per fornire un terreno di discussione per il sistema di aggiornamento dei binari, o binup. Sono consentite questioni di design, dettagli di implementazione, patch, report di bug, report di status, richieste di feature, log delle modifiche, e tutto ciò che riguardi binup.

link:{freebsd-bluetooth-url}[freebsd-bluetooth]::
_Bluetooth(R) su FreeBSD_
+
Questo è il forum dove si riuniscono gli utenti Bluetooth(R) di FreeBSD. Sono consentite aromentazioni su problemi di progettazione, dettagli implementativi, patch, report di bug, lo stato attuale, nuove caratteristiche, e altro materiale relativo a Bluetooth(R).

link:{freebsd-bugbusters-url}[freebsd-bugbusters]::
_Coordinamento dello sforzo di gestione dei Problem Report_
+
Lo scopo di questa lista è di servire come forum di coordinamento e discussione per il Bugmeister, i suoi Bugbuster, e ogni altra parte che abbia un genuino interesse nel database PR. Questa lista non è per la discussione di bug specifici, patch, o PR.

link:{freebsd-bugs-url}[freebsd-bugs]::
_Report di bug_
+
Questa è la lista per i report dei bug di FreeBSD. Quando possibile, i bug dovrebbero essere indicati usando il comando man:send-pr[1] o tramite la sua link:https://www.FreeBSD.org/send-pr/[interfaccia WEB].

link:{freebsd-chat-url}[freebsd-chat]::
_Argomenti non tecnici relativi alla comunità FreeBSD_
+
Questa lista contiene ciò che resta dalle altre liste riguardo ad informazioni non tecniche, sociali. Include discussioni sul fatto che Jordan sembri o meno un toon ferret, se scrivere o meno in maiuscolo, chi sta bevendo troppo caffè, dove spillano la migliore birra, chi spilla birra in cantina, e così via. Annunci occasionali di eventi importanti (party a venire, celebrazioni di matrimoni, nascite, nuovi lavori etc.) possono essere fatti alle liste non tecniche, ma i suddetti argomenti dovrebbero essere diretti a questa lista.

{core-name}::
_Il core team di FreeBSD_
+
Questa è una lista interna ad uso dei membri core. Messaggi possono esservi spediti quando una seria questione relativa a FreeBSD richiede un arbitrato da un alto scrutinio.

{freebsd-current}::
_Discussioni sull'uso di FreeBSD.current;_
+
Questa è la mailing list di discussione di FreeBSD.current;. Contiene avvertimenti su nuove features in arrivo in -CURRENT che toccheranno gli utenti, ed istruzioni su passi che devono restare -CURRENT. Chiunque usi ""CURRENT"" deve sottoscrivere questa lista. È una mailing list tecnica per la quale ci si attende materiale strettamente tecnico.

link:{freebsd-cvsweb-url}[freebsd-cvsweb]::
_Progetto CVSweb di FreeBSD_
+
Discussioni tecniche sull'uso, sviluppo e mantenimento di FreeBSD-CVSweb

link:{freebsd-doc-url}[freebsd-doc]::
_Progetto di documentazione_
+
Questa mailing list è per la discussione di argomenti e progetti riguardanti la creazione della documentazione FreeBSD. I membri di questa mailing list sono noti in genere come ""The FreeBSD Documentation Project"". È una lista aperta, sentitevi liberi di unirla e contribuirvi.

link:{freebsd-drivers-url}[freebsd-drivers]::
_Scrivere driver di dispositivi per FreeBSD_
+
Questo è un forum per discussioni tecniche relative ai driver di dispositivi su FreeBSD. È sostanzialmente un posto per gli sviluppatori di driver di dispositivi su questioni su come scrivere driver di dispositivi usando le API del kernel di FreeBSD.

link:{freebsd-eclipse-url}[freebsd-eclipse]::
_Utenti FreeBSD di Eclipse IDE, strumenti, applicazioni client e port._
+
L'intenzione di questa lista è di fornire un supporto reciproco per tutto ciò che concerne la scelta, l'installazione, l'uso, lo sviluppo e il mantenimento di Eclipse IDE, gli strumenti, le applicazioni client sulla piattaforma FreeBSD e l'assistenza al porting di Eclipse IDE nonchè i plugin per l'ambiente di FreeBSD.
+
L'intenzione è anche quella di facilitare lo scambio di informazioni tra la comunità di Eclipse e la comunità di FreeBSD per un reciproco beneficio.
+
Benchè questa lista si focalizzi principalmente sulle necessità degli utenti di Eclipse essa fornisce anche un forum per quelli ai quali piace sviluppare applicaizoni specifiche per FreeBSD usando il framework Eclipse.

link:{freebsd-embedded-url}[freebsd-embedded]::
_Come usare FreeBSD in applicazioni embedded._
+
In questa lista sono affrontati argomenti relativi all'uso di FreeBSD in sistemi embedded. Essendo questa una mailing list tecnica ci si aspetta contenuti tecnici. Per l'intento di questa lista definiamo i sistemi embedded come quei calcolatori che non sono desktop e che in genere sono utilizzati per un singolo fine al contrario dell'usuale concezione dei sistemi calcolatori. Esempi includono, senza limitazione alcuna, tutti i tipi di telefonini, strumenti di networking come i router, gli switch, i PBX, strumenti di misurazione remota, PDA, sistemi di punti vendita, e altri ancora.

link:{freebsd-emulation-url}[freebsd-emulation]::
_Emulazione di altri sistemi come Linux/MS-DOS(R)/Windows(R)_
+
Questo è un forum per discussioni tecniche relative all'esecuzione su FreeBSD di programmi scritti per altri sistemi operativi.

link:{freebsd-eol-url}[freebsd-eol]::
_Supporto per il software relativo a FreeBSD che non è più supportato dal progetto FreeBSD._
+
Questa lista è rivolta a coloro che sono interessati a fornire o usufruire del supporto per software relativo a FreeBSD per il quale il progetto FreeBSD non fornisce più un supporto ufficiale (es. avvisi di sicurezza e patch).

link:{freebsd-firewire-url}[freebsd-firewire]::
_FireWire(R) (iLink, IEEE 1394)_
+
Questa è la mailing list per la discussione del design e l'implementazione di un sottosistema FireWire(R) (anche noto come IEEE 1394 o iLink) per FreeBSD. Argomenti rilevanti includono nello specifico gli standards, i bus devices, i loro protocolli, insiemi di adapter boards/cards/chips, e l'architettura e implementazione del codice per il loro pieno supporto.

link:{freebsd-fs-url}[freebsd-fs]::
_File system_
+
Discussioni riguardanti i file system FreeBSD. Questa è una lista dalle caratteristiche tecniche per la quale ci si attende contenuto strettamente tecnico.

link:{freebsd-geom-url}[freebsd-geom]::
_GEOM_
+
Discussioni riguardanti GEOM e relative implementazioni. Questa è una mailing list tecnica per la quale ci si attente contenuto strettamente tecnico.

link:{freebsd-gnome-url}[freebsd-gnome]::
_GNOME_
+
Discussioni riguardanti The Gnome Desktop Environment per sistemi FreeBSD. Questa è una mailing list tecnica per la quale ci si attende materiale strettamente tecnico.

link:{freebsd-ipfw-url}[freebsd-ipfw]::
_Firewall IP_
+
Questo è il forum di discussione riguardante il redesign del codice IP firewall di FreeBSD. Questa è una mailing list tecnica per la quale ci si attende materiale strettamente tecnico.

link:{freebsd-ia64-url}[freebsd-ia64]::
_Il porting di FreeBSD su IA64_
+
Questa è una mailing list tecnica per individui impegnati attivamente nel porting di FreeBSD alla piattaforma IA-64 dall'Intel(R), nel sollevare problemi e nel proporre soluzioni. Individui interessati nel seguire le discussioni tecniche sono comunque benvenuti.

link:{freebsd-isdn-url}[freebsd-isdn]::
_Sistema di comunicazione ISDN_
+
Questa è la mailing list per le persone che discutono lo sviluppo del supporto ISDN per FreeBSD.

link:{freebsd-java-url}[freebsd-java]::
_Sviluppo Java(TM)_
+
Questa è la mailing list per le persone impegnate nello sviluppo di applicazioni Java(TM) significative per FreeBSD ed il porting ed il mantenimento delle JDK(TM).

[[eresources-charters-jobs]]
link:{freebsd-jobs-url}[freebsd-jobs]::
_Cercasi e offresi opportunità di lavoro_
+
Questo è un forum dove inviare avvisi di impiego e curriculum vitae relativi specificatamente a FreeBSD, ad esempio se stai cercando un impiego relativo a FreeBSD o hai un posto di lavoro da pubblicizzare che coinvolge FreeBSD allora questo è il posto giusto. Questa _non_ è una mailing list sui problemi di occupazione in generale visto che forum appropriati esistono già da altre parti.
+
Nota che questa lista, come le altre mailing list di `FreeBSD.org`, è distribuita in tutto il mondo. Di conseguenza, devi essere chiaro sul luogo e sulle possibiltà di telelavoro o assistenza nel cambiare abitazione, se disponibili.
+
Le email dovrebbero usare solo formati aperti - preferibilmente testo semplice, ma molti lettori accettano anche Portable Document Format (PDF), HTML, e alcuni altri. Formati chiusi come Microsoft(R) Word ([.filename]#.doc#) saranno respinti dal server delle mailing list.

link:{freebsd-kde-url}[freebsd-kde]::
_KDE_
+
Discussioni concernenti KDE su sistemi FreeBSD. È una mailing list a carattere tecnico per la quale ci si attende materiale strettamente tecnico.

link:{freebsd-hackers-url}[freebsd-hackers]::
_Discussioni tecniche_
+
Questo è un forum per discussioni tecniche relative a FreeBSD. Questa è la mailing list tecnica principale. È per individui che lavorano attivamente a FreeBSD per sollevare problemi o discutere soluzioni alternative. Individui interessati nel seguire le discussioni tecniche sono comunque benvenuti. È una mailing list tecnica per la quale ci si attende contenuto strettamente tecnico.

link:{freebsd-hardware-url}[freebsd-hardware]::
_Discussione generale sull'hardware e FreeBSD_
+
Discussione generica sui vari tipi di hardware che FreeBSD supporta, vari problemi e suggerimenti riguardo a cosa convenga acquistare e cosa evitare.

link:{freebsd-hubs-url}[freebsd-hubs]::
_Siti mirror_
+
Annunci e discussioni per persone che mantengono siti mirror FreeBSD.

link:{freebsd-isp-url}[freebsd-isp]::
_Questioni riguardanti gli Internet Service Provider_
+
Questa mailing list è per la discussione di argomenti riguardanti gli Internet Service Provider (ISP) che usano FreeBSD. È una mailing list tecnica per a quale ci si attende materiale strettamente tecnico.

link:{freebsd-openoffice-url}[freebsd-openoffice]::
_OpenOffice.org_
+
Questione concernenti il porting ed il mantenimento di OpenOffice.org e StarOffice(TM).

link:{freebsd-performance-url}[freebsd-performance]::
_Discussioni riguardo la calibrazione o la velocizzazione di FreeBSD_
+
Questa mailing list esiste per procurare ad hackers, amministratori di sistema, e/o parti interessate un luogo dove discutere argomenti legati alla performance di FreeBSD. Argomenti accettabili includono installazioni di FreeBSD ad alto carico, con problemi di performance o che stanno spingendo ai limiti delle sue possibilità FreeBSD. Le parti interessate che sono disposte a lavorare per un miglioramento delle prestazioni di FreeBSD sono altamente incoraggiate a sottoscrivere questa lista. Questa è una lista estremamente tecnica, idealmente adatta per utenti FreeBSD esperti, hackers o amministratori intenzionati a mantenere FreeBSD veloce, robusto e scalabile. Questa lista non è una lista domanda-e-risposta che sostituisce l'uso della documentazione, quanto piuttosto un luogo dove apportare i propri contributi o porre domande che non hanno avuto risposta altrove riguardo a tematiche di prestazione.

link:{freebsd-pf-url}[freebsd-pf]::
_Discussioni sul sistema di firewall packet filter_
+
Discussioni concernenti il sistema di firewall packet filter (pf) su FreeBSD. Saranno ben accolte sia discussioni tecniche che questioni generiche. Inoltre su questa lista si discute anche del framework ALTQ Qos.

link:{freebsd-platforms-url}[freebsd-platforms]::
_Il porting sulle piattaforme non Intel(R)_
+
Questione concernenti FreeBSD fra le varie piattaforme, discussioni generiche e proposte per ports ad architetture non Intel(R). È una maliling list tecnica per la quale ci si attende materiale strettamente tecnico.

link:{freebsd-policy-url}[freebsd-policy]::
_Le decisioni della politica del Core Team_
+
Questa è una mailing list a scarso traffico, di sola lettura, per le decisioni politiche del Core Team.

link:{freebsd-ports-url}[freebsd-ports]::
_Discussioni sui ""port""_
+
Discussioni riguardanti la collezione dei ""port"" di FreeBSD ([.filename]#/usr/ports#), l'infrastruttura dei port, e sforzi generali per la coordinazione dei port. È una mailing list a carattere tecnico per la quale ci si attende materiale strettamente tecnico.

link:{freebsd-ports-bugs-url}[freebsd-ports-bugs]::
_Discussione dei bug dei ""port""_
+
Discussioni concernenti report di problemi sulla ""collezione dei port"" di FreeBSD ([.filename]#/usr/ports#), proposte di nuovi port, o modifiche ai port. È una mailing list a carattere tecnico per la quale ci si attende materiale strettamente tecnico.

link:{freebsd-proliant-url}[freebsd-proliant]::
_Discussioni tecniche di FreeBSD su piattaforme server HP ProLiant_
+
Questa mailing list è usata per discussioni tecniche sull'uso di FreeBSD su server HP ProLiant, includendo discussioni su driver ProLiant, software di gestione, strumenti di configurazione, ed aggiornamenti del BIOS. Come tale, questo è il posto adatto per discutere circa hpasmd, hpasmcli, e hpacucli.

link:{freebsd-python-url}[freebsd-python]::
_Python su FreeBSD_
+
Questa è una lista di discussioni relative al miglioramento del supporto di Python su FreeBSD. Questa è una mailing list tecnica. È per coloro che lavorano sul porting di Python, sui suoi moduli di terze parti e sul materiale di Zopein FreeBSD. Inoltre sono benvenute persone interessate alle discussioni tecniche.

link:{freebsd-questions-url}[freebsd-questions]::
_Domande degli utenti_
+
Questa è una mailing list per domande riguardanti FreeBSD. Non dovreste porre domande del tipo ""how to"" alle liste tecniche a meno che stiate considerando le questioni come molto tecniche.

link:{freebsd-scsi-url}[freebsd-scsi]::
_Sottosistema SCSI_
+
Questa è la mailing list per le persone impegnate nel sottosistema SCSI di FreeBSD. È una mailing list tecnica per la quale ci si attende materiale strettamente tecnico.

{freebsd-security}::
_Questioni di sicurezza_
+
Argomenti relativi alla sicurezza dei sistemi FreeBSD (DES, Kerberos, buchi di sicurezza noti e fixes, etc.). Questa è una mailing list tecnica per la quale ci si attende materiale strettamente tecnico. Notate che questa non è una lista domanda e risposta, ma che i contributi (SIA domande SIA risposte) alle FAQ sono benvenute.

{freebsd-security-notifications}::
_Notifiche riguardanti la sicurezza_
+
Notifiche riguardanti problemi di sicurezza di FreeBSD e fix. Non è una lista di discussione. La relativa lista di discussione è FreeBSD-security.

link:{freebsd-small-url}[freebsd-small]::
_Utilizzo di FreeBSD in applicazioni embedded_
+
Questa lista discute argomenti relativi ad installazioni di FreeBSD su macchine dalle risorse estremamente limitate e sistemi embedded.
+

[NOTE]
====
Questa lista è stata resa obsoleta da link:{freebsd-embedded-url}[freebsd-embedded].
====

{freebsd-stable}::
_Discussioni riguardo l'uso di FreeBSD.stable;_
+
Questa è la mailing list degli utenti di FreeBSD.stable;. Include avvertimenti su nuove caratteristiche in arrivo nella -STABLE che toccheranno gli utenti, e istruzioni sui passi da compiere per tenere aggiornata la -STABLE. Chiunque usi la ""STABLE"" dovrebbe sottoscrivere questa lista. È una lista di carattere tecnico per la quale ci si attende materiale strettamente tecnico.

link:{freebsd-standards-url}[freebsd-standards]::
_Rispetto degli standards C99 & POSIX_
+
Questo è un forum di discussioni tecniche relative al rispetto degli standards C99 e POSIX da parte di FreeBSD.

link:{freebsd-usb-url}[freebsd-usb]::
_Discussioni per il supporto USB in FreeBSD_
+
Questa è la mailing list per discussioni tecniche relative al supporto USB in FreeBSD.

link:{freebsd-user-groups-url}[freebsd-user-groups]::
_Lista di coordinamento dei gruppi utenti_
+
Questa è la mailing list per i coordinatori di ogni Gruppo Utenti locale, in cui discutere questioni fra di loro e un membro designato del Core Team. Questa mailing list dovrebbe essere limitata a discussioni su meeting e coordinamento di progetti che riguardano molti Gruppi Utenti.

link:{freebsd-vendors-url}[freebsd-vendors]::
_I venditori_
+
Discussioni di coordinamento fra il FreeBSD Project e venditori di software e hardware per FreeBSD.

[[eresources-mailfiltering]]
=== Filtraggio sulle Mailing List

Le mailing list di FreeBSD sono filtrate in molti modi per evitare la distribuzione di spam, virus, e altre email non volute. Le azioni di filtraggio descritte in questa sezione non includono tutte quelle usate per proteggere le mailing list.

Solo certi tipi di allegati sono ammessi sulle mailing list. Tutti gli allegati con un tipo di contenuto MIME non presente nella lista seguente saranno eliminati prima che l'email sia distribuita sulla mailing list.

* application/octet-stream
* application/pdf
* application/pgp-signature
* application/x-pkcs7-signature
* message/rfc822
* multipart/alternative
* multipart/related
* multipart/signed
* text/html
* text/plain
* text/x-diff
* text/x-patch

[NOTE]
====
Alcune mailing list potrebbero ammettere allegati di altri tipi di contenuto MIME, ma la lista qui sopra dovrebbe essere corretta per la maggior parte delle mailing list.
====

Se un'email contiene sia una versione HTML che una versione testo, quella HTML verrà rimossa. Se un'email contiene solo una versione HTML, sarà convertita in semplice testo.

[[eresources-news]]
== Newsgroup Usenet

Oltre ai due newsgroup specificamente designati per FreeBSD, ve ne sono molti altri in cui FreeBSD è discusso o che sono comunque rilevanti per gli utenti FreeBSD. Sono disponibili degli http://minnie.tuhs.org/BSD-info/bsdnews_search.html[archivi interrogabili attraverso parole chiave] su questi newsgroup per gentile concessione di Warren Toomey mailto:wkt@cs.adfa.edu.au[wkt@cs.adfa.edu.au].

=== Newsgroup specifici BSD

* link:news:comp.unix.bsd.freebsd.announce[comp.unix.bsd.freebsd.announce]
* link:news:comp.unix.bsd.freebsd.misc[comp.unix.bsd.freebsd.misc]
* link:news:de.comp.os.unix.bsd[de.comp.os.unix.bsd] (Tedesco)
* link:news:fr.comp.os.bsd[fr.comp.os.bsd] (Francese)
* link:news:it.comp.os.freebsd[it.comp.os.freebsd] (Italiano)
* link:news:tw.bbs.comp.386bsd[tw.bbs.comp.386bsd] (Cinese Tradizionale)

=== Altri newsgroup UNIX(R) di interesse

* link:news:comp.unix[comp.unix]
* link:news:comp.unix.questions[comp.unix.questions]
* link:news:comp.unix.admin[comp.unix.admin]
* link:news:comp.unix.programmer[comp.unix.programmer]
* link:news:comp.unix.shell[comp.unix.shell]
* link:news:comp.unix.user-friendly[comp.unix.user-friendly]
* link:news:comp.security.unix[comp.security.unix]
* link:news:comp.sources.unix[comp.sources.unix]
* link:news:comp.unix.advocacy[comp.unix.advocacy]
* link:news:comp.unix.misc[comp.unix.misc]
* link:news:comp.bugs.4bsd[comp.bugs.4bsd]
* link:news:comp.bugs.4bsd.ucb-fixes[comp.bugs.4bsd.ucb-fixes]
* link:news:comp.unix.bsd[comp.unix.bsd]

=== X Windows System

* link:news:comp.windows.x.i386unix[comp.windows.x.i386unix]
* link:news:comp.windows.x[comp.windows.x]
* link:news:comp.windows.x.apps[comp.windows.x.apps]
* link:news:comp.windows.x.announce[comp.windows.x.announce]
* link:news:comp.windows.x.intrinsics[comp.windows.x.intrinsics]
* link:news:comp.windows.x.motif[comp.windows.x.motif]
* link:news:comp.windows.x.pex[comp.windows.x.pex]
* link:news:comp.emulators.ms-windows.wine[comp.emulators.ms-windows.wine]

[[eresources-web]]
== Server World Wide Web

<<central-mirrors, {central}>>, <<armenia-mirrors, {mirrors-armenia}>>, <<australia-mirrors, {mirrors-australia}>>, <<austria-mirrors, {mirrors-austria}>>, <<czech-republic-mirrors, {mirrors-czech}>>, <<denmark-mirrors, {mirrors-denmark}>>, <<finland-mirrors, {mirrors-finland}>>, <<france-mirrors, {mirrors-france}>>, <<germany-mirrors, {mirrors-germany}>>, <<hong-kong-mirrors, {mirrors-hongkong}>>, <<ireland-mirrors, {mirrors-ireland}>>, <<japan-mirrors, {mirrors-japan}>>, <<latvia-mirrors, {mirrors-latvia}>>, <<lithuania-mirrors, {mirrors-lithuania}>>, <<netherlands-mirrors, {mirrors-netherlands}>>, <<norway-mirrors, {mirrors-norway}>>, <<russia-mirrors, {mirrors-russia}>>, <<slovenia-mirrors, {mirrors-slovenia}>>, <<south-africa-mirrors, {mirrors-south-africa}>>, <<spain-mirrors, {mirrors-spain}>>, <<sweden-mirrors, {mirrors-sweden}>>, <<switzerland-mirrors, {mirrors-switzerland}>>, <<taiwan-mirrors, {mirrors-taiwan}>>, <<uk-mirrors, {mirrors-uk}>>, <<usa-mirrors, {mirrors-us}>>.

(as of UTC)

[[central-mirrors]]
*{central}*

* {central-www}

[[armenia-mirrors]]
*{mirrors-armenia}*

* {mirrors-armenia-www-httpv6} (IPv6)

[[australia-mirrors]]
*{mirrors-australia}*

* {mirrors-australia-www-http}
* {mirrors-australia-www2-http}

[[austria-mirrors]]
*{mirrors-austria}*

* {mirrors-armenia-www-httpv6} (IPv6)

[[czech-republic-mirrors]]
*{mirrors-czech}*

* {mirrors-czech-www-httpv6} (IPv6)

[[denmark-mirrors]]
*{mirrors-denmark}*

* {mirrors-denmark-www-httpv6} (IPv6)

[[finland-mirrors]]
*{mirrors-finland}*

* {mirrors-finland-www-http}

[[france-mirrors]]
*{mirrors-france}*

* {mirrors-france-www-http}

[[germany-mirrors]]
*{mirrors-germany}*

* {mirrors-germany-www-http}

[[hong-kong-mirrors]]
*{mirrors-hongkong}*

* {mirrors-hongkong-www}

[[ireland-mirrors]]
*{mirrors-ireland}*

* {mirrors-ireland-www} 

[[japan-mirrors]]
*{mirrors-japan}*

* {mirrors-japan-www-httpv6} (IPv6)

[[latvia-mirrors]]
*{mirrors-latvia}*

* {mirrors-latvia-www} 

[[lithuania-mirrors]]
*{mirrors-lithuania}*

* {mirrors-lithuania-www} 

[[netherlands-mirrors]]
*{mirrors-netherlands}*

* {mirrors-netherlands-www} 

[[norway-mirrors]]
*{mirrors-norway}*

* {mirrors-norway-www} 

[[russia-mirrors]]
*{mirrors-russia}*

* {mirrors-russia-www-httpv6} (IPv6)

[[slovenia-mirrors]]
*{mirrors-slovenia}*

* {mirrors-slovenia-www} 

[[south-africa-mirrors]]
*{mirrors-south-africa}*

* {mirrors-south-africa-www}

[[spain-mirrors]]
*{mirrors-spain}*

* {mirrors-spain-www}
* {mirrors-spain-www2}

[[sweden-mirrors]]
*{mirrors-sweden}*

* {mirrors-sweden-www}

[[switzerland-mirrors]]
*{mirrors-switzerland}*

* {mirrors-switzerland-www-httpv6} (IPv6)
* {mirrors-switzerland-www2-httpv6} (IPv6)

[[taiwan-mirrors]]
*{mirrors-taiwan}*

* {mirrors-taiwan-www}
* {mirrors-taiwan-www2}
* {mirrors-taiwan-www4}
* {mirrors-taiwan-www5-httpv6} (IPv6)

[[uk-mirrors]]
*{mirrors-uk}*

* {mirrors-uk-www}
* {mirrors-uk-www3}

[[usa-mirrors]]
*{mirrors-us}*

* {mirrors-us-www5-httpv6} (IPv6)

[[eresources-email]]
== Indirizzi Email

I seguenti Gruppi Utenti forniscono indirizzi email per i propri membri. Gli amministratori di lista si riservano il diritto di revocare l'indirizzo assegnato se in alcun modo se ne fa cattivo uso.

[.informaltable]
[cols=""1,1,1,1"", frame=""none"", options=""header""]
|===
| Dominio
| Offerta
| Gruppo utente
| Amministratore

|ukug.uk.FreeBSD.org
|Solo forwarding
|mailto:freebsd-users@uk.FreeBSD.org[freebsd-users@uk.FreeBSD.org]
|Lee Johnston mailto:lee@uk.FreeBSD.org[lee@uk.FreeBSD.org]
|===

[[eresources-shell]]
== Shell Accounts

I seguenti Gruppi utenti forniscono account di shell a persone che supportano attivamente il progetto FreeBSD. Gli amministratori elencati si riservano il diritto di cancellare l'account se viene in alcun modo usato male.

[.informaltable]
[cols=""1,1,1,1"", frame=""none"", options=""header""]
|===
| Host
| Accesso
| Offerta
| Amministratore

|dogma.freebsd-uk.eu.org
|Telnet/FTP/SSH
|Email, spazio Web, FTP anonimo
|Lee Johnston mailto:lee@uk.FreeBSD.org[lee@uk.FreeBSD.org]
|===
",12231,False,2401.1934432988205,median
"#include ""AppHdr.h""

#ifdef USE_TILE_WEB

#include ""tileweb.h""

#include <cerrno>
#include <cstdarg>
#include <sys/socket.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/un.h>
#include <unistd.h>

#include ""artefact.h""
#include ""branch.h""
#include ""command.h""
#include ""coord.h""
#include ""directn.h""
#include ""english.h""
#include ""env.h""
#include ""files.h""
#include ""item-name.h""
#include ""json.h""
#include ""json-wrapper.h""
#include ""lang-fake.h""
#include ""libutil.h""
#include ""macro.h""
#include ""map-knowledge.h""
#include ""menu.h""
#include ""message.h""
#include ""mon-util.h""
#include ""notes.h""
#include ""options.h""
#include ""player.h""
#include ""player-equip.h""
#include ""religion.h""
#include ""scroller.h""
#include ""skills.h""
#include ""state.h""
#include ""stringutil.h""
#include ""throw.h""
#include ""tile-flags.h""
#include ""tile-player-flag-cut.h""
#include ""tiledef-dngn.h""
#include ""tiledef-gui.h""
#include ""tiledef-icons.h""
#include ""tiledef-main.h""
#include ""tiledef-player.h""
#include ""tilepick.h""
#include ""tilepick-p.h""
#include ""tileview.h""
#include ""transform.h""
#include ""travel.h""
#include ""unicode.h""
#include ""unwind.h""
#include ""version.h""
#include ""viewgeom.h""
#include ""view.h""

//#define DEBUG_WEBSOCKETS

static unsigned int get_milliseconds()
{
    // This is Unix-only, but so is Webtiles at the moment.
    timeval tv;
    gettimeofday(&tv, nullptr);

    return ((unsigned int) tv.tv_sec) * 1000 + tv.tv_usec / 1000;
}

TilesFramework tiles;

TilesFramework::TilesFramework() :
      m_controlled_from_web(false),
      _send_lock(false),
      m_last_ui_state(UI_INIT),
      m_view_loaded(false),
      m_current_view(coord_def(GXM, GYM)),
      m_next_view(coord_def(GXM, GYM)),
      m_next_view_tl(0, 0),
      m_next_view_br(-1, -1),
      m_current_flash_colour(BLACK),
      m_next_flash_colour(BLACK),
      m_need_full_map(true),
      m_text_menu(""menu_txt""),
      m_print_fg(15)
{
    screen_cell_t default_cell;
    default_cell.tile.bg = TILE_FLAG_UNSEEN;
    m_current_view.fill(default_cell);
    m_next_view.fill(default_cell);
}

TilesFramework::~TilesFramework()
{
}

void TilesFramework::shutdown()
{
    if (m_sock_name.empty())
        return;

    close(m_sock);
    remove(m_sock_name.c_str());
}

void TilesFramework::draw_doll_edit()
{
}

bool TilesFramework::initialise()
{
    m_cursor[CURSOR_MOUSE] = NO_CURSOR;
    m_cursor[CURSOR_TUTORIAL] = NO_CURSOR;
    m_cursor[CURSOR_MAP] = NO_CURSOR;

    // Initially, switch to CRT.
    cgotoxy(1, 1, GOTO_CRT);

    if (m_sock_name.empty())
        return true;

    // Init socket
    m_sock = socket(PF_UNIX, SOCK_DGRAM, 0);
    if (m_sock < 0)
        die(""Can't open the webtiles socket!"");
    sockaddr_un addr;
    addr.sun_family = AF_UNIX;
    strcpy(addr.sun_path, m_sock_name.c_str());
    if (::bind(m_sock, (sockaddr*) &addr, sizeof(sockaddr_un)))
        die(""Can't bind the webtiles socket!"");

    int bufsize = 64 * 1024;
    if (setsockopt(m_sock, SOL_SOCKET, SO_SNDBUF, &bufsize, sizeof(bufsize)))
        die(""Can't set buffer size!"");
    // Need small maximum message size to avoid crashes in OS X
    m_max_msg_size = 2048;

    struct timeval tv;
    tv.tv_sec = 1;
    tv.tv_usec = 0;
    if (setsockopt(m_sock, SOL_SOCKET, SO_SNDTIMEO, &tv, sizeof(tv)) < 0)
        die(""Can't set send timeout!"");

    if (m_await_connection)
        _await_connection();

    _send_version();
    send_exit_reason(""unknown"");
    _send_options();
    _send_layout();

    return true;
}

string TilesFramework::get_message()
{
    return m_msg_buf;
}

void TilesFramework::write_message(const char *format, ...)
{
    char buf[2048];
    int len;

    va_list argp;
    va_start(argp, format);
    if ((len = vsnprintf(buf, sizeof(buf), format, argp)) < 0)
        die(""Webtiles message format error! (%s)"", format);
    else if (len >= (int)sizeof(buf))
        die(""Webtiles message too long! (%d)"", len);
    va_end(argp);

    m_msg_buf.append(buf);
}

void TilesFramework::finish_message()
{
    if (m_msg_buf.size() == 0)
        return;
#ifdef DEBUG_WEBSOCKETS
    const int initial_buf_size = m_msg_buf.size();
    fprintf(stderr, ""websocket: About to send %d bytes.\\n"", initial_buf_size);
#endif

    if (m_sock_name.empty())
    {
        m_msg_buf.clear();
        return;
    }

    m_msg_buf.append(""\\n"");
    const char* fragment_start = m_msg_buf.data();
    const char* data_end = m_msg_buf.data() + m_msg_buf.size();
    int fragments = 0;
    while (fragment_start < data_end)
    {
        int fragment_size = data_end - fragment_start;
        if (fragment_size > m_max_msg_size)
            fragment_size = m_max_msg_size;
        fragments++;

        for (unsigned int i = 0; i < m_dest_addrs.size(); ++i)
        {
            int retries = 30;
            ssize_t sent = 0;
            while (sent < fragment_size)
            {
                ssize_t retval = sendto(m_sock, fragment_start + sent,
                    fragment_size - sent, 0, (sockaddr*) &m_dest_addrs[i],
                    sizeof(sockaddr_un));
#ifdef DEBUG_WEBSOCKETS
                fprintf(stderr,
                            ""    trying to send fragment to client %d..."", i);
#endif
                if (retval <= 0)
                {
                    const char *errmsg = retval == 0 ? ""No bytes sent""
                                                     : strerror(errno);
                    if (--retries <= 0)
                        die(""Socket write error: %s"", errmsg);

                    if (retval == 0 || errno == ENOBUFS || errno == EWOULDBLOCK
                        || errno == EINTR || errno == EAGAIN)
                    {
                        // Wait for half a second at first (up to five), then
                        // try again.
                        const int sleep_time = retries > 25 ? 2 * 1000
                                             : retries > 10 ? 500 * 1000
                                             : 5000 * 1000;
#ifdef DEBUG_WEBSOCKETS
                        fprintf(stderr, ""failed (%s), sleeping for %dms.\\n"",
                                                    errmsg, sleep_time / 1000);
#endif
                        usleep(sleep_time);
                    }
                    else if (errno == ECONNREFUSED || errno == ENOENT)
                    {
                        // the other side is dead
#ifdef DEBUG_WEBSOCKETS
                        fprintf(stderr,
                            ""failed (%s), breaking.\\n"", errmsg);
#endif
                        m_dest_addrs.erase(m_dest_addrs.begin() + i);
                        i--;
                        break;
                    }
                    else
                        die(""Socket write error: %s"", errmsg);
                }
                else
                {
#ifdef DEBUG_WEBSOCKETS
                    fprintf(stderr, ""fragment size %d sent.\\n"", fragment_size);
#endif
                    sent += retval;
                }
            }
        }

        fragment_start += fragment_size;
    }
    m_msg_buf.clear();
    m_need_flush = true;
#ifdef DEBUG_WEBSOCKETS
    fprintf(stderr, ""websocket: Sent %d bytes in %d fragments.\\n"",
                                                initial_buf_size, fragments);
#endif
}

void TilesFramework::send_message(const char *format, ...)
{
    char buf[2048];
    int len;

    va_list argp;
    va_start(argp, format);
    if ((len = vsnprintf(buf, sizeof(buf), format, argp)) >= (int)sizeof(buf)
        || len == -1)
    {
        if (len == -1)
            die(""Webtiles message format error! (%s)"", format);
        else
            die(""Webtiles message too long! (%d)"", len);
    }
    va_end(argp);

    m_msg_buf.append(buf);

    finish_message();
}

void TilesFramework::flush_messages()
{
    if (_send_lock)
        return;
    unwind_bool no_rentry(_send_lock, true);

    if (m_need_flush)
    {
        send_message(""*{\\""msg\\"":\\""flush_messages\\""}"");
        m_need_flush = false;
    }
}

void TilesFramework::_await_connection()
{
    if (m_sock_name.empty())
        return;

    while (m_dest_addrs.size() == 0)
        _receive_control_message();
}

wint_t TilesFramework::_receive_control_message()
{
    if (m_sock_name.empty())
        return 0;

    char buf[4096]; // Should be enough for client->server messages
    sockaddr_un srcaddr;
    socklen_t srcaddr_len;

    srcaddr_len = sizeof(srcaddr);

    int len = recvfrom(m_sock, buf, sizeof(buf),
                       0,
                       (sockaddr *) &srcaddr, &srcaddr_len);

    if (len == -1)
        die(""Socket read error: %s"", strerror(errno));

    string data(buf, len);
    try
    {
        return _handle_control_message(srcaddr, data);
    }
    catch (JsonWrapper::MalformedException&)
    {
        dprf(""Malformed control message!"");
        return 0;
    }
}

wint_t TilesFramework::_handle_control_message(sockaddr_un addr, string data)
{
    JsonWrapper obj = json_decode(data.c_str());
    obj.check(JSON_OBJECT);

    JsonWrapper msg = json_find_member(obj.node, ""msg"");
    msg.check(JSON_STRING);
    string msgtype(msg->string_);
#ifdef DEBUG_WEBSOCKETS
    fprintf(stderr, ""websocket: Received control message '%s' in %d byte.\\n"", msgtype.c_str(), (int) data.size());
#endif

    int c = 0;

    if (msgtype == ""attach"")
    {
        JsonWrapper primary = json_find_member(obj.node, ""primary"");
        primary.check(JSON_BOOL);

        m_dest_addrs.push_back(addr);
        m_controlled_from_web = primary->bool_;
    }
    else if (msgtype == ""key"")
    {
        JsonWrapper keycode = json_find_member(obj.node, ""keycode"");
        keycode.check(JSON_NUMBER);

        // TODO: remove this fixup call
        c = function_keycode_fixup((int) keycode->number_);
    }
    else if (msgtype == ""spectator_joined"")
    {
        flush_messages();
        _send_everything();
        flush_messages();
    }
    else if (msgtype == ""menu_scroll"")
    {
        JsonWrapper first = json_find_member(obj.node, ""first"");
        first.check(JSON_NUMBER);
        // last visible item is sent too, but currently unused

        if (!m_menu_stack.empty() && m_menu_stack.back().type == UIStackFrame::MENU)
            m_menu_stack.back().menu->webtiles_scroll((int) first->number_);
    }
    else if (msgtype == ""*request_menu_range"")
    {
        JsonWrapper start = json_find_member(obj.node, ""start"");
        start.check(JSON_NUMBER);
        JsonWrapper end = json_find_member(obj.node, ""end"");
        end.check(JSON_NUMBER);

        if (!m_menu_stack.empty() && m_menu_stack.back().type == UIStackFrame::MENU)
        {
            m_menu_stack.back().menu->webtiles_handle_item_request((int) start->number_,
                                                                   (int) end->number_);
        }
    }
    else if (msgtype == ""note"")
    {
        JsonWrapper content = json_find_member(obj.node, ""content"");
        content.check(JSON_STRING);

        if (Options.note_chat_messages)
            take_note(Note(NOTE_MESSAGE, MSGCH_PLAIN, 0, content->string_));
    }
    else if (msgtype == ""click_travel"" &&
             mouse_control::current_mode() == MOUSE_MODE_COMMAND)
    {
        JsonWrapper x = json_find_member(obj.node, ""x"");
        JsonWrapper y = json_find_member(obj.node, ""y"");
        x.check(JSON_NUMBER);
        y.check(JSON_NUMBER);
        JsonWrapper force = json_find_member(obj.node, ""force"");

        coord_def gc = coord_def((int) x->number_, (int) y->number_) + m_origin;
        c = click_travel(gc, force.node && force->tag == JSON_BOOL && force->bool_);
        if (c != CK_MOUSE_CMD)
        {
            clear_messages();
            process_command((command_type) c);
        }
        c = CK_MOUSE_CMD;
    }
    else if (msgtype == ""formatted_scroller_scroll"")
    {
        JsonWrapper scroll = json_find_member(obj.node, ""scroll"");
        scroll.check(JSON_NUMBER);
        recv_formatted_scroller_scroll((int)scroll->number_);
    }

    return c;
}

bool TilesFramework::await_input(wint_t& c, bool block)
{
    int result;
    fd_set fds;
    int maxfd = m_sock_name.empty() ? STDIN_FILENO : m_sock;

    while (true)
    {
        do
        {
            FD_ZERO(&fds);
            FD_SET(STDIN_FILENO, &fds);
            if (!m_sock_name.empty())
                FD_SET(m_sock, &fds);

            if (block)
            {
                tiles.flush_messages();
                result = select(maxfd + 1, &fds, nullptr, nullptr, nullptr);
            }
            else
            {
                timeval timeout;
                timeout.tv_sec = 0;
                timeout.tv_usec = 0;

                result = select(maxfd + 1, &fds, nullptr, nullptr, &timeout);
            }
        }
        while (result == -1 && errno == EINTR);

        if (result == 0)
            return false;
        else if (result > 0)
        {
            if (!m_sock_name.empty() && FD_ISSET(m_sock, &fds))
            {
                c = _receive_control_message();

                if (c != 0)
                    return true;
            }

            if (FD_ISSET(STDIN_FILENO, &fds))
            {
                c = 0;
                return true;
            }
        }
        else if (errno == EBADF)
        {
            // This probably means that stdin got closed because of a
            // SIGHUP. We'll just return.
            c = 0;
            return false;
        }
        else
            die(""select error: %s"", strerror(errno));
    }
}

void TilesFramework::dump()
{
    fprintf(stderr, ""Webtiles message buffer: %s\\n"", m_msg_buf.c_str());
    fprintf(stderr, ""Webtiles JSON stack:\\n"");
    for (const JsonFrame &frame : m_json_stack)
    {
        fprintf(stderr, ""start: %d end: %d type: %c\\n"",
                frame.start, frame.prefix_end, frame.type);
    }
}

void TilesFramework::send_exit_reason(const string& type, const string& message)
{
    write_message(""*"");
    write_message(""{\\""msg\\"":\\""exit_reason\\"",\\""type\\"":\\"""");
    write_message_escaped(type);
    if (!message.empty())
    {
        write_message(""\\"",\\""message\\"":\\"""");
        write_message_escaped(message);
    }
    write_message(""\\""}"");
    finish_message();
}

void TilesFramework::send_dump_info(const string& type, const string& filename)
{
    write_message(""*"");
    write_message(""{\\""msg\\"":\\""dump\\"",\\""type\\"":\\"""");
    write_message_escaped(type);
    write_message(""\\"",\\""filename\\"":\\"""");
    write_message_escaped(strip_filename_unsafe_chars(filename));
    write_message(""\\""}"");
    finish_message();
}

void TilesFramework::_send_version()
{
#ifdef WEB_DIR_PATH
    // The star signals a message to the server
    send_message(""*{\\""msg\\"":\\""client_path\\"",\\""path\\"":\\""%s\\"",\\""version\\"":\\""%s\\""}"", WEB_DIR_PATH, Version::Long);
#endif

    string title = CRAWL "" "" + string(Version::Long);
    send_message(""{\\""msg\\"":\\""version\\"",\\""text\\"":\\""%s\\""}"", title.c_str());
}

void TilesFramework::_send_options()
{
    json_open_object();
    json_write_string(""msg"", ""options"");
    Options.write_webtiles_options(""options"");
    json_close_object();
    finish_message();
}

#define ZOOM_INC 10

static void _set_option_int(string name, int value)
{
    tiles.json_open_object();
    tiles.json_write_string(""msg"", ""set_option"");
    tiles.json_write_string(""name"", name);
    tiles.json_write_int(""value"", value);
    tiles.json_close_object();
    tiles.finish_message();
}

void TilesFramework::zoom_dungeon(bool in)
{
    if (m_ui_state == UI_VIEW_MAP)
    {
        Options.tile_map_scale = min(300, max(20,
                    Options.tile_map_scale + (in ? ZOOM_INC : -ZOOM_INC)));
        _set_option_int(""tile_map_scale"", Options.tile_map_scale);
        dprf(""Zooming map to %d"", Options.tile_map_scale);
    }
    else
    {
        Options.tile_viewport_scale = min(300, max(20,
                    Options.tile_viewport_scale + (in ? ZOOM_INC : -ZOOM_INC)));
        _set_option_int(""tile_viewport_scale"", Options.tile_viewport_scale);
        dprf(""Zooming to %d"", Options.tile_viewport_scale);
    }
    // calling redraw explicitly is not needed here: it triggers from a
    // listener on the webtiles side.
    // TODO: how to implement dynamic max zoom that reacts to the webtiles side?
}

void TilesFramework::_send_layout()
{
    tiles.json_open_object();
    tiles.json_write_string(""msg"", ""layout"");
    tiles.json_open_object(""message_pane"");
    tiles.json_write_int(""height"",
                        max(Options.msg_webtiles_height, crawl_view.msgsz.y));
    tiles.json_write_bool(""small_more"", Options.small_more);
    tiles.json_close_object();
    tiles.json_close_object();
    tiles.finish_message();
}

void TilesFramework::push_menu(Menu* m)
{
    UIStackFrame frame;
    frame.type = UIStackFrame::MENU;
    frame.menu = m;
    frame.centred = !crawl_state.need_save;
    m_menu_stack.push_back(frame);
    m->webtiles_write_menu();
    tiles.finish_message();
}

void TilesFramework::push_crt_menu(string tag)
{
    UIStackFrame frame;
    frame.type = UIStackFrame::CRT;
    frame.crt_tag = tag;
    frame.centred = !crawl_state.need_save;
    m_menu_stack.push_back(frame);

    json_open_object();
    json_write_string(""msg"", ""menu"");
    json_write_string(""type"", ""crt"");
    json_write_string(""tag"", tag);
    json_write_bool(""ui-centred"", frame.centred);
    json_close_object();
    finish_message();
}

bool TilesFramework::is_in_crt_menu()
{
    return !m_menu_stack.empty() && m_menu_stack.back().type == UIStackFrame::CRT;
}

bool TilesFramework::is_in_menu(Menu* m)
{
    return !m_menu_stack.empty() && m_menu_stack.back().type == UIStackFrame::MENU
        && m_menu_stack.back().menu == m;
}

void TilesFramework::pop_menu()
{
    if (m_menu_stack.empty()) return;
    m_menu_stack.pop_back();
    send_message(""{\\""msg\\"":\\""close_menu\\""}"");
}

void TilesFramework::pop_all_ui_layouts()
{
    for (auto it = m_menu_stack.crbegin(); it != m_menu_stack.crend(); it++)
    {
        if (it->type == UIStackFrame::UI)
            send_message(""{\\""msg\\"":\\""ui-pop\\""}"");
        else
            send_message(""{\\""msg\\"":\\""close_menu\\""}"");
    }
    m_menu_stack.clear();

    // This is a bit of a hack, in case the client-side menu stack ever gets
    // out of sync with m_menu_stack. (This can maybe happen for reasons that I
    // don't fully understand, on spectator join.)
    send_message(""{\\""msg\\"":\\""close_all_menus\\""}"");
}

void TilesFramework::push_ui_layout(const string& type, unsigned num_state_slots)
{
    ASSERT(m_json_stack.size() == 1);
    ASSERT(m_json_stack.back().type == '}'); // enums, schmenums
    tiles.json_write_string(""msg"", ""ui-push"");
    tiles.json_write_string(""type"", type);
    tiles.json_write_bool(""ui-centred"", !crawl_state.need_save);
    tiles.json_close_object();
    UIStackFrame frame;
    frame.type = UIStackFrame::UI;
    frame.ui_json.resize(num_state_slots+1);
    frame.ui_json[0] = m_msg_buf;
    frame.centred = !crawl_state.need_save;
    m_menu_stack.push_back(frame);
    tiles.finish_message();
}

void TilesFramework::pop_ui_layout()
{
    if (m_menu_stack.empty()) return;
    m_menu_stack.pop_back();
    send_message(""{\\""msg\\"":\\""ui-pop\\""}"");
}

void TilesFramework::ui_state_change(const string& type, unsigned state_slot)
{
    ASSERT(!m_menu_stack.empty());
    UIStackFrame &top = m_menu_stack.back();
    ASSERT(top.type == UIStackFrame::UI);
    ASSERT(m_json_stack.size() == 1);
    ASSERT(m_json_stack.back().type == '}');
    tiles.json_write_string(""msg"", ""ui-state"");
    tiles.json_write_string(""type"", type);
    tiles.json_close_object();
    ASSERT(state_slot + 1 < top.ui_json.size());
    top.ui_json[state_slot+1] = m_msg_buf;
    tiles.finish_message();
}

void TilesFramework::push_ui_cutoff()
{
    int cutoff = static_cast<int>(m_menu_stack.size());
    m_ui_cutoff_stack.push_back(cutoff);
    send_message(""{\\""msg\\"":\\""ui_cutoff\\"",\\""cutoff\\"":%d}"", cutoff);
}

void TilesFramework::pop_ui_cutoff()
{
    m_ui_cutoff_stack.pop_back();
    int cutoff = m_ui_cutoff_stack.empty() ? -1 : m_ui_cutoff_stack.back();
    send_message(""{\\""msg\\"":\\""ui_cutoff\\"",\\""cutoff\\"":%d}"", cutoff);
}

static void _send_text_cursor(bool enabled)
{
    tiles.send_message(""{\\""msg\\"":\\""text_cursor\\"",\\""enabled\\"":%s}"",
                       enabled ? ""true"" : ""false"");
}

void TilesFramework::set_text_cursor(bool enabled)
{
    if (m_text_cursor == enabled) return;

    m_text_cursor = enabled;
}

static void _send_ui_state(WebtilesUIState state)
{
    tiles.json_open_object();
    tiles.json_write_string(""msg"", ""ui_state"");
    tiles.json_write_int(""state"", state);
    tiles.json_close_object();
    tiles.finish_message();
}

void TilesFramework::set_ui_state(WebtilesUIState state)
{
    if (m_ui_state == state) return;

    m_ui_state = state;
}

void TilesFramework::update_input_mode(mouse_mode mode, bool force)
{
    auto prev_mode = mouse_control::current_mode();
    if (prev_mode == mode && !force)
        return;

    // we skip redrawing in this case because it happens on every key input,
    // and is very heavy on held down keys
    if (force
        || !(prev_mode == MOUSE_MODE_COMMAND && mode == MOUSE_MODE_NORMAL
             || prev_mode == MOUSE_MODE_NORMAL && mode == MOUSE_MODE_COMMAND))
    {
        redraw();
    }

    json_open_object();
    json_write_string(""msg"", ""input_mode"");
    json_write_int(""mode"", mode);
    json_close_object();
    finish_message();
}

static bool _update_string(bool force, string& current,
                           const string& next,
                           const string& name,
                           bool update = true)
{
    if (force || current != next)
    {
        tiles.json_write_string(name, next);
        if (update)
            current = next;
        return true;
    }
    else
        return false;
}

template<class T> static bool _update_int(bool force, T& current, T next,
                                          const string& name,
                                          bool update = true)
{
    if (force || current != next)
    {
        tiles.json_write_int(name, next);
        if (update)
            current = next;
        return true;
    }
    else
        return false;
}

static bool _update_statuses(player_info& c)
{
    bool changed = false;
    unsigned int counter = 0;
    status_info inf;
    for (unsigned int status = 0; status <= STATUS_LAST_STATUS; ++status)
    {
        if (status == DUR_DIVINE_SHIELD)
        {
            inf = status_info();
            if (!you.duration[status])
                continue;
            inf.short_text = ""divine shield"";
        }
        else if (status == DUR_ICEMAIL_DEPLETED)
        {
            inf = status_info();
            if (you.duration[status] <= ICEMAIL_TIME / ICEMAIL_MAX)
                continue;
            inf.short_text = ""icemail depleted"";
        }
        else if (status == DUR_ACROBAT)
        {
            inf = status_info();
            if (!acrobat_boost_visible())
                continue;
            inf.short_text = ""acrobat"";
        }
        else if (!fill_status_info(status, inf)) // this will reset inf itself
            continue;

        if (!inf.light_text.empty() || !inf.short_text.empty())
        {
            if (!changed)
            {
                // up until now, c.status has not changed. Does this dur differ
                // from the counter-th element in c.status?
                if (counter >= c.status.size()
                    || inf.light_text != c.status[counter].light_text
                    || inf.light_colour != c.status[counter].light_colour
                    || inf.short_text != c.status[counter].short_text)
                {
                    changed = true;
                }
            }

            if (changed)
            {
                // c.status has changed at some point before counter, so all
                // bets are off for any future statuses.
                c.status.resize(counter + 1);
                c.status[counter] = inf;
            }

            counter++;
        }
    }
    if (c.status.size() != counter)
    {
        // the only thing that has happened is that some durations are removed
        ASSERT(!changed);
        changed = true;
        c.status.resize(counter);
    }

    return changed;
}

player_info::player_info()
{
    for (auto &eq : equip)
        eq = -1;
    position = coord_def(-1, -1);
}

/**
 * Send the player properties to the webserver. Any player properties that
 * must be available to the WebTiles client must be sent here through an
 * _update_* function call of the correct data type.
 * @param force_full  If true, all properties will be updated in the json
 *                    regardless whether their values are the same as the
 *                    current info in m_current_player_info.
 */
void TilesFramework::_send_player(bool force_full)
{
    player_info& c = m_current_player_info;

    json_open_object();
    json_write_string(""msg"", ""player"");
    json_treat_as_empty();

    _update_string(force_full, c.name, you.your_name, ""name"");
    _update_string(force_full, c.job_title, filtered_lang(player_title()),
                   ""title"");
    _update_int(force_full, c.wizard, you.wizard, ""wizard"");
    _update_string(force_full, c.species, species_name(you.species),
                   ""species"");
    string god = """";
    if (you_worship(GOD_JIYVA))
        god = god_name_jiyva(true);
    else if (!you_worship(GOD_NO_GOD))
        god = god_name(you.religion);
    _update_string(force_full, c.god, god, ""god"");
    _update_int(force_full, c.under_penance, (bool) player_under_penance(), ""penance"");
    uint8_t prank = 0;
    if (!you_worship(GOD_NO_GOD))
        prank = max(0, piety_rank());
    else if (you.char_class == JOB_MONK && you.species != SP_DEMIGOD
             && !had_gods())
    {
        prank = 2;
    }
    _update_int(force_full, c.piety_rank, prank, ""piety_rank"");

    _update_int(force_full, c.form, (uint8_t) you.form, ""form"");

    _update_int(force_full, c.hp, you.hp, ""hp"");
    _update_int(force_full, c.hp_max, you.hp_max, ""hp_max"");
    int max_max_hp = get_real_hp(true, false);

    _update_int(force_full, c.real_hp_max, max_max_hp, ""real_hp_max"");
    _update_int(force_full, c.mp, you.magic_points, ""mp"");
    _update_int(force_full, c.mp_max, you.max_magic_points, ""mp_max"");

    _update_int(force_full, c.poison_survival, max(0, poison_survival()),
                ""poison_survival"");

    _update_int(force_full, c.armour_class, you.armour_class(), ""ac"");
    _update_int(force_full, c.evasion, you.evasion(), ""ev"");
    _update_int(force_full, c.shield_class, player_displayed_shield_class(),
                ""sh"");

    _update_int(force_full, c.strength, (int8_t) you.strength(false), ""str"");
    _update_int(force_full, c.strength_max, (int8_t) you.max_strength(), ""str_max"");
    _update_int(force_full, c.intel, (int8_t) you.intel(false), ""int"");
    _update_int(force_full, c.intel_max, (int8_t) you.max_intel(), ""int_max"");
    _update_int(force_full, c.dex, (int8_t) you.dex(false), ""dex"");
    _update_int(force_full, c.dex_max, (int8_t) you.max_dex(), ""dex_max"");

    if (you.species == SP_FELID)
    {
        _update_int(force_full, c.lives, you.lives, ""lives"");
        _update_int(force_full, c.deaths, you.deaths, ""deaths"");
    }

    _update_int(force_full, c.experience_level, you.experience_level, ""xl"");
    _update_int(force_full, c.exp_progress, (int8_t) get_exp_progress(), ""progress"");
    _update_int(force_full, c.gold, you.gold, ""gold"");
    _update_int(force_full, c.noise,
                (you.wizard ? you.get_noise_perception(false) : -1), ""noise"");
    _update_int(force_full, c.adjusted_noise, you.get_noise_perception(true), ""adjusted_noise"");

    if (you.running == 0) // Don't update during running/resting
    {
        _update_int(force_full, c.elapsed_time, you.elapsed_time, ""time"");
        _update_int(force_full, c.num_turns, you.num_turns, ""turn"");
    }

    const PlaceInfo& place = you.get_place_info();
    string short_name = branches[place.branch].shortname;

    if (brdepth[place.branch] == 1)
    {
        // Definite articles
        if (place.branch == BRANCH_ABYSS)
            short_name.insert(0, ""The "");
        // Indefinite articles
        else if (place.branch != BRANCH_PANDEMONIUM &&
                 !is_connected_branch(place.branch))
        {
            short_name = article_a(short_name);
        }
    }
    _update_string(force_full, c.place, short_name, ""place"");
    _update_int(force_full, c.depth, brdepth[place.branch] > 1 ? you.depth : 0, ""depth"");

    if (m_origin.equals(-1, -1))
        m_origin = you.position;
    coord_def pos = you.position - m_origin;
    if (force_full || c.position != pos)
    {
        json_open_object(""pos"");
        json_write_int(""x"", pos.x);
        json_write_int(""y"", pos.y);
        json_close_object();
        c.position = pos;
    }

    if (force_full || _update_statuses(c))
    {
        json_open_array(""status"");
        for (const status_info &status : c.status)
        {
            json_open_object();
            if (!status.light_text.empty())
                json_write_string(""light"", status.light_text);
            if (!status.short_text.empty())
                json_write_string(""text"", status.short_text);
            if (status.light_colour)
                json_write_int(""col"", macro_colour(status.light_colour));
            json_close_object(true);
        }
        json_close_array();
    }

    json_open_object(""inv"");
    for (unsigned int i = 0; i < ENDOFPACK; ++i)
    {
        json_open_object(to_string(i));
        _send_item(c.inv[i], get_item_info(you.inv[i]), force_full);
        json_close_object(true);
    }
    json_close_object(true);

    json_open_object(""equip"");
    for (unsigned int i = EQ_FIRST_EQUIP; i < NUM_EQUIP; ++i)
    {
        const int8_t equip = !you.melded[i] ? you.equip[i] : -1;
        _update_int(force_full, c.equip[i], equip, to_string(i));
    }
    json_close_object(true);

    _update_int(force_full, c.quiver_item,
                (int8_t) you.m_quiver.get_fire_item(), ""quiver_item"");

    _update_string(force_full, c.unarmed_attack,
                   you.unarmed_attack_name(), ""unarmed_attack"");
    _update_int(force_full, c.unarmed_attack_colour,
                (uint8_t) get_form()->uc_colour, ""unarmed_attack_colour"");
    _update_int(force_full, c.quiver_available, !fire_warn_if_impossible(true),
                ""quiver_available"");

    json_close_object(true);

    finish_message();
}

void TilesFramework::_send_item(item_info& current, const item_info& next,
                                bool force_full)
{
    bool changed = false;
    bool defined = next.defined();

    if (force_full || current.base_type != next.base_type)
    {
        changed = true;
        json_write_int(""base_type"", next.base_type);
    }

    changed |= _update_int(force_full, current.quantity, next.quantity,
                           ""quantity"", false);

    if (!defined)
    {
        current = next;
        return; // For undefined items, only send base_type and quantity
    }
    else if (!current.defined())
        force_full = true; // if the item was undefined before, send everything

    changed |= _update_int(force_full, current.sub_type, next.sub_type,
                           ""sub_type"", false);
    changed |= _update_int(force_full, current.plus, next.plus,
                           ""plus"", false);
    changed |= _update_int(force_full, current.plus2, next.plus2,
                           ""plus2"", false);
    changed |= _update_int(force_full, current.flags, next.flags,
                           ""flags"", false);
    changed |= _update_string(force_full, current.inscription,
                              next.inscription, ""inscription"", false);

    // TODO: props?

    changed |= (current.special != next.special);

    // Derived stuff
    if (changed && defined)
    {
        string name = next.name(DESC_A, true, false, true);
        if (force_full || current.name(DESC_A, true, false, true) != name)
            json_write_string(""name"", name);

        const string prefix = item_prefix(next);
        const int prefcol = menu_colour(next.name(DESC_INVENTORY), prefix);
        if (force_full)
            json_write_int(""col"", macro_colour(prefcol));
        else
        {
            const string current_prefix = item_prefix(current);
            const int current_prefcol = menu_colour(current.name(DESC_INVENTORY), current_prefix);

            if (current_prefcol != prefcol)
                json_write_int(""col"", macro_colour(prefcol));
        }

        tileidx_t tile = tileidx_item(next);
        if (force_full || tileidx_item(current) != tile)
        {
            json_open_array(""tile"");
            tileidx_t base_tile = tileidx_known_base_item(tile);
            if (base_tile)
                json_write_int(base_tile);
            json_write_int(tile);
            json_close_array();
        }

        current = next;
    }
}

static void _send_doll(const dolls_data &doll, bool submerged, bool ghost)
{
    // Ordered from back to front.
    // FIXME: Implement this logic in one place in e.g. pack_doll_buf().
    int p_order[TILEP_PART_MAX] =
    {
        // background
        TILEP_PART_SHADOW,
        TILEP_PART_HALO,
        TILEP_PART_ENCH,
        TILEP_PART_DRCWING,
        TILEP_PART_CLOAK,
        // player
        TILEP_PART_BASE,
        TILEP_PART_BOOTS,
        TILEP_PART_LEG,
        TILEP_PART_BODY,
        TILEP_PART_ARM,
        TILEP_PART_HAIR,
        TILEP_PART_BEARD,
        TILEP_PART_DRCHEAD,
        TILEP_PART_HELM,
        TILEP_PART_HAND1,
        TILEP_PART_HAND2,
    };

    int flags[TILEP_PART_MAX];
    tilep_calc_flags(doll, flags);

    // For skirts, boots go under the leg armour. For pants, they go over.
    if (doll.parts[TILEP_PART_LEG] < TILEP_LEG_SKIRT_OFS)
    {
        p_order[7] = TILEP_PART_BOOTS;
        p_order[6] = TILEP_PART_LEG;
    }

    // Draw scarves above other clothing.
    if (doll.parts[TILEP_PART_CLOAK] >= TILEP_CLOAK_SCARF_FIRST_NORM)
    {
        p_order[4] = p_order[5];
        p_order[5] = p_order[6];
        p_order[6] = p_order[7];
        p_order[7] = p_order[8];
        p_order[8] = p_order[9];
        p_order[9] = TILEP_PART_CLOAK;
    }

    // Special case bardings from being cut off.
    const bool is_naga = is_player_tile(doll.parts[TILEP_PART_BASE],
                                        TILEP_BASE_NAGA);

    if (doll.parts[TILEP_PART_BOOTS] >= TILEP_BOOTS_NAGA_BARDING
        && doll.parts[TILEP_PART_BOOTS] <= TILEP_BOOTS_NAGA_BARDING_RED
        || doll.parts[TILEP_PART_BOOTS] == TILEP_BOOTS_LIGHTNING_SCALES)
    {
        flags[TILEP_PART_BOOTS] = is_naga ? TILEP_FLAG_NORMAL : TILEP_FLAG_HIDE;
    }

    const bool is_cent = is_player_tile(doll.parts[TILEP_PART_BASE],
                                        TILEP_BASE_CENTAUR);

    if (doll.parts[TILEP_PART_BOOTS] >= TILEP_BOOTS_CENTAUR_BARDING
        && doll.parts[TILEP_PART_BOOTS] <= TILEP_BOOTS_CENTAUR_BARDING_RED
        || doll.parts[TILEP_PART_BOOTS] == TILEP_BOOTS_BLACK_KNIGHT)
    {
        flags[TILEP_PART_BOOTS] = is_cent ? TILEP_FLAG_NORMAL : TILEP_FLAG_HIDE;
    }

    tiles.json_open_array(""doll"");

    for (int i = 0; i < TILEP_PART_MAX; ++i)
    {
        int p = p_order[i];

        if (!doll.parts[p] || flags[p] == TILEP_FLAG_HIDE)
            continue;

        if (p == TILEP_PART_SHADOW && (submerged || ghost))
            continue;

        int ymax = TILE_Y;

        if (flags[p] == TILEP_FLAG_CUT_CENTAUR
            || flags[p] == TILEP_FLAG_CUT_NAGA)
        {
            ymax = 18;
        }

        tiles.json_write_comma();
        tiles.write_message(""[%u,%d]"", (unsigned int) doll.parts[p], ymax);
    }
    tiles.json_close_array();
}

void TilesFramework::send_mcache(mcache_entry *entry, bool submerged, bool send_doll)
{
    bool trans = entry->transparent();
    if (trans && send_doll)
        tiles.json_write_int(""trans"", 1);

    const dolls_data *doll = entry->doll();
    if (send_doll)
    {
        if (doll)
            _send_doll(*doll, submerged, trans);
        else
        {
            tiles.json_write_comma();
            tiles.write_message(""\\""doll\\"":[]"");
        }
    }

    tiles.json_open_array(""mcache"");

    tile_draw_info dinfo[mcache_entry::MAX_INFO_COUNT];
    int draw_info_count = entry->info(&dinfo[0]);
    for (int i = 0; i < draw_info_count; i++)
    {
        tiles.json_write_comma();
        tiles.write_message(""[%u,%d,%d]"", (unsigned int) dinfo[i].idx,
                            dinfo[i].ofs_x, dinfo[i].ofs_y);
    }

    tiles.json_close_array();
}

static bool _in_water(const packed_cell &cell)
{
    return (cell.bg & TILE_FLAG_WATER) && !(cell.fg & TILE_FLAG_FLYING);
}

static bool _needs_flavour(const packed_cell &cell)
{
    tileidx_t bg_idx = cell.bg & TILE_FLAG_MASK;
    if (bg_idx >= TILE_DNGN_FIRST_TRANSPARENT)
        return true; // Needs flv.floor
    if (cell.is_liquefied || cell.is_bloody ||
        cell.is_moldy || cell.glowing_mold)
    {
        return true; // Needs flv.special
    }
    return false;
}

static inline unsigned _get_brand(int col)
{
    return (col & COLFLAG_FRIENDLY_MONSTER) ? Options.friend_brand :
           (col & COLFLAG_NEUTRAL_MONSTER)  ? Options.neutral_brand :
           (col & COLFLAG_ITEM_HEAP)        ? Options.heap_brand :
           (col & COLFLAG_WILLSTAB)         ? Options.stab_brand :
           (col & COLFLAG_MAYSTAB)          ? Options.may_stab_brand :
           (col & COLFLAG_FEATURE_ITEM)     ? Options.feature_item_brand :
           (col & COLFLAG_TRAP_ITEM)        ? Options.trap_item_brand :
           (col & COLFLAG_REVERSE)          ? CHATTR_REVERSE
                                            : CHATTR_NORMAL;
}

void TilesFramework::write_tileidx(tileidx_t t)
{
    // JS can only handle signed ints
    const int lo = t & 0xFFFFFFFF;
    const int hi = t >> 32;
    if (hi == 0)
        tiles.write_message(""%d"", lo);
    else
        tiles.write_message(""[%d,%d]"", lo, hi);
}

void TilesFramework::_send_cell(const coord_def &gc,
                                const screen_cell_t &current_sc, const screen_cell_t &next_sc,
                                const map_cell &current_mc, const map_cell &next_mc,
                                map<uint32_t, coord_def>& new_monster_locs,
                                bool force_full)
{
    if (current_mc.feat() != next_mc.feat())
        json_write_int(""f"", next_mc.feat());

    if (next_mc.monsterinfo())
        _send_monster(gc, next_mc.monsterinfo(), new_monster_locs, force_full);
    else if (current_mc.monsterinfo())
        json_write_null(""mon"");

    map_feature mf = get_cell_map_feature(gc);
    if (get_cell_map_feature(current_mc) != mf)
        json_write_int(""mf"", mf);

    // Glyph and colour
    char32_t glyph = next_sc.glyph;
    if (current_sc.glyph != glyph)
    {
        char buf[5];
        buf[wctoutf8(buf, glyph)] = 0;
        json_write_string(""g"", buf);
    }
    if ((current_sc.colour != next_sc.colour
         || current_sc.glyph == ' ') && glyph != ' ')
    {
        int col = next_sc.colour;
        col = (_get_brand(col) << 4) | macro_colour(col & 0xF);
        json_write_int(""col"", col);
    }

    json_open_object(""t"");
    {
        // Tile data
        const packed_cell &next_pc = next_sc.tile;
        const packed_cell &current_pc = current_sc.tile;

        const tileidx_t fg_idx = next_pc.fg & TILE_FLAG_MASK;

        const bool in_water = _in_water(next_pc);
        bool fg_changed = false;

        if (next_pc.fg != current_pc.fg)
        {
            fg_changed = true;

            json_write_name(""fg"");
            write_tileidx(next_pc.fg);
            if (fg_idx && fg_idx <= TILE_MAIN_MAX)
                json_write_int(""base"", (int) tileidx_known_base_item(fg_idx));
        }

        if (next_pc.bg != current_pc.bg)
        {
            json_write_name(""bg"");
            write_tileidx(next_pc.bg);
        }

        if (next_pc.cloud != current_pc.cloud)
        {
            json_write_name(""cloud"");
            write_tileidx(next_pc.cloud);
        }

        if (next_pc.is_bloody != current_pc.is_bloody)
            json_write_bool(""bloody"", next_pc.is_bloody);

        if (next_pc.old_blood != current_pc.old_blood)
            json_write_bool(""old_blood"", next_pc.old_blood);

        if (next_pc.is_silenced != current_pc.is_silenced)
            json_write_bool(""silenced"", next_pc.is_silenced);

        if (next_pc.halo != current_pc.halo)
            json_write_int(""halo"", next_pc.halo);

        if (next_pc.is_highlighted_summoner
            != current_pc.is_highlighted_summoner)
        {
            json_write_bool(""highlighted_summoner"",
                            next_pc.is_highlighted_summoner);
        }

        if (next_pc.is_moldy != current_pc.is_moldy)
            json_write_bool(""moldy"", next_pc.is_moldy);

        if (next_pc.glowing_mold != current_pc.glowing_mold)
            json_write_bool(""glowing_mold"", next_pc.glowing_mold);

        if (next_pc.is_sanctuary != current_pc.is_sanctuary)
            json_write_bool(""sanctuary"", next_pc.is_sanctuary);

        if (next_pc.is_liquefied != current_pc.is_liquefied)
            json_write_bool(""liquefied"", next_pc.is_liquefied);

        if (next_pc.orb_glow != current_pc.orb_glow)
            json_write_int(""orb_glow"", next_pc.orb_glow);

        if (next_pc.quad_glow != current_pc.quad_glow)
            json_write_bool(""quad_glow"", next_pc.quad_glow);

        if (next_pc.disjunct != current_pc.disjunct)
            json_write_bool(""disjunct"", next_pc.disjunct);

        if (next_pc.mangrove_water != current_pc.mangrove_water)
            json_write_bool(""mangrove_water"", next_pc.mangrove_water);

        if (next_pc.awakened_forest != current_pc.awakened_forest)
            json_write_bool(""awakened_forest"", next_pc.awakened_forest);

        if (next_pc.blood_rotation != current_pc.blood_rotation)
            json_write_int(""blood_rotation"", next_pc.blood_rotation);

        if (next_pc.travel_trail != current_pc.travel_trail)
            json_write_int(""travel_trail"", next_pc.travel_trail);

        if (_needs_flavour(next_pc) &&
            (next_pc.flv.floor != current_pc.flv.floor
             || next_pc.flv.special != current_pc.flv.special
             || !_needs_flavour(current_pc)
             || force_full))
        {
            json_open_object(""flv"");
            json_write_int(""f"", next_pc.flv.floor);
            if (next_pc.flv.special)
                json_write_int(""s"", next_pc.flv.special);
            json_close_object();
        }

        if (fg_idx >= TILEP_MCACHE_START)
        {
            if (fg_changed)
            {
                mcache_entry *entry = mcache.get(fg_idx);
                if (entry)
                    send_mcache(entry, in_water);
                else
                {
                    json_write_comma();
                    write_message(""\\""doll\\"":[[%d,%d]]"", TILEP_MONS_UNKNOWN, TILE_Y);
                    json_write_null(""mcache"");
                }
            }
        }
        else if (fg_idx == TILEP_PLAYER)
        {
            bool player_doll_changed = false;
            dolls_data result = player_doll;
            fill_doll_equipment(result);
            if (result != last_player_doll)
            {
                player_doll_changed = true;
                last_player_doll = result;
            }
            if (fg_changed || player_doll_changed)
            {
                _send_doll(last_player_doll, in_water, false);
                if (Options.tile_use_monster != MONS_0)
                {
                    monster_info minfo(MONS_PLAYER, MONS_PLAYER);
                    minfo.props[""monster_tile""] =
                        short(last_player_doll.parts[TILEP_PART_BASE]);
                    item_def *item;
                    if (you.slot_item(EQ_WEAPON))
                    {
                        item = new item_def(get_item_info(*you.slot_item(EQ_WEAPON)));
                        minfo.inv[MSLOT_WEAPON].reset(item);
                    }
                    if (you.slot_item(EQ_SHIELD))
                    {
                        item = new item_def(get_item_info(*you.slot_item(EQ_SHIELD)));
                        minfo.inv[MSLOT_SHIELD].reset(item);
                    }
                    tileidx_t mcache_idx = mcache.register_monster(minfo);
                    mcache_entry *entry = mcache.get(mcache_idx);
                    if (entry)
                        send_mcache(entry, in_water, false);
                    else
                        json_write_null(""mcache"");
                }
                else
                    json_write_null(""mcache"");
            }
        }
        else if (fg_idx >= TILE_MAIN_MAX)
        {
            if (fg_changed)
            {
                json_write_comma();
                write_message(""\\""doll\\"":[[%u,%d]]"", (unsigned int) fg_idx, TILE_Y);
                json_write_null(""mcache"");
            }
        }
        else
        {
            if (fg_changed)
            {
                json_write_comma();
                json_write_null(""doll"");
                json_write_null(""mcache"");
            }
        }

        bool overlays_changed = false;

        if (next_pc.num_dngn_overlay != current_pc.num_dngn_overlay)
            overlays_changed = true;
        else
        {
            for (int i = 0; i < next_pc.num_dngn_overlay; i++)
            {
                if (next_pc.dngn_overlay[i] != current_pc.dngn_overlay[i])
                {
                    overlays_changed = true;
                    break;
                }
            }
        }

        if (overlays_changed)
        {
            json_open_array(""ov"");
            for (int i = 0; i < next_pc.num_dngn_overlay; ++i)
                json_write_int(next_pc.dngn_overlay[i]);
            json_close_array();
        }
    }
    json_close_object(true);
}

void TilesFramework::_send_cursor(cursor_type type)
{
    if (m_cursor[type] == NO_CURSOR)
        send_message(""{\\""msg\\"":\\""cursor\\"",\\""id\\"":%d}"", type);
    else
    {
        if (m_origin.equals(-1, -1))
            m_origin = m_cursor[type];
        send_message(""{\\""msg\\"":\\""cursor\\"",\\""id\\"":%d,\\""loc\\"":{\\""x\\"":%d,\\""y\\"":%d}}"",
                     type, m_cursor[type].x - m_origin.x,
                     m_cursor[type].y - m_origin.y);
    }
}

void TilesFramework::_mcache_ref(bool inc)
{
    for (int y = 0; y < GYM; y++)
        for (int x = 0; x < GXM; x++)
        {
            coord_def gc(x, y);

            int fg_idx = m_current_view(gc).tile.fg & TILE_FLAG_MASK;
            if (fg_idx >= TILEP_MCACHE_START)
            {
                mcache_entry *entry = mcache.get(fg_idx);
                if (entry)
                {
                    if (inc)
                        entry->inc_ref();
                    else
                        entry->dec_ref();
                }
            }
        }
}

void TilesFramework::_send_map(bool force_full)
{
    // TODO: prevent in some other / better way?
    if (_send_lock)
        return;

    unwind_bool no_rentry(_send_lock, true);

    map<uint32_t, coord_def> new_monster_locs;

    force_full = force_full || m_need_full_map;
    m_need_full_map = false;

    json_open_object();
    json_write_string(""msg"", ""map"");
    json_treat_as_empty();

    if (force_full)
        json_write_bool(""clear"", true);

    if (force_full || you.on_current_level != m_player_on_level)
    {
        json_write_bool(""player_on_level"", you.on_current_level);
        m_player_on_level = you.on_current_level;
    }

    if (force_full || m_current_gc != m_next_gc)
    {
        if (m_origin.equals(-1, -1))
            m_origin = m_next_gc;
        json_open_object(""vgrdc"");
        json_write_int(""x"", m_next_gc.x - m_origin.x);
        json_write_int(""y"", m_next_gc.y - m_origin.y);
        json_close_object();
        m_current_gc = m_next_gc;
    }

    screen_cell_t default_cell;
    default_cell.tile.bg = TILE_FLAG_UNSEEN;
    default_cell.glyph = ' ';
    default_cell.colour = 7;
    map_cell default_map_cell;

    coord_def last_gc(0, 0);
    bool send_gc = true;

    json_open_array(""cells"");
    for (int y = 0; y < GYM; y++)
        for (int x = 0; x < GXM; x++)
        {
            coord_def gc(x, y);

            if (!is_dirty(gc) && !force_full)
                continue;

            if (cell_needs_redraw(gc))
            {
                screen_cell_t *cell = &m_next_view(gc);

                draw_cell(cell, gc, false, m_current_flash_colour);
                cell->tile.flv = env.tile_flv(gc);
                pack_cell_overlays(gc, m_next_view);
            }

            mark_clean(gc);

            if (m_origin.equals(-1, -1))
                m_origin = gc;

            json_open_object();
            if (send_gc
                || last_gc.x + 1 != gc.x
                || last_gc.y != gc.y)
            {
                json_write_int(""x"", x - m_origin.x);
                json_write_int(""y"", y - m_origin.y);
                json_treat_as_empty();
            }

            const screen_cell_t& sc = force_full ? default_cell
                : m_current_view(gc);
            const map_cell& mc = force_full ? default_map_cell
                : m_current_map_knowledge(gc);
            _send_cell(gc,
                       sc,
                       m_next_view(gc),
                       mc, env.map_knowledge(gc),
                       new_monster_locs, force_full);

            if (!json_is_empty())
            {
                send_gc = false;
                last_gc = gc;
            }
            json_close_object(true);
        }
    json_close_array(true);

    json_close_object(true);

    finish_message();

    if (force_full)
        _send_cursor(CURSOR_MAP);

    if (m_mcache_ref_done)
        _mcache_ref(false);

    m_current_map_knowledge = env.map_knowledge;
    m_current_view = m_next_view;

    _mcache_ref(true);
    m_mcache_ref_done = true;

    m_monster_locs = new_monster_locs;
}

void TilesFramework::_send_monster(const coord_def &gc, const monster_info* m,
                                   map<uint32_t, coord_def>& new_monster_locs,
                                   bool force_full)
{
    json_open_object(""mon"");
    if (m->client_id)
    {
        json_write_int(""id"", m->client_id);
        json_treat_as_empty();
        new_monster_locs[m->client_id] = gc;
    }

    const monster_info* last = nullptr;
    auto it = m_monster_locs.find(m->client_id);
    if (m->client_id == 0 || it == m_monster_locs.end())
    {
        last = m_current_map_knowledge(gc).monsterinfo();

        if (last && last->client_id != m->client_id)
            json_treat_as_nonempty(); // Force sending at least the id
    }
    else
    {
        last = m_current_map_knowledge(it->second).monsterinfo();

        if (it->second != gc)
            json_treat_as_nonempty(); // As above
    }

    if (last == nullptr)
        force_full = true;

    if (force_full || (last->full_name() != m->full_name()))
        json_write_string(""name"", m->full_name());

    if (force_full || (last->pluralised_name() != m->pluralised_name()))
        json_write_string(""plural"", m->pluralised_name());

    if (force_full || last->type != m->type)
    {
        json_write_int(""type"", m->type);

        // TODO: get this information to the client in another way
        json_open_object(""typedata"");
        json_write_int(""avghp"", mons_avg_hp(m->type));
        if (!mons_class_gives_xp(m->type))
            json_write_bool(""no_exp"", true);
        json_close_object();
    }

    if (force_full || last->attitude != m->attitude)
        json_write_int(""att"", m->attitude);

    if (force_full || last->base_type != m->base_type)
        json_write_int(""btype"", m->base_type);

    if (force_full || last->threat != m->threat)
        json_write_int(""threat"", m->threat);

    // tiebreakers for two monsters with the same custom name
    if (m->is_named())
        json_write_int(""clientid"", m->client_id);

    json_close_object(true);
}

void TilesFramework::load_dungeon(const crawl_view_buffer &vbuf,
                                  const coord_def &gc)
{
    if (vbuf.size().equals(0, 0))
        return;

    m_view_loaded = true;

    if (m_ui_state == UI_CRT)
        set_ui_state(UI_NORMAL);

    m_next_flash_colour = you.flash_colour;
    if (m_next_flash_colour == BLACK)
        m_next_flash_colour = viewmap_flash_colour();

    // First re-render the area that was covered by vbuf the last time
    for (int y = m_next_view_tl.y; y <= m_next_view_br.y; y++)
        for (int x = m_next_view_tl.x; x <= m_next_view_br.x; x++)
        {
            if (x < 0 || x >= GXM || y < 0 || y >= GYM)
                continue;

            if (!crawl_view.in_viewport_g(coord_def(x, y)))
                mark_for_redraw(coord_def(x, y));
        }

    // re-cache the map knowledge for the whole map, not just the updated portion
    // fixes render bugs for out-of-LOS when transitioning levels in shoals/slime
    for (int y = 0; y < GYM; y++)
        for (int x = 0; x < GXM; x++)
        {
            const coord_def gc(x, y);
            screen_cell_t *cell = &m_next_view(gc);
            cell->tile.map_knowledge = map_bounds(gc) ? env.map_knowledge(gc) : map_cell();
        }

    m_next_view_tl = view2grid(coord_def(1, 1));
    m_next_view_br = view2grid(crawl_view.viewsz);

    // Copy vbuf into m_next_view
    for (int y = 0; y < vbuf.size().y; y++)
        for (int x = 0; x < vbuf.size().x; x++)
        {
            coord_def pos(x+1, y+1);
            coord_def grid = view2grid(pos);

            if (grid.x < 0 || grid.x >= GXM || grid.y < 0 || grid.y >= GYM)
                continue;

            screen_cell_t *cell = &m_next_view(grid);

            *cell = ((const screen_cell_t *) vbuf)[x + vbuf.size().x * y];
            cell->tile.flv = env.tile_flv(grid);
            pack_cell_overlays(grid, m_next_view);

            mark_clean(grid); // Remove redraw flag
            mark_dirty(grid);
        }

    m_next_gc = gc;
}

void TilesFramework::load_dungeon(const coord_def &cen)
{
    unwind_var<coord_def> viewp(crawl_view.viewp, cen - crawl_view.viewhalfsz);
    unwind_var<coord_def> vgrdc(crawl_view.vgrdc, cen);
    unwind_var<coord_def> vlos1(crawl_view.vlos1);
    unwind_var<coord_def> vlos2(crawl_view.vlos2);

    m_next_gc = cen;

    crawl_view.calc_vlos();
    viewwindow(false, true);
    place_cursor(CURSOR_MAP, cen);
}

void TilesFramework::resize()
{
    m_text_menu.resize(crawl_view.termsz.x, crawl_view.termsz.y);
}

void TilesFramework::_send_messages()
{
    if (_send_lock)
        return;
    unwind_bool no_rentry(_send_lock, true);

    webtiles_send_messages();
}

/*
  Send everything a newly joined spectator needs
 */
void TilesFramework::_send_everything()
{
    _send_version();
    _send_options();
    _send_layout();

    _send_text_cursor(m_text_cursor);

    // UI State
    _send_ui_state(m_ui_state);
    m_last_ui_state = m_ui_state;

    send_message(""{\\""msg\\"":\\""flash\\"",\\""col\\"":%d}"", m_current_flash_colour);

    _send_cursor(CURSOR_MOUSE);
    _send_cursor(CURSOR_TUTORIAL);

     // Player
    _send_player(true);

    // Map is sent after player, otherwise HP/MP bar can be left behind in the
    // old location if the player has moved
    _send_map(true);

    // Menus
    json_open_object();
    json_write_string(""msg"", ""ui-stack"");
    json_open_array(""items"");
    for (UIStackFrame &frame : m_menu_stack)
    {
        json_write_comma(); // noop immediately following open
        if (frame.type == UIStackFrame::MENU)
            frame.menu->webtiles_write_menu();
        else if (frame.type == UIStackFrame::CRT)
        {
            json_open_object();
            json_write_string(""msg"", ""menu"");
            json_write_string(""type"", ""crt"");
            json_write_string(""tag"", frame.crt_tag);
            json_write_bool(""ui-centred"", frame.centred);
            json_close_object();
        }
        else
        {
            for (const auto& json : frame.ui_json)
                if (!json.empty())
                {
                    m_msg_buf.append(json);
                    json_write_comma();
                }
            continue;
        }
    }
    json_close_array();
    json_close_object();
    finish_message();

    _send_messages();

    update_input_mode(mouse_control::current_mode(), true);

    m_text_menu.send(true);
}

void TilesFramework::clrscr()
{
    m_text_menu.clear();

    cgotoxy(1, 1);

    set_need_redraw();
}

void TilesFramework::layout_reset()
{
    m_layout_reset = true;
}

void TilesFramework::cgotoxy(int x, int y, GotoRegion region)
{
    m_print_x = x - 1;
    m_print_y = y - 1;

    bool crt_popup = region == GOTO_CRT && !m_menu_stack.empty() &&
            m_menu_stack.back().type == UIStackFrame::CRT;
    m_print_area = crt_popup ? &m_text_menu : nullptr;
    m_cursor_region = region;
}

void TilesFramework::redraw()
{
    if (!has_receivers())
    {
        if (m_mcache_ref_done)
        {
            _mcache_ref(false);
            m_mcache_ref_done = false;
        }
        return;
    }

    if (m_layout_reset)
    {
        _send_layout();
        m_layout_reset = false;
    }

    if (m_last_text_cursor != m_text_cursor)
    {
        _send_text_cursor(m_text_cursor);
        m_last_text_cursor = m_text_cursor;
    }

    if (m_last_ui_state != m_ui_state)
    {
        _send_ui_state(m_ui_state);
        m_last_ui_state = m_ui_state;
    }

    m_text_menu.send();

    _send_player();
    _send_messages();

    if (m_need_redraw && m_view_loaded)
    {
        if (m_current_flash_colour != m_next_flash_colour)
        {
            send_message(""{\\""msg\\"":\\""flash\\"",\\""col\\"":%d}"",
                         m_next_flash_colour);
            m_current_flash_colour = m_next_flash_colour;
        }
        _send_map(false);
    }

    m_need_redraw = false;
    m_last_tick_redraw = get_milliseconds();
}

void TilesFramework::update_minimap(const coord_def& gc)
{
    if (gc.x < 0 || gc.x >= GXM || gc.y < 0 || gc.y >= GYM)
        return;

    mark_for_redraw(gc);
}

void TilesFramework::clear_minimap()
{
    m_origin = coord_def(-1, -1);
    // Changing the origin invalidates coordinates on the client side
    m_current_gc = coord_def(-1, -1);
    m_need_full_map = true;
}

void TilesFramework::update_minimap_bounds()
{
}

void TilesFramework::update_tabs()
{
}

void TilesFramework::place_cursor(cursor_type type, const coord_def &gc)
{
    // This is mainly copied from DungeonRegion::place_cursor.
    coord_def result = gc;

    // If we're only looking for a direction, put the mouse
    // cursor next to the player to let them know that their
    // spell/wand will only go one square.
    if (mouse_control::current_mode() == MOUSE_MODE_TARGET_DIR
        && type == CURSOR_MOUSE && gc != INVALID_COORD)
    {
        coord_def delta = gc - you.pos();

        int ax = abs(delta.x);
        int ay = abs(delta.y);

        result = you.pos();
        if (1000 * ay < 414 * ax)
            result += (delta.x > 0) ? coord_def(1, 0) : coord_def(-1, 0);
        else if (1000 * ax < 414 * ay)
            result += (delta.y > 0) ? coord_def(0, 1) : coord_def(0, -1);
        else if (delta.x > 0)
            result += (delta.y > 0) ? coord_def(1, 1) : coord_def(1, -1);
        else if (delta.x < 0)
            result += (delta.y > 0) ? coord_def(-1, 1) : coord_def(-1, -1);
    }

    if (m_cursor[type] != result)
    {
        m_cursor[type] = result;
        if (type == CURSOR_MOUSE)
            m_last_clicked_grid = coord_def();

        // if map is going to be updated, send the cursor after that
        if (type == CURSOR_MAP && m_need_full_map)
            return;

        _send_cursor(type);
    }
}

void TilesFramework::clear_text_tags(text_tag_type type)
{
}

void TilesFramework::add_text_tag(text_tag_type type, const string &tag,
                                  const coord_def &gc)
{
}

void TilesFramework::add_text_tag(text_tag_type type, const monster_info& mon)
{
}

const coord_def &TilesFramework::get_cursor() const
{
    return m_cursor[CURSOR_MOUSE];
}

void TilesFramework::add_overlay(const coord_def &gc, tileidx_t idx)
{
    if (idx >= TILE_MAIN_MAX)
        return;

    m_has_overlays = true;

    send_message(""{\\""msg\\"":\\""overlay\\"",\\""idx\\"":%u,\\""x\\"":%d,\\""y\\"":%d}"",
                 (unsigned int) idx, gc.x - m_origin.x, gc.y - m_origin.y);
}

void TilesFramework::clear_overlays()
{
    if (m_has_overlays)
        send_message(""{\\""msg\\"":\\""clear_overlays\\""}"");

    m_has_overlays = false;
}

void TilesFramework::set_need_redraw(unsigned int min_tick_delay)
{
    unsigned int ticks = (get_milliseconds() - m_last_tick_redraw);
    if (min_tick_delay && ticks <= min_tick_delay)
        return;

    m_need_redraw = true;
}

bool TilesFramework::need_redraw() const
{
    return m_need_redraw;
}

void TilesFramework::textcolour(int col)
{
    m_print_fg = col & 0xF;
    m_print_bg = (col >> 4) & 0xF;
}

void TilesFramework::textbackground(int col)
{
    m_print_bg = col;
}

void TilesFramework::put_ucs_string(char32_t *str)
{
    if (m_print_area == nullptr)
        return;

    while (*str)
    {
        if (*str == '\\r')
            continue;

        if (*str == '\\n')
        {
            m_print_x = 0;
            m_print_y++;
            // TODO: Clear end of line?
        }
        else
        {
            if (m_print_x >= m_print_area->mx)
            {
                m_print_x = 0;
                m_print_y++;
            }

            if (m_print_y < m_print_area->my)
            {
                m_print_area->put_character(*str, m_print_fg, m_print_bg,
                                            m_print_x, m_print_y);
            }

            m_print_x++;
        }

        str++;
    }
}

void TilesFramework::clear_to_end_of_line()
{
    if (m_print_area == nullptr || m_print_y >= m_print_area->my)
        return;

    for (int x = m_print_x; x < m_print_area->mx; ++x)
        m_print_area->put_character(' ', m_print_fg, m_print_bg, x, m_print_y);
}

void TilesFramework::mark_for_redraw(const coord_def& gc)
{
    mark_dirty(gc);
    m_cells_needing_redraw[gc.y * GXM + gc.x] = true;
}

void TilesFramework::mark_dirty(const coord_def& gc)
{
    m_dirty_cells[gc.y * GXM + gc.x] = true;
}

void TilesFramework::mark_clean(const coord_def& gc)
{
    m_cells_needing_redraw[gc.y * GXM + gc.x] = false;
    m_dirty_cells[gc.y * GXM + gc.x] = false;
}

bool TilesFramework::is_dirty(const coord_def& gc)
{
    return m_dirty_cells[gc.y * GXM + gc.x];
}

bool TilesFramework::cell_needs_redraw(const coord_def& gc)
{
    return m_cells_needing_redraw[gc.y * GXM + gc.x];
}

void TilesFramework::write_message_escaped(const string& s)
{
    for (unsigned char c : s)
    {
        if (c == '""')
            m_msg_buf.append(""\\\\\\"""");
        else if (c == '\\\\')
            m_msg_buf.append(""\\\\\\\\"");
        else if (c < 0x20)
        {
            char buf[7];
            snprintf(buf, sizeof(buf), ""\\\\u%04x"", c);
            m_msg_buf.append(buf);
        }
        else
            m_msg_buf.push_back(c);
    }
}

void TilesFramework::json_open(const string& name, char opener, char type)
{
    m_json_stack.resize(m_json_stack.size() + 1);
    JsonFrame& fr = m_json_stack.back();
    fr.start = m_msg_buf.size();

    json_write_comma();
    if (!name.empty())
        json_write_name(name);

    m_msg_buf.append(1, opener);

    fr.prefix_end = m_msg_buf.size();
    fr.type = type;
}

void TilesFramework::json_treat_as_empty()
{
    if (m_json_stack.empty())
        die(""json error: empty stack"");
    m_json_stack.back().prefix_end = m_msg_buf.size();
}

void TilesFramework::json_treat_as_nonempty()
{
    if (m_json_stack.empty())
        die(""json error: empty stack"");
    m_json_stack.back().prefix_end = -1;
}

bool TilesFramework::json_is_empty()
{
    if (m_json_stack.empty())
        die(""json error: empty stack"");
    return m_json_stack.back().prefix_end == (int) m_msg_buf.size();
}

void TilesFramework::json_close(bool erase_if_empty, char type)
{
    if (m_json_stack.empty())
        die(""json error: attempting to close object/array on empty stack"");
    if (m_json_stack.back().type != type)
        die(""json error: attempting to close wrong type"");

    if (erase_if_empty && json_is_empty())
        m_msg_buf.resize(m_json_stack.back().start);
    else
        m_msg_buf.append(1, type);

    m_json_stack.pop_back();
}

void TilesFramework::json_open_object(const string& name)
{
    json_open(name, '{', '}');
}

void TilesFramework::json_close_object(bool erase_if_empty)
{
    json_close(erase_if_empty, '}');
}

void TilesFramework::json_open_array(const string& name)
{
    json_open(name, '[', ']');
}

void TilesFramework::json_close_array(bool erase_if_empty)
{
    json_close(erase_if_empty, ']');
}

void TilesFramework::json_write_comma()
{
    if (m_msg_buf.empty()) return;
    char last = m_msg_buf[m_msg_buf.size() - 1];
    if (last == '{' || last == '[' || last == ',' || last == ':') return;
    write_message("","");
}

void TilesFramework::json_write_name(const string& name)
{
    json_write_comma();

    write_message(""\\"""");
    write_message_escaped(name);
    write_message(""\\"":"");
}

void TilesFramework::json_write_int(int value)
{
    json_write_comma();

    write_message(""%d"", value);
}

void TilesFramework::json_write_int(const string& name, int value)
{
    if (!name.empty())
        json_write_name(name);

    json_write_int(value);
}

void TilesFramework::json_write_bool(bool value)
{
    json_write_comma();

    if (value)
        write_message(""true"");
    else
        write_message(""false"");
}

void TilesFramework::json_write_bool(const string& name, bool value)
{
    if (!name.empty())
        json_write_name(name);

    json_write_bool(value);
}

void TilesFramework::json_write_null()
{
    json_write_comma();

    write_message(""null"");
}

void TilesFramework::json_write_null(const string& name)
{
    if (!name.empty())
        json_write_name(name);

    json_write_null();
}

void TilesFramework::json_write_string(const string& value)
{
    json_write_comma();

    write_message(""\\"""");
    write_message_escaped(value);
    write_message(""\\"""");
}

void TilesFramework::json_write_string(const string& name, const string& value)
{
    if (!name.empty())
        json_write_name(name);

    json_write_string(value);
}

bool is_tiles()
{
    return tiles.is_controlled_from_web();
}
#endif
",16347,True,2659.6737065754237,median
"//  Copyright (c) 2007-2016 Hartmut Kaiser
//  Copyright (c)      2011 Bryce Lelbach
//
//  Distributed under the Boost Software License, Version 1.0. (See accompanying
//  file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

#include <hpx/config.hpp>
#include <hpx/config/defaults.hpp>
#include <hpx/compat/mutex.hpp>
#include <hpx/runtime.hpp>
#include <hpx/exception.hpp>
#include <hpx/apply.hpp>
#include <hpx/util/ini.hpp>
#include <hpx/util/logging.hpp>
#include <hpx/util/filesystem_compatibility.hpp>
#include <hpx/util/runtime_configuration.hpp>
#include <hpx/util/unlock_guard.hpp>

#include <hpx/lcos/wait_all.hpp>
#include <hpx/performance_counters/counters.hpp>
#include <hpx/runtime/actions/continuation.hpp>
#include <hpx/runtime/actions/plain_action.hpp>
#include <hpx/runtime/agas/interface.hpp>
#include <hpx/runtime/components/component_commandline_base.hpp>
#include <hpx/runtime/components/component_startup_shutdown_base.hpp>
#include <hpx/runtime/components/server/component_database.hpp>
#include <hpx/runtime/components/server/create_component.hpp>
#include <hpx/runtime/components/server/memory.hpp>
#include <hpx/runtime/components/server/memory_block.hpp>
#include <hpx/runtime/components/server/runtime_support.hpp>
#include <hpx/runtime/components/static_factory_data.hpp>
#include <hpx/runtime/components/stubs/runtime_support.hpp>
#include <hpx/runtime/find_localities.hpp>
#include <hpx/runtime/naming/resolver_client.hpp>
#include <hpx/runtime/naming/unmanaged.hpp>
#include <hpx/runtime/serialization/serialize.hpp>
#include <hpx/runtime/serialization/vector.hpp>
#include <hpx/runtime/shutdown_function.hpp>
#include <hpx/runtime/startup_function.hpp>
#include <hpx/runtime/threads/coroutines/coroutine.hpp>
#include <hpx/runtime/threads/threadmanager.hpp>

#include <hpx/lcos/barrier.hpp>
#include <hpx/lcos/broadcast.hpp>
#include <hpx/lcos/detail/barrier_node.hpp>
#if defined(HPX_USE_FAST_DIJKSTRA_TERMINATION_DETECTION)
#include <hpx/lcos/reduce.hpp>
#endif
#include <hpx/lcos/local/packaged_task.hpp>

#include <hpx/util/assert.hpp>
#include <hpx/util/parse_command_line.hpp>
#include <hpx/util/command_line_handling.hpp>
#include <hpx/util/yield_while.hpp>

#include <hpx/plugins/message_handler_factory_base.hpp>
#include <hpx/plugins/binary_filter_factory_base.hpp>

#include <hpx/plugins/parcelport/mpi/mpi_environment.hpp>

#include <boost/filesystem/path.hpp>
#include <boost/filesystem/convenience.hpp>
#include <boost/algorithm/string/case_conv.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/tokenizer.hpp>

#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <exception>
#include <iostream>
#include <map>
#include <memory>
#include <mutex>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>

///////////////////////////////////////////////////////////////////////////////
// Serialization support for the runtime_support actions
HPX_REGISTER_ACTION_ID(
    hpx::components::server::runtime_support::create_memory_block_action,
    create_memory_block_action,
    hpx::actions::create_memory_block_action_id)
HPX_REGISTER_ACTION_ID(
    hpx::components::server::runtime_support::load_components_action,
    load_components_action,
    hpx::actions::load_components_action_id)
HPX_REGISTER_ACTION_ID(
    hpx::components::server::runtime_support::call_startup_functions_action,
    call_startup_functions_action,
    hpx::actions::call_startup_functions_action_id)
HPX_REGISTER_ACTION_ID(
    hpx::components::server::runtime_support::call_shutdown_functions_action,
    call_shutdown_functions_action,
    hpx::actions::call_shutdown_functions_action_id)
HPX_REGISTER_ACTION_ID(
    hpx::components::server::runtime_support::shutdown_action,
    shutdown_action,
    hpx::actions::shutdown_action_id)
HPX_REGISTER_ACTION_ID(
    hpx::components::server::runtime_support::shutdown_all_action,
    shutdown_all_action,
    hpx::actions::shutdown_all_action_id)
HPX_REGISTER_ACTION_ID(
    hpx::components::server::runtime_support::terminate_action,
    terminate_action,
    hpx::actions::terminate_action_id)
HPX_REGISTER_ACTION_ID(
    hpx::components::server::runtime_support::terminate_all_action,
    terminate_all_action,
    hpx::actions::terminate_all_action_id)
HPX_REGISTER_ACTION_ID(
    hpx::components::server::runtime_support::get_config_action,
    get_config_action,
    hpx::actions::get_config_action_id)
HPX_REGISTER_ACTION_ID(
    hpx::components::server::runtime_support::garbage_collect_action,
    garbage_collect_action,
    hpx::actions::garbage_collect_action_id)
HPX_REGISTER_ACTION_ID(
    hpx::components::server::runtime_support::create_performance_counter_action,
    create_performance_counter_action,
    hpx::actions::create_performance_counter_action_id)
HPX_REGISTER_ACTION_ID(
    hpx::components::server::runtime_support::remove_from_connection_cache_action,
    remove_from_connection_cache_action,
    hpx::actions::remove_from_connection_cache_action_id)
HPX_REGISTER_ACTION_ID(
    hpx::components::server::runtime_support::dijkstra_termination_action,
    dijkstra_termination_action,
    hpx::actions::dijkstra_termination_action_id)

///////////////////////////////////////////////////////////////////////////////
HPX_DEFINE_COMPONENT_NAME(hpx::components::server::runtime_support,
    hpx_runtime_support);
HPX_DEFINE_GET_COMPONENT_TYPE_STATIC(
    hpx::components::server::runtime_support,
    hpx::components::component_runtime_support)

namespace hpx
{
    // helper function to stop evaluating counters during shutdown
    void stop_evaluating_counters();

    namespace parcelset
    {
        // default parcel-sent handler function
        void default_write_handler(boost::system::error_code const& ec,
            parcelset::parcel const& p);
    }
}

namespace hpx { namespace components
{
    bool initial_static_loading = true;

    ///////////////////////////////////////////////////////////////////////////
    // There is no need to protect these global from thread concurrent access
    // as they are access during early startup only.
    std::vector<static_factory_load_data_type>&
    get_static_module_data()
    {
        static std::vector<static_factory_load_data_type> global_module_init_data;
        return global_module_init_data;
    }

    void init_registry_module(static_factory_load_data_type const& data)
    {
        if (initial_static_loading)
            get_static_module_data().push_back(data);
    }

    ///////////////////////////////////////////////////////////////////////////
    std::map<std::string, util::plugin::get_plugins_list_type>&
    get_static_factory_data()
    {
        static std::map<std::string, util::plugin::get_plugins_list_type>
            global_factory_init_data;
        return global_factory_init_data;
    }

    void init_registry_factory(static_factory_load_data_type const& data)
    {
        if (initial_static_loading)
            get_static_factory_data().insert(
                std::make_pair(data.name, data.get_factory));
    }

    bool get_static_factory(std::string const& instance,
        util::plugin::get_plugins_list_type& f)
    {
        typedef std::map<std::string, util::plugin::get_plugins_list_type>
            map_type;

        map_type const& m = get_static_factory_data();
        map_type::const_iterator it = m.find(instance);
        if (it == m.end())
            return false;

        f = it->second;
        return true;
    }

    ///////////////////////////////////////////////////////////////////////////
    std::map<std::string, util::plugin::get_plugins_list_type>&
    get_static_commandline_data()
    {
        static std::map<std::string, util::plugin::get_plugins_list_type>
            global_commandline_init_data;
        return global_commandline_init_data;
    }

    void init_registry_commandline(static_factory_load_data_type const& data)
    {
        if (initial_static_loading)
            get_static_commandline_data().insert(
                std::make_pair(data.name, data.get_factory));
    }

    bool get_static_commandline(std::string const& instance,
        util::plugin::get_plugins_list_type& f)
    {
        typedef std::map<std::string, util::plugin::get_plugins_list_type>
            map_type;

        map_type const& m = get_static_commandline_data();
        map_type::const_iterator it = m.find(instance);
        if (it == m.end())
            return false;

        f = it->second;
        return true;
    }

    ///////////////////////////////////////////////////////////////////////////
    std::map<std::string, util::plugin::get_plugins_list_type>&
    get_static_startup_shutdown_data()
    {
        static std::map<std::string, util::plugin::get_plugins_list_type>
            global_startup_shutdown_init_data;
        return global_startup_shutdown_init_data;
    }

    void init_registry_startup_shutdown(static_factory_load_data_type const& data)
    {
        if (initial_static_loading)
            get_static_startup_shutdown_data().insert(
                std::make_pair(data.name, data.get_factory));
    }

    bool get_static_startup_shutdown(std::string const& instance,
        util::plugin::get_plugins_list_type& f)
    {
        typedef std::map<std::string, util::plugin::get_plugins_list_type>
            map_type;

        map_type const& m = get_static_startup_shutdown_data();
        map_type::const_iterator it = m.find(instance);
        if (it == m.end())
            return false;

        f = it->second;
        return true;
    }
}}

///////////////////////////////////////////////////////////////////////////////
namespace hpx { namespace components { namespace server
{
    ///////////////////////////////////////////////////////////////////////////
    runtime_support::runtime_support(hpx::util::runtime_configuration & cfg)
      : stop_called_(false), stop_done_(false), terminated_(false),
        dijkstra_color_(false), shutdown_all_invoked_(false),
        modules_(cfg.modules())
    {}

    ///////////////////////////////////////////////////////////////////////////
    // create a new instance of a memory block
    // FIXME: error code?
    naming::gid_type runtime_support::create_memory_block(
        std::size_t count, hpx::actions::manage_object_action_base const& act)
    {
        server::memory_block* c = server::memory_block::create(count, act);
        naming::gid_type gid = c->get_base_gid();
        if (gid) {
            LRT_(info) << ""successfully created memory block of size "" << count //-V128
                       << "": "" << gid;
            return gid;
        }

        delete c;

        std::ostringstream strm;
        strm << ""global id "" << gid << "" is already bound to a different ""
                ""component instance"";
        HPX_THROW_EXCEPTION(hpx::duplicate_component_address,
            ""runtime_support::create_memory_block"",
            strm.str());

        return naming::invalid_gid;
    }

    // function to be called during shutdown
    // Action: shut down this runtime system instance
    void runtime_support::shutdown(double timeout,
        naming::id_type const& respond_to)
    {
        // initiate system shutdown
        stop(timeout, respond_to, false);
    }

    // function to be called to terminate this locality immediately
    void runtime_support::terminate(naming::id_type const& respond_to)
    {
        // push pending logs
        components::cleanup_logging();

        if (respond_to) {
            // respond synchronously
            typedef lcos::base_lco_with_value<void> void_lco_type;
            typedef void_lco_type::set_event_action action_type;

            naming::address addr;
            if (agas::is_local_address_cached(respond_to, addr)) {
                // execute locally, action is executed immediately as it is
                // a direct_action
                hpx::applier::detail::apply_l<action_type>(respond_to,
                    std::move(addr));
            }
            else {
                // apply remotely, parcel is sent synchronously
                hpx::applier::detail::apply_r_sync<action_type>(std::move(addr),
                    respond_to);
            }
        }

        std::abort();
    }
}}}

///////////////////////////////////////////////////////////////////////////////
typedef hpx::components::server::runtime_support::call_shutdown_functions_action
    call_shutdown_functions_action;
typedef
    hpx::lcos::detail::make_broadcast_action<call_shutdown_functions_action>::type
    call_shutdown_functions_broadcast_action;

HPX_ACTION_USES_MEDIUM_STACK(
    call_shutdown_functions_broadcast_action)

HPX_REGISTER_BROADCAST_ACTION_DECLARATION(call_shutdown_functions_action,
        call_shutdown_functions_action)
HPX_REGISTER_BROADCAST_ACTION_ID(call_shutdown_functions_action,
        call_shutdown_functions_action,
        hpx::actions::broadcast_call_shutdown_functions_action_id)

#if defined(HPX_USE_FAST_DIJKSTRA_TERMINATION_DETECTION)

///////////////////////////////////////////////////////////////////////////////
typedef std::logical_or<bool> std_logical_or_type;

typedef hpx::components::server::runtime_support::dijkstra_termination_action
    dijkstra_termination_action;

HPX_REGISTER_REDUCE_ACTION_DECLARATION(dijkstra_termination_action, std_logical_or_type)
HPX_REGISTER_REDUCE_ACTION(dijkstra_termination_action, std_logical_or_type)

#endif

namespace hpx { namespace components { namespace server
{
    ///////////////////////////////////////////////////////////////////////////
    // initiate system shutdown for all localities
    void invoke_shutdown_functions(
        std::vector<naming::id_type> const& localities, bool pre_shutdown)
    {
        call_shutdown_functions_action act;
        lcos::broadcast(act, localities, pre_shutdown).get();
    }

    ///////////////////////////////////////////////////////////////////////////
    void runtime_support::dijkstra_make_black()
    {
        // Rule 1: A machine sending a message makes itself black.
        std::lock_guard<dijkstra_mtx_type> l(dijkstra_mtx_);
        dijkstra_color_ = true;
    }

#if defined(HPX_USE_FAST_DIJKSTRA_TERMINATION_DETECTION)
    // This new code does not work, currently, as the return actions generated
    // by the futures used by hpx::reduce make the sender black. This causes
    // an infinite loop while waiting for the Dijkstra termination detection
    // to return.

    // invoked during termination detection
    bool runtime_support::dijkstra_termination()
    {
        applier::applier& appl = hpx::applier::get_applier();
        naming::resolver_client& agas_client = appl.get_agas_client();

        agas_client.start_shutdown();

        // First wait for this locality to become passive. We do this by
        // periodically checking the number of still running threads.
        //
        // Rule 0: When active, machine nr.i + 1 keeps the token; when passive,
        // it hands over the token to machine nr.i.
        threads::threadmanager& tm = appl.get_thread_manager();

        util::yield_while([&tm]()
            {
                tm.cleanup_terminated(true);
                return tm.get_thread_count() >
                    std::int64_t(1) + tm.get_background_thread_count();
            }, ""runtime_support::dijkstra_termination"", hpx::threads::pending,
            false); // Don't allow timed suspension

        // Now this locality has become passive, thus we can send the token
        // to the next locality.
        //
        // Rule 2: When machine nr.i + 1 propagates the probe, it hands over a
        // black token to machine nr.i if it is black itself, whereas while
        // being white it leaves the color of the token unchanged.
        std::lock_guard<dijkstra_mtx_type> l(dijkstra_mtx_);
        bool dijkstra_token = dijkstra_color_;

        // Rule 5: Upon transmission of the token to machine nr.i, machine
        // nr.i + 1 becomes white.
        dijkstra_color_ = false;

        // The reduce-function (logical_or) will make sure black will be
        // propagated.
        return dijkstra_token;
    }

    // kick off termination detection
    std::size_t runtime_support::dijkstra_termination_detection(
        std::vector<naming::id_type> const& locality_ids)
    {
        std::uint32_t num_localities =
            static_cast<std::uint32_t>(locality_ids.size());
        if (num_localities == 1)
        {
            // While no real distributed termination detection has to be
            // performed, we should still wait for the thread-queues to drain.
            applier::applier& appl = hpx::applier::get_applier();
            threads::threadmanager& tm = appl.get_thread_manager();

            util::yield_while([&tm]()
                {
                    tm.cleanup_terminated(true);
                    return tm.get_thread_count() >
                        std::int64_t(1) + tm.get_background_thread_count();
                }, ""runtime_support::dijkstra_termination"",
                hpx::threads::pending, false); // Don't allow timed suspension

            return 0;
        }

        std::size_t count = 0;      // keep track of number of trials

        {
            // Note: we protect the entire loop here since the stopping condition
            // depends on the shared variable ""dijkstra_color_""
            // Proper unlocking for possible remote actions needs to be taken care of
            typedef std::unique_lock<dijkstra_mtx_type> dijkstra_scoped_lock;
            dijkstra_scoped_lock l(dijkstra_mtx_);
            do {
                // Rule 4: Machine nr.0 initiates a probe by making itself white
                // and sending a white token to machine nr.N - 1.
                dijkstra_color_ = false;        // start off with white

                dijkstra_termination_action act;
                bool termination_aborted = false;
                {
                    util::unlock_guard<dijkstra_scoped_lock> ul(l);
                    termination_aborted = lcos::reduce(act,
                        locality_ids, std_logical_or_type()).get()
                }

                if (termination_aborted)
                {
                    dijkstra_color_ = true;     // unsuccessful termination
                }

                // Rule 3: After the completion of an unsuccessful probe, machine
                // nr.0 initiates a next probe.

                ++count;

            } while (dijkstra_color_);
        }

        return count;
    }
#else
    void runtime_support::send_dijkstra_termination_token(
        std::uint32_t target_locality_id,
        std::uint32_t initiating_locality_id,
        std::uint32_t num_localities, bool dijkstra_token)
    {
        // First wait for this locality to become passive. We do this by
        // periodically checking the number of still running threads.
        //
        // Rule 0: When active, machine nr.i + 1 keeps the token; when passive,
        // it hands over the token to machine nr.i.
        applier::applier& appl = hpx::applier::get_applier();
        threads::threadmanager& tm = appl.get_thread_manager();

        util::yield_while([&tm]()
            {
                tm.cleanup_terminated(true);
                return tm.get_thread_count() >
                    std::int64_t(1) + tm.get_background_thread_count();
            }, ""runtime_support::dijkstra_termination"", hpx::threads::pending,
            false); // Don't allow timed suspension

        // Now this locality has become passive, thus we can send the token
        // to the next locality.
        //
        // Rule 2: When machine nr.i + 1 propagates the probe, it hands over a
        // black token to machine nr.i if it is black itself, whereas while
        // being white it leaves the color of the token unchanged.
        {
            std::lock_guard<dijkstra_mtx_type> l(dijkstra_mtx_);
            if (dijkstra_color_)
                dijkstra_token = dijkstra_color_;

            // Rule 5: Upon transmission of the token to machine nr.i, machine
            // nr.i + 1 becomes white.
            dijkstra_color_ = false;
        }

        naming::id_type id(naming::get_id_from_locality_id(target_locality_id));
        apply<dijkstra_termination_action>(id, initiating_locality_id,
            num_localities, dijkstra_token);
    }

    // invoked during termination detection
    void runtime_support::dijkstra_termination(
        std::uint32_t initiating_locality_id, std::uint32_t num_localities,
        bool dijkstra_token)
    {
        applier::applier& appl = hpx::applier::get_applier();
        naming::resolver_client& agas_client = appl.get_agas_client();
        parcelset::parcelhandler& ph = appl.get_parcel_handler();

        agas_client.start_shutdown();
        ph.flush_parcels();

        std::uint32_t locality_id = get_locality_id();

        if (initiating_locality_id == locality_id)
        {
            // we received the token after a full circle
            if (dijkstra_token)
            {
                std::lock_guard<dijkstra_mtx_type> l(dijkstra_mtx_);
                dijkstra_color_ = true;     // unsuccessful termination
            }

            dijkstra_cond_.notify_one();
            return;
        }

        if (0 == locality_id)
            locality_id = num_localities;

        send_dijkstra_termination_token(locality_id - 1,
            initiating_locality_id, num_localities, dijkstra_token);
    }

    // Kick off termination detection, this is modeled after Dijkstra's paper:
    // http://www.cs.mcgill.ca/~lli22/575/termination3.pdf.
    std::size_t runtime_support::dijkstra_termination_detection(
        std::vector<naming::id_type> const& locality_ids)
    {
        std::uint32_t num_localities =
            static_cast<std::uint32_t>(locality_ids.size());
        if (num_localities == 1)
        {
            // While no real distributed termination detection has to be
            // performed, we should still wait for the thread-queues to drain.
            applier::applier& appl = hpx::applier::get_applier();
            threads::threadmanager& tm = appl.get_thread_manager();

            util::yield_while([&tm]()
                {
                    tm.cleanup_terminated(true);
                    return tm.get_thread_count() >
                        std::int64_t(1) + tm.get_background_thread_count();
                }, ""runtime_support::dijkstra_termination"",
                hpx::threads::pending, false); // Don't allow timed suspension

            return 0;
        }

        std::uint32_t initiating_locality_id = get_locality_id();

        // send token to previous node
        std::uint32_t target_id = initiating_locality_id;
        if (0 == target_id)
            target_id = static_cast<std::uint32_t>(num_localities);

        std::size_t count = 0;      // keep track of number of trials

        {
            // Note: we protect the entire loop here since the stopping condition
            // depends on the shared variable ""dijkstra_color_""
            // Proper unlocking for possible remote actions needs to be taken care of
            typedef std::unique_lock<dijkstra_mtx_type> dijkstra_scoped_lock;
            dijkstra_scoped_lock l(dijkstra_mtx_);
            do {
                // Rule 4: Machine nr.0 initiates a probe by making itself white
                // and sending a white token to machine nr.N - 1.
                dijkstra_color_ = false;        // start off with white

                {
                    util::unlock_guard<dijkstra_scoped_lock> ul(l);
                    send_dijkstra_termination_token(target_id - 1,
                        initiating_locality_id, num_localities, false);
                }

                // wait for token to come back to us
                dijkstra_cond_.wait(l);

                // Rule 3: After the completion of an unsuccessful probe, machine
                // nr.0 initiates a next probe.

                ++count;

            } while (dijkstra_color_);
        }

        return count;
    }
#endif

    ///////////////////////////////////////////////////////////////////////////
    void runtime_support::shutdown_all(double timeout)
    {
        if (find_here() != hpx::find_root_locality())
        {
            HPX_THROW_EXCEPTION(invalid_status,
                ""runtime_support::shutdown_all"",
                ""shutdown_all should be invoked on the root locality only"");
            return;
        }

        // make sure shutdown_all is invoked only once
        bool flag = false;
        if (!shutdown_all_invoked_.compare_exchange_strong(flag, true))
        {
            return;
        }

        LRT_(info) << ""runtime_support::shutdown_all: ""
            ""initializing application shutdown"";

        applier::applier& appl = hpx::applier::get_applier();
        naming::resolver_client& agas_client = appl.get_agas_client();

        agas_client.start_shutdown();

        stop_evaluating_counters();

        // wake up suspended pus
        threads::threadmanager& tm = appl.get_thread_manager();
        tm.resume();

        std::vector<naming::id_type> locality_ids = find_all_localities();
        std::size_t count = dijkstra_termination_detection(locality_ids);

        LRT_(info) << ""runtime_support::shutdown_all: "" //-V128
                      ""passed first termination detection (count: ""
                   << count << "")."";

        // execute registered shutdown functions on all localities
        invoke_shutdown_functions(locality_ids, true);
        invoke_shutdown_functions(locality_ids, false);

        LRT_(info) << ""runtime_support::shutdown_all: ""
            ""invoked shutdown functions"";

        // Do a second round of termination detection to synchronize with all
        // work which was triggered by the invocation of the shutdown
        // functions.
        count = dijkstra_termination_detection(locality_ids);

        LRT_(info) << ""runtime_support::shutdown_all: "" //-V128
                      ""passed second termination detection (count: ""
                   << count << "")."";

        // Shut down all localities except the local one, we can't use
        // broadcast here as we have to handle the back parcel in a special
        // way.
        std::reverse(locality_ids.begin(), locality_ids.end());
        std::uint32_t locality_id = get_locality_id();
        std::vector<lcos::future<void> > lazy_actions;

        for (naming::id_type const& id : locality_ids)
        {
            if (locality_id != naming::get_locality_id_from_id(id))
            {
                using components::stubs::runtime_support;
                lazy_actions.push_back(runtime_support::shutdown_async(id,
                    timeout));
            }
        }

        // wait for all localities to be stopped
        wait_all(lazy_actions);

        LRT_(info) << ""runtime_support::shutdown_all: ""
            ""all localities have been shut down"";

        // Now make sure this local locality gets shut down as well.
        // There is no need to respond...
        stop(timeout, naming::invalid_id, false);
    }

    ///////////////////////////////////////////////////////////////////////////
    // initiate system shutdown for all localities
    void runtime_support::terminate_all()
    {
        std::vector<naming::gid_type> locality_ids;
        applier::applier& appl = hpx::applier::get_applier();
        appl.get_agas_client().get_localities(locality_ids);
        std::reverse(locality_ids.begin(), locality_ids.end());

        // Terminate all localities except the local one, we can't use
        // broadcast here as we have to handle the back parcel in a special
        // way.
        {
            std::uint32_t locality_id = get_locality_id();
            std::vector<lcos::future<void> > lazy_actions;

            for (naming::gid_type gid : locality_ids)
            {
                if (locality_id != naming::get_locality_id_from_gid(gid))
                {
                    using components::stubs::runtime_support;
                    naming::id_type id(gid, naming::id_type::unmanaged);
                    lazy_actions.push_back(runtime_support::terminate_async(id));
                }
            }

            // wait for all localities to be stopped
            wait_all(lazy_actions);
        }

        // now make sure this local locality gets terminated as well.
        terminate(naming::invalid_id);   //good night
    }

    ///////////////////////////////////////////////////////////////////////////
    // Retrieve configuration information
    util::section runtime_support::get_config()
    {
        return *(get_runtime().get_config().get_section(""application""));
    }

    ///////////////////////////////////////////////////////////////////////////
    /// \\brief Force a garbage collection operation in the AGAS layer.
    void runtime_support::garbage_collect()
    {
        naming::get_agas_client().garbage_collect_non_blocking();
    }

    ///////////////////////////////////////////////////////////////////////////
    /// \\brief Create the given performance counter instance.
    naming::gid_type runtime_support::create_performance_counter(
        performance_counters::counter_info const& info)
    {
        return performance_counters::detail::create_counter_local(info);
    }

    ///////////////////////////////////////////////////////////////////////////
    void runtime_support::delete_function_lists()
    {
        pre_startup_functions_.clear();
        startup_functions_.clear();
        pre_shutdown_functions_.clear();
        shutdown_functions_.clear();
    }

    void runtime_support::tidy()
    {
        // Only after releasing the components we are allowed to release
        // the modules. This is done in reverse order of loading.
        plugins_.clear();       // unload all plugins
        modules_.clear();       // unload all modules
    }

    ///////////////////////////////////////////////////////////////////////////
    /// \\brief Remove the given locality from our connection cache
    void runtime_support::remove_from_connection_cache(
        naming::gid_type const& gid, parcelset::endpoints_type const& eps)
    {
        runtime* rt = get_runtime_ptr();
        if (rt == nullptr) return;

        // instruct our connection cache to drop all connections it is holding
        rt->get_parcel_handler().remove_from_connection_cache(gid, eps);
    }

    ///////////////////////////////////////////////////////////////////////////
    void runtime_support::run()
    {
        std::unique_lock<compat::mutex> l(mtx_);
        stop_called_ = false;
        stop_done_ = false;
        terminated_ = false;
        shutdown_all_invoked_.store(false);
    }

    void runtime_support::wait()
    {
        std::unique_lock<compat::mutex> l(mtx_);
        while (!stop_done_) {
            LRT_(info) << ""runtime_support: about to enter wait state"";
            wait_condition_.wait(l);
            LRT_(info) << ""runtime_support: exiting wait state"";
        }
    }

    void runtime_support::stop(double timeout,
        naming::id_type const& respond_to, bool remove_from_remote_caches)
    {
        std::unique_lock<compat::mutex> l(mtx_);
        if (!stop_called_) {
            // push pending logs
            components::cleanup_logging();

            HPX_ASSERT(!terminated_);

            applier::applier& appl = hpx::applier::get_applier();
            threads::threadmanager& tm = appl.get_thread_manager();
            naming::resolver_client& agas_client = appl.get_agas_client();

            util::high_resolution_timer t;
            double start_time = t.elapsed();
            bool timed_out = false;
            error_code ec(lightweight);

            stop_called_ = true;

            {
                util::unlock_guard<compat::mutex> ul(mtx_);

                util::yield_while(
                    [&tm, timeout, &t, start_time, &timed_out]()
                    {
                        tm.cleanup_terminated(true);

                        if (timeout >= 0.0 && timeout <
                            (t.elapsed() - start_time))
                        {
                            timed_out = true;
                            return false;
                        }

                        return tm.get_thread_count() >
                            std::int64_t(1) + tm.get_background_thread_count();
                    }, ""runtime_support::stop"", hpx::threads::pending,
                    false); // Don't allow timed suspension

                // If it took longer than expected, kill all suspended threads as
                // well.
                if (timed_out) {
                    // now we have to wait for all threads to be aborted
                    start_time = t.elapsed();

                    util::yield_while(
                        [&tm, timeout, &t, start_time]()
                        {
                            tm.abort_all_suspended_threads();
                            tm.cleanup_terminated(true);

                            if (timeout >= 0.0 && timeout <
                                (t.elapsed() - start_time))
                            {
                                return false;
                            }

                            return tm.get_thread_count() >
                                std::int64_t(1) +
                                tm.get_background_thread_count();
                        }, ""runtime_support::dijkstra_termination"",
                        hpx::threads::pending,
                        false); // Don't allow timed suspension
                }

                // Drop the locality from the partition table.
                naming::gid_type here = agas_client.get_local_locality();

                // unregister fixed components
                agas_client.unbind_local(appl.get_runtime_support_raw_gid(), ec);
                agas_client.unbind_local(appl.get_memory_raw_gid(), ec);

                if (remove_from_remote_caches)
                    remove_here_from_connection_cache();

                agas_client.unregister_locality(here, ec);

                if (remove_from_remote_caches)
                    remove_here_from_console_connection_cache();

                if (respond_to) {
                    // respond synchronously
                    typedef lcos::base_lco_with_value<void> void_lco_type;
                    typedef void_lco_type::set_event_action action_type;

                    naming::address addr;
                    if (agas::is_local_address_cached(respond_to, addr)) {
                        // this should never happen
                        HPX_ASSERT(false);
                    }
                    else {
                        // apply remotely, parcel is sent synchronously
                        hpx::applier::detail::apply_r_sync<action_type>(
                            std::move(addr), respond_to);
                    }
                }
            }

            stop_done_ = true;
            wait_condition_.notify_all();
            stop_condition_.wait(l);        // wait for termination
        }
    }

    void runtime_support::notify_waiting_main()
    {
        std::unique_lock<compat::mutex> l(mtx_);
        if (!stop_called_) {
            stop_called_ = true;
            stop_done_ = true;
            wait_condition_.notify_all();
            stop_condition_.wait(l);        // wait for termination
        }
    }

    // this will be called after the thread manager has exited
    void runtime_support::stopped()
    {
        std::lock_guard<compat::mutex> l(mtx_);
        if (!terminated_) {
            terminated_ = true;
            stop_condition_.notify_all();   // finished cleanup/termination
        }
    }

    ///////////////////////////////////////////////////////////////////////////
    inline void decode (std::string &str, char const *s, char const *r)
    {
        std::string::size_type pos = 0;
        while ((pos = str.find(s, pos)) != std::string::npos)
        {
            str.replace(pos, 2, r);
        }
    }

    inline std::string decode_string(std::string str)
    {
        decode(str, ""\\\\n"", ""\\n"");
        return str;
    }

    int runtime_support::load_components()
    {
        // load components now that AGAS is up
        util::runtime_configuration& ini = get_runtime().get_config();

        // first static components
        ini.load_components_static(components::get_static_module_data());

        // modules loaded dynamically should not register themselves statically
        components::initial_static_loading = false;

        // make sure every component module gets asked for startup/shutdown
        // functions only once
        std::set<std::string> startup_handled;

        // collect additional command-line options
        boost::program_options::options_description options;

        // then dynamic ones
        naming::resolver_client& client = get_runtime().get_agas_client();
        int result = load_components(ini, client.get_local_locality(), client,
            options, startup_handled);

        if (!load_plugins(ini, options, startup_handled))
            result = -2;

        // do secondary command line processing, check validity of options only
        try {
            std::string unknown_cmd_line(ini.get_entry(""hpx.unknown_cmd_line"", """"));
            if (!unknown_cmd_line.empty()) {
                std::string runtime_mode(ini.get_entry(""hpx.runtime_mode"", """"));
                boost::program_options::variables_map vm;

                util::commandline_error_mode mode = util::rethrow_on_error;
                std::string allow_unknown(
                    ini.get_entry(""hpx.commandline.allow_unknown"", ""0""));
                if (allow_unknown != ""0"") mode = util::allow_unregistered;

                std::vector<std::string> still_unregistered_options;
                util::parse_commandline(ini, options, unknown_cmd_line, vm,
                    std::size_t(-1), mode,
                    get_runtime_mode_from_name(runtime_mode), nullptr,
                    &still_unregistered_options);

                std::string still_unknown_commandline;
                for (std::size_t i = 1; i != still_unregistered_options.size();
                     ++i)
                {
                    if (i != 1)
                    {
                        still_unknown_commandline += "" "";
                    }
                    still_unknown_commandline +=
                        util::detail::enquote(still_unregistered_options[i]);
                }

                if (!still_unknown_commandline.empty())
                {
                    util::section* s = ini.get_section(""hpx"");
                    HPX_ASSERT(s != nullptr);
                    s->add_entry(""unknown_cmd_line_option"",
                        still_unknown_commandline);
                }
            }

            std::string fullhelp(ini.get_entry(""hpx.cmd_line_help"", """"));
            if (!fullhelp.empty()) {
                std::string help_option(
                    ini.get_entry(""hpx.cmd_line_help_option"", """"));
                if (0 == std::string(""full"").find(help_option)) {
                    std::cout << decode_string(fullhelp);
                    std::cout << options << std::endl;
                }
                else {
                    throw hpx::detail::command_line_error(
                        ""unknown help option: "" + help_option);
                }
                return 1;
            }

            // secondary command line handling, looking for --exit and other
            // options
            std::string cmd_line(ini.get_entry(""hpx.cmd_line"", """"));
            if (!cmd_line.empty()) {
                std::string runtime_mode(ini.get_entry(""hpx.runtime_mode"", """"));
                boost::program_options::variables_map vm;

                util::parse_commandline(ini, options, cmd_line, vm, std::size_t(-1),
                    util::allow_unregistered | util::report_missing_config_file,
                    get_runtime_mode_from_name(runtime_mode));

                if (vm.count(""hpx:print-bind"")) {
                    std::size_t num_threads = boost::lexical_cast<std::size_t>(
                        ini.get_entry(""hpx.os_threads"", 1));
                    util::handle_print_bind(vm, num_threads);
                }

                if (vm.count(""hpx:list-parcel-ports""))
                    util::handle_list_parcelports();

                if (vm.count(""hpx:exit""))
                    return 1;
            }
        }
        catch (std::exception const& e) {
            std::cerr << ""runtime_support::load_components: ""
                      << ""command line processing: "" << e.what() << std::endl;
            return -1;
        }

        return result;
    }

    void runtime_support::call_startup_functions(bool pre_startup)
    {
        if (pre_startup) {
            get_runtime().set_state(state_pre_startup);
            for (startup_function_type& f : pre_startup_functions_)
            {
                f();
            }
        }
        else {
            get_runtime().set_state(state_startup);
            for (startup_function_type& f : startup_functions_)
            {
                f();
            }
        }
    }

    void runtime_support::call_shutdown_functions(bool pre_shutdown)
    {
        runtime& rt = get_runtime();
        if (pre_shutdown) {
            rt.set_state(state_pre_shutdown);
            for (shutdown_function_type& f : pre_shutdown_functions_)
            {
                try {
                    f();
                }
                catch (...) {
                    rt.report_error(std::current_exception());
                }
            }
        }
        else {
            rt.set_state(state_shutdown);
            for (shutdown_function_type& f : shutdown_functions_)
            {
                try {
                    f();
                }
                catch (...) {
                    rt.report_error(std::current_exception());
                }
            }
            lcos::barrier::get_global_barrier().detach();
        }
    }

    // working around non-copy-ability of packaged_task
    struct indirect_packaged_task
    {
        typedef lcos::local::packaged_task<void()> packaged_task_type;

        indirect_packaged_task()
          : pt(std::make_shared<packaged_task_type>([](){}))
        {}

        hpx::future<void> get_future()
        {
            return pt->get_future();
        }

        template <typename ...Ts>
        void operator()(Ts&& ... vs)
        {
            // This needs to be run on a HPX thread
            hpx::apply(std::move(*pt));
            pt.reset();
        }

        std::shared_ptr<packaged_task_type> pt;
    };

    void runtime_support::remove_here_from_connection_cache()
    {
        runtime* rt = get_runtime_ptr();
        if (rt == nullptr)
            return;

        std::vector<naming::id_type> locality_ids = find_remote_localities();

        typedef server::runtime_support::remove_from_connection_cache_action
            action_type;

        std::vector<future<void> > callbacks;
        callbacks.reserve(locality_ids.size());

        action_type act;
        for (naming::id_type const& id : locality_ids)
        {
            // console is handled separately
            if (naming::get_locality_id_from_id(id) == 0)
                continue;

            indirect_packaged_task ipt;
            callbacks.push_back(ipt.get_future());
            apply_cb(act, id, std::move(ipt), hpx::get_locality(), rt->endpoints());
        }

        wait_all(callbacks);
    }

    void runtime_support::remove_here_from_console_connection_cache()
    {
        runtime* rt = get_runtime_ptr();
        if (rt == nullptr)
            return;

        typedef server::runtime_support::remove_from_connection_cache_action
            action_type;

        action_type act;
        indirect_packaged_task ipt;
        future<void> callback = ipt.get_future();

        // handle console separately
        id_type id = naming::get_id_from_locality_id(0);
        apply_cb(act, id, std::move(ipt), hpx::get_locality(), rt->endpoints());

        callback.wait();
    }

    ///////////////////////////////////////////////////////////////////////////
    void runtime_support::register_message_handler(
        char const* message_handler_type, char const* action, error_code& ec)
    {
        // locate the factory for the requested plugin type
        typedef std::unique_lock<plugin_map_mutex_type> plugin_map_scoped_lock;
        plugin_map_scoped_lock l(p_mtx_);

        plugin_map_type::const_iterator it = plugins_.find(message_handler_type);
        if (it == plugins_.end() || !(*it).second.first) {
            if (ec.category() != hpx::get_lightweight_hpx_category())
            {
                // we don't know anything about this component
                std::ostringstream strm;
                strm << ""attempt to create message handler plugin instance of ""
                        ""invalid/unknown type: "" << message_handler_type;
                l.unlock();
                HPX_THROWS_IF(ec, hpx::bad_plugin_type,
                    ""runtime_support::create_message_handler"",
                    strm.str());
            }
            else
            {
                // lightweight error handling
                HPX_THROWS_IF(ec, hpx::bad_plugin_type,
                    ""runtime_support::create_message_handler"",
                    ""attempt to create message handler plugin instance of ""
                    ""invalid/unknown type"");
            }
            return;
        }

        l.unlock();

        // create new component instance
        std::shared_ptr<plugins::message_handler_factory_base> factory(
            std::static_pointer_cast<plugins::message_handler_factory_base>(
                (*it).second.first));

        factory->register_action(action, ec);

        if (ec)
        {
            std::ostringstream strm;
            strm << ""couldn't register action '"" << action
                 << ""' for message handler plugin of type: ""
                 << message_handler_type;
            HPX_THROWS_IF(ec, hpx::bad_plugin_type,
                ""runtime_support::register_message_handler"",
                strm.str());
            return;
        }

        if (&ec != &throws)
            ec = make_success_code();

        // log result if requested
        LRT_(info) << ""successfully registered message handler plugin of type: ""
                    << message_handler_type;
    }

    parcelset::policies::message_handler*
    runtime_support::create_message_handler(
        char const* message_handler_type, char const* action,
        parcelset::parcelport* pp, std::size_t num_messages,
        std::size_t interval, error_code& ec)
    {
        // locate the factory for the requested plugin type
        typedef std::unique_lock<plugin_map_mutex_type> plugin_map_scoped_lock;
        plugin_map_scoped_lock l(p_mtx_);

        plugin_map_type::const_iterator it = plugins_.find(message_handler_type);
        if (it == plugins_.end() || !(*it).second.first) {
            if (ec.category() != hpx::get_lightweight_hpx_category())
            {
                // we don't know anything about this component
                std::ostringstream strm;
                strm << ""attempt to create message handler plugin instance of ""
                        ""invalid/unknown type: "" << message_handler_type;
                l.unlock();
                HPX_THROWS_IF(ec, hpx::bad_plugin_type,
                    ""runtime_support::create_message_handler"",
                    strm.str());
            }
            else
            {
                // lightweight error handling
                HPX_THROWS_IF(ec, hpx::bad_plugin_type,
                    ""runtime_support::create_message_handler"",
                    ""attempt to create message handler plugin instance of ""
                    ""invalid/unknown type"");
            }
            return nullptr;
        }

        l.unlock();

        // create new component instance
        std::shared_ptr<plugins::message_handler_factory_base> factory(
            std::static_pointer_cast<plugins::message_handler_factory_base>(
                (*it).second.first));

        parcelset::policies::message_handler* mh = factory->create(action,
            pp, num_messages, interval);
        if (nullptr == mh) {
            std::ostringstream strm;
            strm << ""couldn't create message handler plugin of type: ""
                 << message_handler_type;
            HPX_THROWS_IF(ec, hpx::bad_plugin_type,
                ""runtime_support::create_message_handler"",
                strm.str());
            return nullptr;
        }

        if (&ec != &throws)
            ec = make_success_code();

        // log result if requested
        LRT_(info) << ""successfully created message handler plugin of type: ""
                    << message_handler_type;
        return mh;
    }

    serialization::binary_filter* runtime_support::create_binary_filter(
        char const* binary_filter_type, bool compress,
        serialization::binary_filter* next_filter, error_code& ec)
    {
        // locate the factory for the requested plugin type
        typedef std::unique_lock<plugin_map_mutex_type> plugin_map_scoped_lock;
        plugin_map_scoped_lock l(p_mtx_);

        plugin_map_type::const_iterator it = plugins_.find(binary_filter_type);
        if (it == plugins_.end() || !(*it).second.first) {
            // we don't know anything about this component
            std::ostringstream strm;
            strm << ""attempt to create binary filter plugin instance of ""
                    ""invalid/unknown type: "" << binary_filter_type;
            HPX_THROWS_IF(ec, hpx::bad_plugin_type,
                ""runtime_support::create_binary_filter"",
                strm.str());
            return nullptr;
        }

        l.unlock();

        // create new component instance
        std::shared_ptr<plugins::binary_filter_factory_base> factory(
            std::static_pointer_cast<plugins::binary_filter_factory_base>(
                (*it).second.first));

        serialization::binary_filter* bf = factory->create(compress, next_filter);
        if (nullptr == bf) {
            std::ostringstream strm;
            strm << ""couldn't create binary filter plugin of type: ""
                 << binary_filter_type;
            HPX_THROWS_IF(ec, hpx::bad_plugin_type,
                ""runtime_support::create_binary_filter"",
                strm.str());
            return nullptr;
        }

        if (&ec != &throws)
            ec = make_success_code();

        // log result if requested
        LRT_(info) << ""successfully created binary filter handler plugin of type: ""
                    << binary_filter_type;
        return bf;
    }

    ///////////////////////////////////////////////////////////////////////////
    bool runtime_support::load_component_static(
        util::section& ini, std::string const& instance,
        std::string const& component, boost::filesystem::path const& lib,
        naming::gid_type const& prefix, naming::resolver_client& agas_client,
        bool isdefault, bool isenabled,
        boost::program_options::options_description& options,
        std::set<std::string>& startup_handled)
    {
        try {
            // initialize the factory instance using the preferences from the
            // ini files
            util::section const* glob_ini = nullptr;
            if (ini.has_section(""settings""))
                glob_ini = ini.get_section(""settings"");

            util::section const* component_ini = nullptr;
            std::string component_section(""hpx.components."" + instance);
            if (ini.has_section(component_section))
                component_ini = ini.get_section(component_section);

            error_code ec(lightweight);
            if (nullptr == component_ini ||
                ""0"" == component_ini->get_entry(""no_factory"", ""0""))
            {
                util::plugin::get_plugins_list_type f;
                if (!components::get_static_factory(instance, f)) {
                    LRT_(warning) << ""static loading failed: "" << lib.string()
                                    << "": "" << instance << "": couldn't find ""
                                    << ""factory in global static factory map"";
                    return false;
                }

                LRT_(info) << ""static loading succeeded: "" << lib.string()
                            << "": "" << instance;
            }

            // make sure startup/shutdown registration is called once for each
            // module, same for plugins
            if (startup_handled.find(component) == startup_handled.end()) {
                startup_handled.insert(component);
                load_commandline_options_static(component, options, ec);
                if (ec) ec = error_code(lightweight);
                load_startup_shutdown_functions_static(component, ec);
            }
        }
        catch (hpx::exception const&) {
            throw;
        }
        catch (std::logic_error const& e) {
            LRT_(warning) << ""static loading failed: "" << lib.string()
                          << "": "" << instance << "": "" << e.what();
            return false;
        }
        catch (std::exception const& e) {
            LRT_(warning) << ""static loading failed: "" << lib.string()
                          << "": "" << instance << "": "" << e.what();
            return false;
        }
        return true;    // component got loaded
    }

    ///////////////////////////////////////////////////////////////////////////
    // Load all components from the ini files found in the configuration
    int runtime_support::load_components(util::section& ini,
        naming::gid_type const& prefix, naming::resolver_client& agas_client,
        boost::program_options::options_description& options,
        std::set<std::string>& startup_handled)
    {
        // load all components as described in the configuration information
        if (!ini.has_section(""hpx.components"")) {
            LRT_(info) << ""No components found/loaded, HPX will be mostly ""
                          ""non-functional (no section [hpx.components] found)."";
            return 0;     // no components to load
        }

        // each shared library containing components may have an ini section
        //
        // # mandatory section describing the component module
        // [hpx.components.instance_name]
        //  name = ...           # the name of this component module
        //  path = ...           # the path where to find this component module
        //  enabled = false      # optional (default is assumed to be true)
        //  static = false       # optional (default is assumed to be false)
        //
        // # optional section defining additional properties for this module
        // [hpx.components.instance_name.settings]
        //  key = value
        //
        util::section* sec = ini.get_section(""hpx.components"");
        if (nullptr == sec)
        {
            LRT_(error) << ""nullptr section found"";
            return 0;     // something bad happened
        }

        util::section::section_map const& s = (*sec).get_sections();
        typedef util::section::section_map::const_iterator iterator;
        iterator end = s.end();
        for (iterator i = s.begin (); i != end; ++i)
        {
            namespace fs = boost::filesystem;

            // the section name is the instance name of the component
            util::section const& sect = i->second;
            std::string instance (sect.get_name());
            std::string component;

            if (sect.has_entry(""name""))
                component = sect.get_entry(""name"");
            else
                component = instance;

            bool isenabled = true;
            if (sect.has_entry(""enabled"")) {
                std::string tmp = sect.get_entry(""enabled"");
                boost::algorithm::to_lower (tmp);
                if (tmp == ""no"" || tmp == ""false"" || tmp == ""0"") {
                    LRT_(info) << ""component factory disabled: "" << instance;
                    isenabled = false;     // this component has been disabled
                }
            }

            // test whether this component section was generated
            bool isdefault = false;
            if (sect.has_entry(""isdefault"")) {
                std::string tmp = sect.get_entry(""isdefault"");
                boost::algorithm::to_lower (tmp);
                if (tmp == ""true"")
                    isdefault = true;
            }

            fs::path lib;
            try {
                std::string component_path;
                if (sect.has_entry(""path""))
                    component_path = sect.get_entry(""path"");
                else
                    component_path = HPX_DEFAULT_COMPONENT_PATH;

                typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
                boost::char_separator<char> sep(HPX_INI_PATH_DELIMITER);
                tokenizer tokens(component_path, sep);
                boost::system::error_code fsec;
                for(tokenizer::iterator it = tokens.begin(); it != tokens.end(); ++it)
                {
                    lib = hpx::util::create_path(*it);
                    fs::path lib_path =
                        lib / std::string(HPX_MAKE_DLL_STRING(component));
                    if(fs::exists(lib_path, fsec))
                    {
                        break;
                    }
                    lib.clear();
                }

                if (sect.get_entry(""static"", ""0"") == ""1"") {
                    load_component_static(ini, instance,
                        component, lib, prefix, agas_client, isdefault,
                        isenabled, options, startup_handled);
                }
                else {
#if defined(HPX_HAVE_STATIC_LINKING)
                    HPX_THROW_EXCEPTION(service_unavailable,
                        ""runtime_support::load_components"",
                        ""static linking configuration does not support dynamic ""
                        ""loading of component '"" + instance + ""'"");
#else
                    load_component_dynamic(ini, instance,
                        component, lib, prefix, agas_client, isdefault,
                        isenabled, options, startup_handled);
#endif
                }
            }
            catch (hpx::exception const& e) {
                LRT_(warning) << ""caught exception while loading "" << instance
                              << "", "" << e.get_error_code().get_message()
                              << "": "" << e.what();
                if (e.get_error_code().value() == hpx::commandline_option_error)
                {
                    std::cerr << ""runtime_support::load_components: ""
                              << ""invalid command line option(s) to ""
                              << instance << "" component: "" << e.what()
                              << std::endl;
                }
            }
        } // for

        return 0;
    }

    ///////////////////////////////////////////////////////////////////////////
    bool runtime_support::load_startup_shutdown_functions_static(
        std::string const& module, error_code& ec)
    {
        try {
            // get the factory, may fail
            util::plugin::get_plugins_list_type f;
            if (!components::get_static_startup_shutdown(module, f))
            {
                LRT_(debug) << ""static loading of startup/shutdown functions ""
                    ""failed: "" << module << "": couldn't find module in global ""
                        << ""static startup/shutdown functions data map"";
                return false;
            }

            util::plugin::static_plugin_factory<
                component_startup_shutdown_base> pf (f);

            // create the startup_shutdown object
            std::shared_ptr<component_startup_shutdown_base>
                startup_shutdown(pf.create(""startup_shutdown"", ec));
            if (ec) {
                LRT_(debug) << ""static loading of startup/shutdown functions ""
                    ""failed: "" << module << "": "" << get_error_what(ec);
                return false;
            }

            startup_function_type startup;
            bool pre_startup = true;
            if (startup_shutdown->get_startup_function(startup, pre_startup))
            {
                if (pre_startup)
                    pre_startup_functions_.push_back(std::move(startup));
                else
                    startup_functions_.push_back(std::move(startup));
            }

            shutdown_function_type shutdown;
            bool pre_shutdown = false;
            if (startup_shutdown->get_shutdown_function(shutdown, pre_shutdown))
            {
                if (pre_shutdown)
                    pre_shutdown_functions_.push_back(std::move(shutdown));
                else
                    shutdown_functions_.push_back(std::move(shutdown));
            }
        }
        catch (hpx::exception const&) {
            throw;
        }
        catch (std::logic_error const& e) {
            LRT_(debug) << ""static loading of startup/shutdown functions failed: ""
                        << module << "": "" << e.what();
            return false;
        }
        catch (std::exception const& e) {
            LRT_(debug) << ""static loading of startup/shutdown functions failed: ""
                        << module << "": "" << e.what();
            return false;
        }
        return true;    // startup/shutdown functions got registered
    }

    ///////////////////////////////////////////////////////////////////////////
    bool runtime_support::load_commandline_options_static(
        std::string const& module,
        boost::program_options::options_description& options, error_code& ec)
    {
        try {
            util::plugin::get_plugins_list_type f;
            if (!components::get_static_commandline(module, f))
            {
                LRT_(debug) << ""static loading of command-line options failed: ""
                        << module << "": couldn't find module in global ""
                        << ""static command line data map"";
                return false;
            }

            // get the factory, may fail
            hpx::util::plugin::static_plugin_factory<
                component_commandline_base> pf (f);

            // create the startup_shutdown object
            std::shared_ptr<component_commandline_base>
                commandline_options(pf.create(""commandline_options"", ec));
            if (ec) {
                LRT_(debug) << ""static loading of command-line options failed: ""
                            << module << "": "" << get_error_what(ec);
                return false;
            }

            options.add(commandline_options->add_commandline_options());
        }
        catch (hpx::exception const&) {
            throw;
        }
        catch (std::logic_error const& e) {
            LRT_(debug) << ""static loading of command-line options failed: ""
                        << module << "": "" << e.what();
            return false;
        }
        catch (std::exception const& e) {
            LRT_(debug) << ""static loading of command-line options failed: ""
                        << module << "": "" << e.what();
            return false;
        }
        return true;    // startup/shutdown functions got registered
    }

#if !defined(HPX_HAVE_STATIC_LINKING)
    bool runtime_support::load_component_dynamic(
        util::section& ini, std::string const& instance,
        std::string const& component, boost::filesystem::path lib,
        naming::gid_type const& prefix, naming::resolver_client& agas_client,
        bool isdefault, bool isenabled,
        boost::program_options::options_description& options,
        std::set<std::string>& startup_handled)
    {
        modules_map_type::iterator it = modules_.find(HPX_MANGLE_STRING(component));
        if (it != modules_.cend())
        {
            // use loaded module, instantiate the requested factory
            return load_component((*it).second, ini, instance, component, lib,
                prefix, agas_client, isdefault, isenabled, options,
                startup_handled);
        }

        // first, try using the path as the full path to the library
        error_code ec(lightweight);
        hpx::util::plugin::dll d(lib.string(), HPX_MANGLE_STRING(component));
        d.load_library(ec);
        if (ec) {
            // build path to component to load
            std::string libname(HPX_MAKE_DLL_STRING(component));
            lib /= hpx::util::create_path(libname);
            d.load_library(ec);
            if (ec) {
                LRT_(warning) << ""dynamic loading failed: "" << lib.string()
                                << "": "" << instance << "": "" << get_error_what(ec);
                return false;   // next please :-P
            }
        }

        // now, instantiate the requested factory
        if (!load_component(d, ini, instance, component, lib, prefix,
                agas_client, isdefault, isenabled, options,
                startup_handled))
        {
            return false;   // next please :-P
        }

        modules_.insert(std::make_pair(HPX_MANGLE_STRING(component), d));
        return true;
    }

    bool runtime_support::load_startup_shutdown_functions(hpx::util::plugin::dll& d,
        error_code& ec)
    {
        try {
            // get the factory, may fail
            hpx::util::plugin::plugin_factory<component_startup_shutdown_base> pf (d,
                ""startup_shutdown"");

            // create the startup_shutdown object
            std::shared_ptr<component_startup_shutdown_base>
                startup_shutdown(pf.create(""startup_shutdown"", ec));
            if (ec) {
                LRT_(debug) << ""loading of startup/shutdown functions failed: ""
                            << d.get_name() << "": "" << get_error_what(ec);
                return false;
            }

            startup_function_type startup;
            bool pre_startup = true;
            if (startup_shutdown->get_startup_function(startup, pre_startup))
            {
                if (pre_startup)
                    pre_startup_functions_.push_back(std::move(startup));
                else
                    startup_functions_.push_back(std::move(startup));
            }

            shutdown_function_type shutdown;
            bool pre_shutdown = false;
            if (startup_shutdown->get_shutdown_function(shutdown, pre_shutdown))
            {
                if (pre_shutdown)
                    pre_shutdown_functions_.push_back(std::move(shutdown));
                else
                    shutdown_functions_.push_back(std::move(shutdown));
            }
        }
        catch (hpx::exception const&) {
            throw;
        }
        catch (std::logic_error const& e) {
            LRT_(debug) << ""loading of startup/shutdown functions failed: ""
                        << d.get_name() << "": "" << e.what();
            return false;
        }
        catch (std::exception const& e) {
            LRT_(debug) << ""loading of startup/shutdown functions failed: ""
                        << d.get_name() << "": "" << e.what();
            return false;
        }
        return true;    // startup/shutdown functions got registered
    }

    bool runtime_support::load_commandline_options(hpx::util::plugin::dll& d,
        boost::program_options::options_description& options, error_code& ec)
    {
        try {
            // get the factory, may fail
            hpx::util::plugin::plugin_factory<component_commandline_base> pf (d,
                ""commandline_options"");

            // create the startup_shutdown object
            std::shared_ptr<component_commandline_base>
                commandline_options(pf.create(""commandline_options"", ec));
            if (ec) {
                LRT_(debug) << ""loading of command-line options failed: ""
                            << d.get_name() << "": "" << get_error_what(ec);
                return false;
            }

            options.add(commandline_options->add_commandline_options());
        }
        catch (hpx::exception const&) {
            throw;
        }
        catch (std::logic_error const& e) {
            LRT_(debug) << ""loading of command-line options failed: ""
                        << d.get_name() << "": "" << e.what();
            return false;
        }
        catch (std::exception const& e) {
            LRT_(debug) << ""loading of command-line options failed: ""
                        << d.get_name() << "": "" << e.what();
            return false;
        }
        return true;    // startup/shutdown functions got registered
    }

    ///////////////////////////////////////////////////////////////////////////
    bool runtime_support::load_component(
        hpx::util::plugin::dll& d, util::section& ini,
        std::string const& instance, std::string const& component,
        boost::filesystem::path const& lib, naming::gid_type const& prefix,
        naming::resolver_client& agas_client, bool isdefault, bool isenabled,
        boost::program_options::options_description& options,
        std::set<std::string>& startup_handled)
    {
        try {
            // initialize the factory instance using the preferences from the
            // ini files
            util::section const* glob_ini = nullptr;
            if (ini.has_section(""settings""))
                glob_ini = ini.get_section(""settings"");

            util::section const* component_ini = nullptr;
            std::string component_section(""hpx.components."" + instance);
            if (ini.has_section(component_section))
                component_ini = ini.get_section(component_section);

            error_code ec(lightweight);
            if (nullptr == component_ini ||
                ""0"" == component_ini->get_entry(""no_factory"", ""0""))
            {
                // get the factory
                hpx::util::plugin::plugin_factory<component_factory_base> pf (d,
                    ""factory"");

                LRT_(info) << ""dynamic loading succeeded: "" << lib.string()
                            << "": "" << instance;
            }

            // make sure startup/shutdown registration is called once for each
            // module, same for plugins
            if (startup_handled.find(d.get_name()) == startup_handled.end()) {
                startup_handled.insert(d.get_name());
                load_commandline_options(d, options, ec);
                if (ec) ec = error_code(lightweight);
                load_startup_shutdown_functions(d, ec);
            }
        }
        catch (hpx::exception const&) {
            throw;
        }
        catch (std::logic_error const& e) {
            LRT_(warning) << ""dynamic loading failed: "" << lib.string()
                          << "": "" << instance << "": "" << e.what();
            return false;
        }
        catch (std::exception const& e) {
            LRT_(warning) << ""dynamic loading failed: "" << lib.string()
                          << "": "" << instance << "": "" << e.what();
            return false;
        }
        return true;    // component got loaded
    }
#endif

    ///////////////////////////////////////////////////////////////////////////
    // Load all components from the ini files found in the configuration
    bool runtime_support::load_plugins(util::section& ini,
        boost::program_options::options_description& options,
        std::set<std::string>& startup_handled)
    {
        // load all components as described in the configuration information
        if (!ini.has_section(""hpx.plugins"")) {
            LRT_(info) << ""No plugins found/loaded."";
            return true;     // no plugins to load
        }

        // each shared library containing components may have an ini section
        //
        // # mandatory section describing the component module
        // [hpx.plugins.instance_name]
        //  name = ...           # the name of this component module
        //  path = ...           # the path where to find this component module
        //  enabled = false      # optional (default is assumed to be true)
        //  static = false       # optional (default is assumed to be false)
        //
        // # optional section defining additional properties for this module
        // [hpx.plugins.instance_name.settings]
        //  key = value
        //
        util::section* sec = ini.get_section(""hpx.plugins"");
        if (nullptr == sec)
        {
            LRT_(error) << ""nullptr section found"";
            return false;     // something bad happened
        }

        util::section::section_map const& s = (*sec).get_sections();
        typedef util::section::section_map::const_iterator iterator;
        iterator end = s.end();
        for (iterator i = s.begin (); i != end; ++i)
        {
            namespace fs = boost::filesystem;

            // the section name is the instance name of the component
            util::section const& sect = i->second;
            std::string instance (sect.get_name());
            std::string component;

            if (i->second.has_entry(""name""))
                component = sect.get_entry(""name"");
            else
                component = instance;

            bool isenabled = true;
            if (sect.has_entry(""enabled"")) {
                std::string tmp = sect.get_entry(""enabled"");
                boost::algorithm::to_lower (tmp);
                if (tmp == ""no"" || tmp == ""false"" || tmp == ""0"") {
                    LRT_(info) << ""plugin factory disabled: "" << instance;
                    isenabled = false;     // this component has been disabled
                }
            }

            fs::path lib;
            try {
                std::string component_path;
                if (sect.has_entry(""path""))
                    component_path = sect.get_entry(""path"");
                else
                    component_path = HPX_DEFAULT_COMPONENT_PATH;

                typedef boost::tokenizer<boost::char_separator<char> > tokenizer;
                boost::char_separator<char> sep(HPX_INI_PATH_DELIMITER);
                tokenizer tokens(component_path, sep);
                boost::system::error_code fsec;
                for(tokenizer::iterator it = tokens.begin(); it != tokens.end(); ++it)
                {
                    lib = hpx::util::create_path(*it);
                    fs::path lib_path =
                        lib / std::string(HPX_MAKE_DLL_STRING(component));
                    if(fs::exists(lib_path, fsec))
                    {
                        break;
                    }
                    lib.clear();
                }

                if (sect.get_entry(""static"", ""0"") == ""1"") {
                    // FIXME: implement statically linked plugins
                    HPX_THROW_EXCEPTION(service_unavailable,
                        ""runtime_support::load_plugins"",
                        ""static linking configuration does not support static ""
                        ""loading of plugin '"" + instance + ""'"");
                }
                else {
#if defined(HPX_HAVE_STATIC_LINKING)
                    HPX_THROW_EXCEPTION(service_unavailable,
                        ""runtime_support::load_plugins"",
                        ""static linking configuration does not support dynamic ""
                        ""loading of plugin '"" + instance + ""'"");
#else
                    // first, try using the path as the full path to the library
                    load_plugin_dynamic(ini, instance, component, lib,
                        isenabled, options, startup_handled);
#endif
                }
            }
            catch (hpx::exception const& e) {
                LRT_(warning) << ""caught exception while loading "" << instance
                              << "", "" << e.get_error_code().get_message()
                              << "": "" << e.what();
                if (e.get_error_code().value() == hpx::commandline_option_error)
                {
                    std::cerr << ""runtime_support::load_plugins: ""
                              << ""invalid command line option(s) to ""
                              << instance << "" component: "" << e.what()
                              << std::endl;
                }
            }
        } // for
        return true;
    }

#if !defined(HPX_HAVE_STATIC_LINKING)
    bool runtime_support::load_plugin(hpx::util::plugin::dll& d,
        util::section& ini,
        std::string const& instance, std::string const& plugin,
        boost::filesystem::path const& lib, bool isenabled,
        boost::program_options::options_description& options,
        std::set<std::string>& startup_handled)
    {
        try {
            // initialize the factory instance using the preferences from the
            // ini files
            util::section const* glob_ini = nullptr;
            if (ini.has_section(""settings""))
                glob_ini = ini.get_section(""settings"");

            util::section const* plugin_ini = nullptr;
            std::string plugin_section(""hpx.plugins."" + instance);
            if (ini.has_section(plugin_section))
                plugin_ini = ini.get_section(plugin_section);

            error_code ec(lightweight);
            if (nullptr == plugin_ini ||
                ""0"" == plugin_ini->get_entry(""no_factory"", ""0""))
            {
                // get the factory
                hpx::util::plugin::plugin_factory<plugins::plugin_factory_base>
                    pf (d, ""factory"");

                // create the component factory object, if not disabled
                std::shared_ptr<plugins::plugin_factory_base> factory (
                    pf.create(instance, ec, glob_ini, plugin_ini, isenabled));
                if (!ec)
                {
                    // store component factory and module for later use
                    plugin_factory_type data(factory, d, isenabled);
                    std::pair<plugin_map_type::iterator, bool> p =
                        plugins_.insert(plugin_map_type::value_type(instance, data));

                    if (!p.second) {
                        LRT_(fatal) << ""duplicate plugin type: "" << instance;
                        return false;
                    }

                    LRT_(info) << ""dynamic loading succeeded: "" << lib.string()
                               << "": "" << instance;
                }
                else
                {
                    LRT_(warning) << ""dynamic loading of plugin factory failed: ""
                        << lib.string() << "": "" << instance << "": ""
                        << get_error_what(ec);
                }
            }

            // make sure startup/shutdown registration is called once for each
            // module, same for plugins
            if (startup_handled.find(d.get_name()) == startup_handled.end()) {
                startup_handled.insert(d.get_name());
                load_commandline_options(d, options, ec);
                if (ec) ec = error_code(lightweight);
                load_startup_shutdown_functions(d, ec);
            }
        }
        catch (hpx::exception const&) {
            throw;
        }
        catch (std::logic_error const& e) {
            LRT_(warning) << ""dynamic loading failed: "" << lib.string()
                          << "": "" << instance << "": "" << e.what();
            return false;
        }
        catch (std::exception const& e) {
            LRT_(warning) << ""dynamic loading failed: "" << lib.string()
                          << "": "" << instance << "": "" << e.what();
            return false;
        }
        return true;
    }

    bool runtime_support::load_plugin_dynamic(util::section& ini,
        std::string const& instance, std::string const& plugin,
        boost::filesystem::path lib, bool isenabled,
        boost::program_options::options_description& options,
        std::set<std::string>& startup_handled)
    {
        modules_map_type::iterator it = modules_.find(HPX_MANGLE_STRING(plugin));
        if (it != modules_.cend())
        {
            // use loaded module, instantiate the requested factory
            return load_plugin((*it).second, ini, instance, plugin, lib,
                isenabled, options, startup_handled);
        }

        // get the handle of the library
        error_code ec(lightweight);
        hpx::util::plugin::dll d(lib.string(), HPX_MANGLE_STRING(plugin));
        d.load_library(ec);
        if (ec) {
            // build path to component to load
            std::string libname(HPX_MAKE_DLL_STRING(plugin));
            lib /= hpx::util::create_path(libname);
            d.load_library(ec);
            if (ec) {
                LRT_(warning) << ""dynamic loading failed: "" << lib.string()
                                << "": "" << instance << "": "" << get_error_what(ec);
                return false;   // next please :-P
            }
        }

        // now, instantiate the requested factory
        if (!load_plugin(d, ini, instance, plugin, lib, isenabled, options,
                startup_handled))
        {
            return false;   // next please :-P
        }

        modules_.insert(std::make_pair(HPX_MANGLE_STRING(plugin), d));
        return true;    // plugin got loaded
    }
#endif
}}}

",16314,True,2799.3053801262718,median
"#include ""optimizer/physical_operators.h""

#include <algorithm>
#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

#include ""catalog/index_schema.h""
#include ""catalog/schema.h""
#include ""common/macros.h""
#include ""optimizer/operator_visitor.h""
#include ""parser/expression/abstract_expression.h""

namespace noisepage::optimizer {

//===--------------------------------------------------------------------===//
// TableFreeScan
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *TableFreeScan::Copy() const { return new TableFreeScan(*this); }

Operator TableFreeScan::Make() {
  auto *scan = new TableFreeScan();
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(scan));
}

bool TableFreeScan::operator==(const BaseOperatorNodeContents &r) {
  return (r.GetOpType() == OpType::TABLEFREESCAN);
  // Again, there isn't any internal data so I guess we're always equal!
}

common::hash_t TableFreeScan::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  // I guess every TableFreeScan object hashes to the same thing?
  return hash;
}

//===--------------------------------------------------------------------===//
// SeqScan
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *SeqScan::Copy() const { return new SeqScan(*this); }

Operator SeqScan::Make(catalog::db_oid_t database_oid, catalog::table_oid_t table_oid,
                       std::vector<AnnotatedExpression> &&predicates, parser::AliasType table_alias,
                       bool is_for_update) {
  auto *scan = new SeqScan();
  scan->database_oid_ = database_oid;
  scan->table_oid_ = table_oid;
  scan->predicates_ = std::move(predicates);
  scan->is_for_update_ = is_for_update;
  scan->table_alias_ = std::move(table_alias);
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(scan));
}

bool SeqScan::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::SEQSCAN) return false;
  const SeqScan &node = *dynamic_cast<const SeqScan *>(&r);
  if (database_oid_ != node.database_oid_) return false;
  if (table_oid_ != node.table_oid_) return false;
  if (predicates_.size() != node.predicates_.size()) return false;
  for (size_t i = 0; i < predicates_.size(); i++) {
    if (predicates_[i].GetExpr() != node.predicates_[i].GetExpr()) return false;
  }
  if (table_alias_ != node.table_alias_) return false;
  return is_for_update_ == node.is_for_update_;
}

common::hash_t SeqScan::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(database_oid_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(table_oid_));
  hash = common::HashUtil::CombineHashInRange(hash, predicates_.begin(), predicates_.end());
  hash = common::HashUtil::CombineHashes(hash, std::hash<parser::AliasType>{}(table_alias_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(is_for_update_));
  return hash;
}

//===--------------------------------------------------------------------===//
// IndexScan
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *IndexScan::Copy() const { return new IndexScan(*this); }

Operator IndexScan::Make(catalog::db_oid_t database_oid, catalog::table_oid_t tbl_oid, catalog::index_oid_t index_oid,
                         std::vector<AnnotatedExpression> &&predicates, bool is_for_update,
                         planner::IndexScanType scan_type,
                         std::unordered_map<catalog::indexkeycol_oid_t, std::vector<planner::IndexExpression>> bounds,
                         bool cover_all_columns) {
  auto *scan = new IndexScan();
  scan->database_oid_ = database_oid;
  scan->tbl_oid_ = tbl_oid;
  scan->index_oid_ = index_oid;
  scan->is_for_update_ = is_for_update;
  scan->predicates_ = std::move(predicates);
  scan->scan_type_ = scan_type;
  scan->bounds_ = std::move(bounds);
  scan->cover_all_columns_ = cover_all_columns;
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(scan));
}

bool IndexScan::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::INDEXSCAN) return false;
  const IndexScan &node = *dynamic_cast<const IndexScan *>(&r);
  if (database_oid_ != node.database_oid_ || index_oid_ != node.index_oid_ || tbl_oid_ != node.tbl_oid_ ||
      predicates_.size() != node.predicates_.size() || is_for_update_ != node.is_for_update_ ||
      scan_type_ != node.scan_type_)
    return false;

  for (size_t i = 0; i < predicates_.size(); i++) {
    if (predicates_[i].GetExpr() != node.predicates_[i].GetExpr()) return false;
  }

  if (bounds_.size() != node.bounds_.size()) return false;
  for (const auto &bound : bounds_) {
    if (node.bounds_.find(bound.first) == node.bounds_.end()) return false;

    std::vector<planner::IndexExpression> exprs = bound.second;
    std::vector<planner::IndexExpression> o_exprs = node.bounds_.find(bound.first)->second;
    if (exprs.size() != o_exprs.size()) return false;
    for (size_t idx = 0; idx < exprs.size(); idx++) {
      if (exprs[idx] == nullptr && o_exprs[idx] == nullptr) continue;
      if (exprs[idx] == nullptr && o_exprs[idx] != nullptr) return false;
      if (exprs[idx] != nullptr && o_exprs[idx] == nullptr) return false;
      if (*exprs[idx] != *o_exprs[idx]) return false;
    }
  }
  return true;
}

common::hash_t IndexScan::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(database_oid_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(tbl_oid_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(index_oid_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(is_for_update_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(scan_type_));
  for (auto &pred : predicates_) {
    auto expr = pred.GetExpr();
    if (expr)
      hash = common::HashUtil::SumHashes(hash, expr->Hash());
    else
      hash = common::HashUtil::SumHashes(hash, BaseOperatorNodeContents::Hash());
  }

  for (const auto &bound : bounds_) {
    hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(bound.first));
    for (auto expr : bound.second) {
      if (expr != nullptr) {
        hash = common::HashUtil::CombineHashes(hash, expr->Hash());
      }
    }
  }
  return hash;
}

//===--------------------------------------------------------------------===//
// External file scan
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *ExternalFileScan::Copy() const { return new ExternalFileScan(*this); }

Operator ExternalFileScan::Make(parser::ExternalFileFormat format, std::string file_name, char delimiter, char quote,
                                char escape) {
  auto *get = new ExternalFileScan();
  get->format_ = format;
  get->file_name_ = std::move(file_name);
  get->delimiter_ = delimiter;
  get->quote_ = quote;
  get->escape_ = escape;
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(get));
}

bool ExternalFileScan::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::EXTERNALFILESCAN) return false;
  const auto &get = *dynamic_cast<const ExternalFileScan *>(&r);
  return (format_ == get.format_ && file_name_ == get.file_name_ && delimiter_ == get.delimiter_ &&
          quote_ == get.quote_ && escape_ == get.escape_);
}

common::hash_t ExternalFileScan::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(format_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(file_name_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(delimiter_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(quote_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(escape_));
  return hash;
}

//===--------------------------------------------------------------------===//
// Query derived scan
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *QueryDerivedScan::Copy() const { return new QueryDerivedScan(*this); }

Operator QueryDerivedScan::Make(
    parser::AliasType table_alias,
    std::unordered_map<parser::AliasType, common::ManagedPointer<parser::AbstractExpression>> &&alias_to_expr_map) {
  auto *get = new QueryDerivedScan();
  get->table_alias_ = std::move(table_alias);
  get->alias_to_expr_map_ = alias_to_expr_map;
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(get));
}

bool QueryDerivedScan::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::QUERYDERIVEDSCAN) return false;
  const QueryDerivedScan &node = *static_cast<const QueryDerivedScan *>(&r);
  if (table_alias_ != node.table_alias_) return false;
  return alias_to_expr_map_ == node.alias_to_expr_map_;
}

common::hash_t QueryDerivedScan::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, std::hash<parser::AliasType>{}(table_alias_));
  for (auto &iter : alias_to_expr_map_) {
    hash = common::HashUtil::CombineHashes(hash, std::hash<parser::AliasType>{}(iter.first));
    hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(iter.second));
  }
  return hash;
}

//===--------------------------------------------------------------------===//
// OrderBy
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *OrderBy::Copy() const { return new OrderBy(*this); }

Operator OrderBy::Make() {
  auto *order_by = new OrderBy();
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(order_by));
}

bool OrderBy::operator==(const BaseOperatorNodeContents &r) {
  return (r.GetOpType() == OpType::ORDERBY);
  // Again, there isn't any internal data so I guess we're always equal!
}

common::hash_t OrderBy::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  // I guess every OrderBy object hashes to the same thing?
  return hash;
}

//===--------------------------------------------------------------------===//
// PhysicalLimit
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *Limit::Copy() const { return new Limit(*this); }

Operator Limit::Make(size_t offset, size_t limit,
                     std::vector<common::ManagedPointer<parser::AbstractExpression>> &&sort_columns,
                     std::vector<optimizer::OrderByOrderingType> &&sort_directions) {
  auto *limit_op = new Limit();
  limit_op->offset_ = offset;
  limit_op->limit_ = limit;
  limit_op->sort_exprs_ = std::move(sort_columns);
  limit_op->sort_directions_ = std::move(sort_directions);
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(limit_op));
}

bool Limit::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::LIMIT) return false;
  const Limit &node = *static_cast<const Limit *>(&r);
  if (offset_ != node.offset_) return false;
  if (limit_ != node.limit_) return false;
  if (sort_exprs_ != node.sort_exprs_) return false;
  if (sort_directions_ != node.sort_directions_) return false;
  return (true);
}

common::hash_t Limit::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(offset_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(limit_));
  hash = common::HashUtil::CombineHashInRange(hash, sort_exprs_.begin(), sort_exprs_.end());
  hash = common::HashUtil::CombineHashInRange(hash, sort_directions_.begin(), sort_directions_.end());
  return hash;
}

//===--------------------------------------------------------------------===//
// InnerIndexJoin
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *InnerIndexJoin::Copy() const { return new InnerIndexJoin(*this); }

Operator InnerIndexJoin::Make(
    catalog::table_oid_t tbl_oid, catalog::index_oid_t idx_oid, planner::IndexScanType scan_type,
    std::unordered_map<catalog::indexkeycol_oid_t, std::vector<planner::IndexExpression>> join_keys,
    std::vector<AnnotatedExpression> join_predicates) {
  auto *join = new InnerIndexJoin();
  join->tbl_oid_ = tbl_oid;
  join->idx_oid_ = idx_oid;
  join->join_keys_ = std::move(join_keys);
  join->join_predicates_ = std::move(join_predicates);
  join->scan_type_ = scan_type;
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(join));
}

common::hash_t InnerIndexJoin::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::SumHashes(hash, common::HashUtil::Hash(tbl_oid_));
  hash = common::HashUtil::SumHashes(hash, common::HashUtil::Hash(idx_oid_));
  hash = common::HashUtil::SumHashes(hash, common::HashUtil::Hash(scan_type_));

  std::vector<catalog::indexkeycol_oid_t> cols;
  for (auto &join_key : join_keys_) {
    cols.push_back(join_key.first);
  }

  std::sort(cols.begin(), cols.end());
  for (auto &col : cols) {
    hash = common::HashUtil::SumHashes(hash, common::HashUtil::Hash(col));
    for (auto &expr : join_keys_.find(col)->second) {
      if (expr == nullptr)
        hash = common::HashUtil::SumHashes(hash, 0);
      else
        hash = common::HashUtil::SumHashes(hash, expr->Hash());
    }
  }

  for (auto &pred : join_predicates_) {
    auto expr = pred.GetExpr();
    if (expr)
      hash = common::HashUtil::SumHashes(hash, expr->Hash());
    else
      hash = common::HashUtil::SumHashes(hash, BaseOperatorNodeContents::Hash());
  }
  return hash;
}

bool InnerIndexJoin::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::INNERINDEXJOIN) return false;
  const InnerIndexJoin &node = *dynamic_cast<const InnerIndexJoin *>(&r);
  if (tbl_oid_ != node.tbl_oid_) return false;
  if (idx_oid_ != node.idx_oid_) return false;
  if (scan_type_ != node.scan_type_) return false;

  if (join_predicates_.size() != node.join_predicates_.size()) return false;
  if (join_predicates_ != node.join_predicates_) return false;

  if (join_keys_.size() != node.join_keys_.size()) return false;
  for (auto &join_key : join_keys_) {
    if (node.join_keys_.find(join_key.first) == node.join_keys_.end()) return false;

    auto &expr = join_key.second;
    auto &other = node.join_keys_.find(join_key.first)->second;
    if (expr.size() != other.size()) return false;
    for (size_t i = 0; i < expr.size(); i++) {
      if (expr[i] == nullptr && other[i] == nullptr) continue;
      if ((expr[i] != nullptr && other[i] == nullptr) || (expr[i] == nullptr && other[i] != nullptr)) return false;
      if (*(expr[i]) != *(other[i])) return false;
    }
  }

  return true;
}

//===--------------------------------------------------------------------===//
// InnerNLJoin
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *InnerNLJoin::Copy() const { return new InnerNLJoin(*this); }

Operator InnerNLJoin::Make(std::vector<AnnotatedExpression> &&join_predicates) {
  auto *join = new InnerNLJoin();
  join->join_predicates_ = std::move(join_predicates);
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(join));
}

common::hash_t InnerNLJoin::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  for (auto &pred : join_predicates_) {
    auto expr = pred.GetExpr();
    if (expr)
      hash = common::HashUtil::SumHashes(hash, expr->Hash());
    else
      hash = common::HashUtil::SumHashes(hash, BaseOperatorNodeContents::Hash());
  }
  return hash;
}

bool InnerNLJoin::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::INNERNLJOIN) return false;
  const InnerNLJoin &node = *dynamic_cast<const InnerNLJoin *>(&r);
  if (join_predicates_.size() != node.join_predicates_.size()) return false;
  if (join_predicates_ != node.join_predicates_) return false;
  return true;
}

//===--------------------------------------------------------------------===//
// LeftNLJoin
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *LeftNLJoin::Copy() const { return new LeftNLJoin(*this); }

Operator LeftNLJoin::Make(common::ManagedPointer<parser::AbstractExpression> join_predicate) {
  auto *join = new LeftNLJoin();
  join->join_predicate_ = join_predicate;
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(join));
}

common::hash_t LeftNLJoin::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, join_predicate_->Hash());
  return hash;
}

bool LeftNLJoin::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::LEFTNLJOIN) return false;
  const LeftNLJoin &node = *static_cast<const LeftNLJoin *>(&r);
  return (*join_predicate_ == *(node.join_predicate_));
}
//===--------------------------------------------------------------------===//
// RightNLJoin
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *RightNLJoin::Copy() const { return new RightNLJoin(*this); }

Operator RightNLJoin::Make(common::ManagedPointer<parser::AbstractExpression> join_predicate) {
  auto *join = new RightNLJoin();
  join->join_predicate_ = join_predicate;
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(join));
}

common::hash_t RightNLJoin::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, join_predicate_->Hash());
  return hash;
}

bool RightNLJoin::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::RIGHTNLJOIN) return false;
  const RightNLJoin &node = *static_cast<const RightNLJoin *>(&r);
  return (*join_predicate_ == *(node.join_predicate_));
}

//===--------------------------------------------------------------------===//
// OuterNLJoin
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *OuterNLJoin::Copy() const { return new OuterNLJoin(*this); }

Operator OuterNLJoin::Make(common::ManagedPointer<parser::AbstractExpression> join_predicate) {
  auto *join = new OuterNLJoin();
  join->join_predicate_ = join_predicate;
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(join));
}

common::hash_t OuterNLJoin::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, join_predicate_->Hash());
  return hash;
}

bool OuterNLJoin::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::OUTERNLJOIN) return false;
  const OuterNLJoin &node = *static_cast<const OuterNLJoin *>(&r);
  return (*join_predicate_ == *(node.join_predicate_));
}

//===--------------------------------------------------------------------===//
// InnerHashJoin
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *InnerHashJoin::Copy() const { return new InnerHashJoin(*this); }

Operator InnerHashJoin::Make(std::vector<AnnotatedExpression> &&join_predicates,
                             std::vector<common::ManagedPointer<parser::AbstractExpression>> &&left_keys,
                             std::vector<common::ManagedPointer<parser::AbstractExpression>> &&right_keys) {
  auto *join = new InnerHashJoin();
  join->join_predicates_ = std::move(join_predicates);
  join->left_keys_ = std::move(left_keys);
  join->right_keys_ = std::move(right_keys);
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(join));
}

common::hash_t InnerHashJoin::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  for (auto &expr : left_keys_) hash = common::HashUtil::CombineHashes(hash, expr->Hash());
  for (auto &expr : right_keys_) hash = common::HashUtil::CombineHashes(hash, expr->Hash());
  for (auto &pred : join_predicates_) {
    auto expr = pred.GetExpr();
    if (expr)
      hash = common::HashUtil::SumHashes(hash, expr->Hash());
    else
      hash = common::HashUtil::SumHashes(hash, BaseOperatorNodeContents::Hash());
  }
  return hash;
}

bool InnerHashJoin::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::INNERHASHJOIN) return false;
  const InnerHashJoin &node = *dynamic_cast<const InnerHashJoin *>(&r);
  if (left_keys_.size() != node.left_keys_.size() || right_keys_.size() != node.right_keys_.size() ||
      join_predicates_.size() != node.join_predicates_.size())
    return false;
  if (join_predicates_ != node.join_predicates_) return false;
  for (size_t i = 0; i < left_keys_.size(); i++) {
    if (*(left_keys_[i]) != *(node.left_keys_[i])) return false;
  }
  for (size_t i = 0; i < right_keys_.size(); i++) {
    if (*(right_keys_[i]) != *(node.right_keys_[i])) return false;
  }
  return true;
}

//===--------------------------------------------------------------------===//
// LeftSemiHashJoin
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *LeftSemiHashJoin::Copy() const { return new LeftSemiHashJoin(*this); }

Operator LeftSemiHashJoin::Make(std::vector<AnnotatedExpression> &&join_predicates,
                                std::vector<common::ManagedPointer<parser::AbstractExpression>> &&left_keys,
                                std::vector<common::ManagedPointer<parser::AbstractExpression>> &&right_keys) {
  auto *join = new LeftSemiHashJoin();
  join->join_predicates_ = std::move(join_predicates);
  join->left_keys_ = std::move(left_keys);
  join->right_keys_ = std::move(right_keys);
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(join));
}

common::hash_t LeftSemiHashJoin::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  for (auto &expr : left_keys_) hash = common::HashUtil::CombineHashes(hash, expr->Hash());
  for (auto &expr : right_keys_) hash = common::HashUtil::CombineHashes(hash, expr->Hash());
  for (auto &pred : join_predicates_) {
    auto expr = pred.GetExpr();
    if (expr)
      hash = common::HashUtil::SumHashes(hash, expr->Hash());
    else
      hash = common::HashUtil::SumHashes(hash, BaseOperatorNodeContents::Hash());
  }
  return hash;
}

bool LeftSemiHashJoin::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::LEFTSEMIHASHJOIN) return false;
  const LeftSemiHashJoin &node = *dynamic_cast<const LeftSemiHashJoin *>(&r);
  if (left_keys_.size() != node.left_keys_.size() || right_keys_.size() != node.right_keys_.size() ||
      join_predicates_.size() != node.join_predicates_.size())
    return false;
  if (join_predicates_ != node.join_predicates_) return false;
  for (size_t i = 0; i < left_keys_.size(); i++) {
    if (*(left_keys_[i]) != *(node.left_keys_[i])) return false;
  }
  for (size_t i = 0; i < right_keys_.size(); i++) {
    if (*(right_keys_[i]) != *(node.right_keys_[i])) return false;
  }
  return true;
}

//===--------------------------------------------------------------------===//
// LeftHashJoin
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *LeftHashJoin::Copy() const { return new LeftHashJoin(*this); }

Operator LeftHashJoin::Make(std::vector<AnnotatedExpression> &&join_predicates,
                            std::vector<common::ManagedPointer<parser::AbstractExpression>> &&left_keys,
                            std::vector<common::ManagedPointer<parser::AbstractExpression>> &&right_keys) {
  auto *join = new LeftHashJoin();
  join->join_predicates_ = std::move(join_predicates);
  join->left_keys_ = std::move(left_keys);
  join->right_keys_ = std::move(right_keys);
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(join));
}

common::hash_t LeftHashJoin::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  for (auto &expr : left_keys_) hash = common::HashUtil::CombineHashes(hash, expr->Hash());
  for (auto &expr : right_keys_) hash = common::HashUtil::CombineHashes(hash, expr->Hash());
  for (auto &pred : join_predicates_) {
    auto expr = pred.GetExpr();
    if (expr)
      hash = common::HashUtil::SumHashes(hash, expr->Hash());
    else
      hash = common::HashUtil::SumHashes(hash, BaseOperatorNodeContents::Hash());
  }
  return hash;
}

bool LeftHashJoin::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::LEFTHASHJOIN) return false;
  const LeftHashJoin &node = *dynamic_cast<const LeftHashJoin *>(&r);
  if (left_keys_.size() != node.left_keys_.size() || right_keys_.size() != node.right_keys_.size() ||
      join_predicates_.size() != node.join_predicates_.size())
    return false;
  if (join_predicates_ != node.join_predicates_) return false;
  for (size_t i = 0; i < left_keys_.size(); i++) {
    if (*(left_keys_[i]) != *(node.left_keys_[i])) return false;
  }
  for (size_t i = 0; i < right_keys_.size(); i++) {
    if (*(right_keys_[i]) != *(node.right_keys_[i])) return false;
  }
  return true;
}

//===--------------------------------------------------------------------===//
// RightHashJoin
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *RightHashJoin::Copy() const { return new RightHashJoin(*this); }

Operator RightHashJoin::Make(common::ManagedPointer<parser::AbstractExpression> join_predicate) {
  auto *join = new RightHashJoin();
  join->join_predicate_ = join_predicate;
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(join));
}

common::hash_t RightHashJoin::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, join_predicate_->Hash());
  return hash;
}

bool RightHashJoin::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::RIGHTHASHJOIN) return false;
  const RightHashJoin &node = *static_cast<const RightHashJoin *>(&r);
  return (*join_predicate_ == *(node.join_predicate_));
}

//===--------------------------------------------------------------------===//
// OuterHashJoin
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *OuterHashJoin::Copy() const { return new OuterHashJoin(*this); }

Operator OuterHashJoin::Make(common::ManagedPointer<parser::AbstractExpression> join_predicate) {
  auto *join = new OuterHashJoin();
  join->join_predicate_ = join_predicate;
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(join));
}

common::hash_t OuterHashJoin::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, join_predicate_->Hash());
  return hash;
}

bool OuterHashJoin::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::OUTERHASHJOIN) return false;
  const OuterHashJoin &node = *static_cast<const OuterHashJoin *>(&r);
  return (*join_predicate_ == *(node.join_predicate_));
}

//===--------------------------------------------------------------------===//
// Insert
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *Insert::Copy() const { return new Insert(*this); }

Operator Insert::Make(catalog::db_oid_t database_oid, catalog::table_oid_t table_oid,
                      std::vector<catalog::col_oid_t> &&columns,
                      std::vector<std::vector<common::ManagedPointer<parser::AbstractExpression>>> &&values) {
#ifndef NDEBUG
  // We need to check whether the number of values for each insert vector
  // matches the number of columns
  for (const auto &insert_vals : values) {
    NOISEPAGE_ASSERT(columns.size() == insert_vals.size(), ""Mismatched number of columns and values"");
  }
#endif

  auto *op = new Insert();
  op->database_oid_ = database_oid;
  op->table_oid_ = table_oid;
  op->columns_ = std::move(columns);
  op->values_ = std::move(values);
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(op));
}

common::hash_t Insert::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(database_oid_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(table_oid_));
  hash = common::HashUtil::CombineHashInRange(hash, columns_.begin(), columns_.end());

  // Perform a deep hash of the values
  for (const auto &insert_vals : values_) {
    hash = common::HashUtil::CombineHashInRange(hash, insert_vals.begin(), insert_vals.end());
  }

  return hash;
}

bool Insert::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::INSERT) return false;
  const Insert &node = *dynamic_cast<const Insert *>(&r);
  if (database_oid_ != node.database_oid_) return false;
  if (table_oid_ != node.table_oid_) return false;
  if (columns_ != node.columns_) return false;
  if (values_ != node.values_) return false;
  return (true);
}

//===--------------------------------------------------------------------===//
// InsertSelect
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *InsertSelect::Copy() const { return new InsertSelect(*this); }

Operator InsertSelect::Make(catalog::db_oid_t database_oid, catalog::table_oid_t table_oid,
                            std::vector<catalog::col_oid_t> &&columns) {
  auto *insert_op = new InsertSelect();
  insert_op->database_oid_ = database_oid;
  insert_op->table_oid_ = table_oid;
  insert_op->columns_ = std::move(columns);
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(insert_op));
}

common::hash_t InsertSelect::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(database_oid_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(table_oid_));
  return hash;
}

bool InsertSelect::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::INSERTSELECT) return false;
  const InsertSelect &node = *dynamic_cast<const InsertSelect *>(&r);
  if (database_oid_ != node.database_oid_) return false;
  if (table_oid_ != node.table_oid_) return false;
  return (true);
}

//===--------------------------------------------------------------------===//
// Delete
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *Delete::Copy() const { return new Delete(*this); }

Operator Delete::Make(catalog::db_oid_t database_oid, std::string table_alias, catalog::table_oid_t table_oid) {
  auto *delete_op = new Delete();
  delete_op->database_oid_ = database_oid;
  delete_op->table_alias_ = std::move(table_alias);
  delete_op->table_oid_ = table_oid;
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(delete_op));
}

common::hash_t Delete::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(database_oid_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(table_alias_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(table_oid_));
  return hash;
}

bool Delete::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::DELETE) return false;
  const Delete &node = *dynamic_cast<const Delete *>(&r);
  if (database_oid_ != node.database_oid_) return false;
  return table_oid_ == node.table_oid_;
}

//===--------------------------------------------------------------------===//
// Update
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *Update::Copy() const { return new Update(*this); }

Operator Update::Make(catalog::db_oid_t database_oid, std::string table_alias, catalog::table_oid_t table_oid,
                      std::vector<common::ManagedPointer<parser::UpdateClause>> &&updates) {
  auto *op = new Update();
  op->database_oid_ = database_oid;
  op->table_alias_ = std::move(table_alias);
  op->table_oid_ = table_oid;
  op->updates_ = updates;
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(op));
}

common::hash_t Update::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(database_oid_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(table_alias_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(table_oid_));
  hash = common::HashUtil::CombineHashInRange(hash, updates_.begin(), updates_.end());
  return hash;
}

bool Update::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::UPDATE) return false;
  const Update &node = *dynamic_cast<const Update *>(&r);
  if (database_oid_ != node.database_oid_) return false;
  if (table_oid_ != node.table_oid_) return false;
  if (updates_ != node.updates_) return false;
  return table_alias_ == node.table_alias_;
}

//===--------------------------------------------------------------------===//
// ExportExternalFile
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *ExportExternalFile::Copy() const { return new ExportExternalFile(*this); }

Operator ExportExternalFile::Make(parser::ExternalFileFormat format, std::string file_name, char delimiter, char quote,
                                  char escape) {
  auto *export_op = new ExportExternalFile();
  export_op->format_ = format;
  export_op->file_name_ = std::move(file_name);
  export_op->delimiter_ = delimiter;
  export_op->quote_ = quote;
  export_op->escape_ = escape;
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(export_op));
}

bool ExportExternalFile::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::EXPORTEXTERNALFILE) return false;
  const auto &export_op = *dynamic_cast<const ExportExternalFile *>(&r);
  return (format_ == export_op.format_ && file_name_ == export_op.file_name_ && delimiter_ == export_op.delimiter_ &&
          quote_ == export_op.quote_ && escape_ == export_op.escape_);
}

common::hash_t ExportExternalFile::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(format_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(file_name_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(delimiter_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(quote_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(escape_));
  return hash;
}

//===--------------------------------------------------------------------===//
// HashGroupBy
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *HashGroupBy::Copy() const { return new HashGroupBy(*this); }

Operator HashGroupBy::Make(std::vector<common::ManagedPointer<parser::AbstractExpression>> &&columns,
                           std::vector<AnnotatedExpression> &&having) {
  auto *agg = new HashGroupBy();
  agg->columns_ = std::move(columns);
  agg->having_ = std::move(having);
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(agg));
}

bool HashGroupBy::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::HASHGROUPBY) return false;
  const HashGroupBy &node = *static_cast<const HashGroupBy *>(&r);
  if (having_.size() != node.having_.size() || columns_.size() != node.columns_.size()) return false;
  for (size_t i = 0; i < having_.size(); i++) {
    if (having_[i] != node.having_[i]) return false;
  }
  for (size_t i = 0; i < columns_.size(); i++) {
    if (*(columns_[i]) != *(node.columns_[i])) return false;
  }
  return true;
}

common::hash_t HashGroupBy::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  for (auto &pred : having_) {
    auto expr = pred.GetExpr();
    if (expr)
      hash = common::HashUtil::SumHashes(hash, expr->Hash());
    else
      hash = common::HashUtil::SumHashes(hash, BaseOperatorNodeContents::Hash());
  }
  for (auto &expr : columns_) hash = common::HashUtil::SumHashes(hash, expr->Hash());
  return hash;
}

//===--------------------------------------------------------------------===//
// SortGroupBy
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *SortGroupBy::Copy() const { return new SortGroupBy(*this); }

Operator SortGroupBy::Make(std::vector<common::ManagedPointer<parser::AbstractExpression>> &&columns,
                           std::vector<AnnotatedExpression> &&having) {
  auto *agg = new SortGroupBy();
  agg->columns_ = std::move(columns);
  agg->having_ = move(having);
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(agg));
}

bool SortGroupBy::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::SORTGROUPBY) return false;
  const SortGroupBy &node = *static_cast<const SortGroupBy *>(&r);
  if (having_.size() != node.having_.size() || columns_.size() != node.columns_.size()) return false;
  for (size_t i = 0; i < having_.size(); i++) {
    if (having_[i] != node.having_[i]) return false;
  }
  for (size_t i = 0; i < columns_.size(); i++) {
    if (*(columns_[i]) != *(node.columns_[i])) return false;
  }
  return true;
}

common::hash_t SortGroupBy::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  for (auto &pred : having_) {
    auto expr = pred.GetExpr();
    if (expr)
      hash = common::HashUtil::SumHashes(hash, expr->Hash());
    else
      hash = common::HashUtil::SumHashes(hash, BaseOperatorNodeContents::Hash());
  }
  for (auto &expr : columns_) hash = common::HashUtil::SumHashes(hash, expr->Hash());
  return hash;
}

//===--------------------------------------------------------------------===//
// Aggregate
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *Aggregate::Copy() const { return new Aggregate(*this); }

Operator Aggregate::Make() {
  auto *agg = new Aggregate();
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(agg));
}

bool Aggregate::operator==(const BaseOperatorNodeContents &r) {
  return (r.GetOpType() == OpType::AGGREGATE);
  // Again, there isn't any internal data so I guess we're always equal!
}

common::hash_t Aggregate::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  // I guess every Aggregate object hashes to the same thing?
  return hash;
}

//===--------------------------------------------------------------------===//
// CreateDatabase
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *CreateDatabase::Copy() const { return new CreateDatabase(*this); }

Operator CreateDatabase::Make(std::string database_name) {
  auto *op = new CreateDatabase();
  op->database_name_ = std::move(database_name);
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(op));
}

common::hash_t CreateDatabase::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(database_name_));
  return hash;
}

bool CreateDatabase::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::CREATEDATABASE) return false;
  const CreateDatabase &node = *dynamic_cast<const CreateDatabase *>(&r);
  return node.database_name_ == database_name_;
}

//===--------------------------------------------------------------------===//
// CreateTable
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *CreateTable::Copy() const { return new CreateTable(*this); }

Operator CreateTable::Make(catalog::namespace_oid_t namespace_oid, std::string table_name,
                           std::vector<common::ManagedPointer<parser::ColumnDefinition>> &&columns,
                           std::vector<common::ManagedPointer<parser::ColumnDefinition>> &&foreign_keys) {
  auto *op = new CreateTable();
  op->namespace_oid_ = namespace_oid;
  op->table_name_ = std::move(table_name);
  op->columns_ = std::move(columns);
  op->foreign_keys_ = std::move(foreign_keys);
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(op));
}

common::hash_t CreateTable::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(namespace_oid_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(table_name_));
  hash = common::HashUtil::CombineHashInRange(hash, columns_.begin(), columns_.end());
  for (const auto &col : columns_) hash = common::HashUtil::CombineHashes(hash, col->Hash());
  for (const auto &fk : foreign_keys_) hash = common::HashUtil::CombineHashes(hash, fk->Hash());
  return hash;
}

bool CreateTable::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::CREATETABLE) return false;
  const CreateTable &node = *dynamic_cast<const CreateTable *>(&r);
  if (namespace_oid_ != node.namespace_oid_) return false;
  if (table_name_ != node.table_name_) return false;
  if (columns_.size() != node.columns_.size()) return false;
  for (size_t i = 0; i < columns_.size(); i++) {
    if (*(columns_[i]) != *(node.columns_[i])) return false;
  }
  if (foreign_keys_.size() != node.foreign_keys_.size()) return false;
  for (size_t i = 0; i < foreign_keys_.size(); i++) {
    if (*(foreign_keys_[i]) != *(node.foreign_keys_[i])) return false;
  }
  return true;
}

//===--------------------------------------------------------------------===//
// CreateIndex
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *CreateIndex::Copy() const {
  std::vector<catalog::IndexSchema::Column> columns;
  for (auto &col : schema_->GetColumns()) {
    columns.emplace_back(col);
  }
  auto schema =
      std::make_unique<catalog::IndexSchema>(std::move(columns), schema_->Type(), schema_->Unique(), schema_->Primary(),
                                             schema_->Exclusion(), schema_->Immediate(), schema_->GetIndexOptions());

  auto op = new CreateIndex();
  op->namespace_oid_ = namespace_oid_;
  op->table_oid_ = table_oid_;
  op->index_name_ = index_name_;
  op->schema_ = std::move(schema);
  return op;
}

Operator CreateIndex::Make(catalog::namespace_oid_t namespace_oid, catalog::table_oid_t table_oid,
                           std::string index_name, std::unique_ptr<catalog::IndexSchema> &&schema) {
  auto *op = new CreateIndex();
  op->namespace_oid_ = namespace_oid;
  op->table_oid_ = table_oid;
  op->index_name_ = std::move(index_name);
  op->schema_ = std::move(schema);
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(op));
}

common::hash_t CreateIndex::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(namespace_oid_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(table_oid_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(index_name_));
  if (schema_ != nullptr) hash = common::HashUtil::CombineHashes(hash, schema_->Hash());
  return hash;
}

bool CreateIndex::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::CREATEINDEX) return false;
  const CreateIndex &node = *dynamic_cast<const CreateIndex *>(&r);
  if (namespace_oid_ != node.namespace_oid_) return false;
  if (table_oid_ != node.table_oid_) return false;
  if (index_name_ != node.index_name_) return false;
  if (schema_ != nullptr && *schema_ != *node.schema_) return false;
  if (schema_ == nullptr && node.schema_ != nullptr) return false;
  return (true);
}

//===--------------------------------------------------------------------===//
// CreateNamespace
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *CreateNamespace::Copy() const { return new CreateNamespace(*this); }

Operator CreateNamespace::Make(std::string namespace_name) {
  auto *op = new CreateNamespace();
  op->namespace_name_ = std::move(namespace_name);
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(op));
}

common::hash_t CreateNamespace::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(namespace_name_));
  return hash;
}

bool CreateNamespace::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::CREATENAMESPACE) return false;
  const CreateNamespace &node = *dynamic_cast<const CreateNamespace *>(&r);
  return node.namespace_name_ == namespace_name_;
}

//===--------------------------------------------------------------------===//
// CreateTrigger
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *CreateTrigger::Copy() const { return new CreateTrigger(*this); }

Operator CreateTrigger::Make(catalog::db_oid_t database_oid, catalog::namespace_oid_t namespace_oid,
                             catalog::table_oid_t table_oid, std::string trigger_name,
                             std::vector<std::string> &&trigger_funcnames, std::vector<std::string> &&trigger_args,
                             std::vector<catalog::col_oid_t> &&trigger_columns,
                             common::ManagedPointer<parser::AbstractExpression> &&trigger_when, int16_t trigger_type) {
  auto *op = new CreateTrigger();
  op->database_oid_ = database_oid;
  op->namespace_oid_ = namespace_oid;
  op->table_oid_ = table_oid;
  op->trigger_name_ = std::move(trigger_name);
  op->trigger_funcnames_ = std::move(trigger_funcnames);
  op->trigger_args_ = std::move(trigger_args);
  op->trigger_columns_ = std::move(trigger_columns);
  op->trigger_when_ = trigger_when;
  op->trigger_type_ = trigger_type;
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(op));
}

common::hash_t CreateTrigger::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(database_oid_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(namespace_oid_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(table_oid_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(trigger_name_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(trigger_type_));
  hash = common::HashUtil::CombineHashes(hash, trigger_when_->Hash());
  hash = common::HashUtil::CombineHashInRange(hash, trigger_funcnames_.begin(), trigger_funcnames_.end());
  hash = common::HashUtil::CombineHashInRange(hash, trigger_args_.begin(), trigger_args_.end());
  hash = common::HashUtil::CombineHashInRange(hash, trigger_columns_.begin(), trigger_columns_.end());
  return hash;
}

bool CreateTrigger::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::CREATETRIGGER) return false;
  const CreateTrigger &node = *dynamic_cast<const CreateTrigger *>(&r);
  if (database_oid_ != node.database_oid_) return false;
  if (namespace_oid_ != node.namespace_oid_) return false;
  if (table_oid_ != node.table_oid_) return false;
  if (trigger_name_ != node.trigger_name_) return false;
  if (trigger_funcnames_ != node.trigger_funcnames_) return false;
  if (trigger_args_ != node.trigger_args_) return false;
  if (trigger_columns_ != node.trigger_columns_) return false;
  if (trigger_type_ != node.trigger_type_) return false;
  if (trigger_when_ == nullptr) return node.trigger_when_ == nullptr;
  return node.trigger_when_ != nullptr && *trigger_when_ == *node.trigger_when_;
}

//===--------------------------------------------------------------------===//
// CreateView
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *CreateView::Copy() const { return new CreateView(*this); }

Operator CreateView::Make(catalog::db_oid_t database_oid, catalog::namespace_oid_t namespace_oid, std::string view_name,
                          common::ManagedPointer<parser::SelectStatement> view_query) {
  auto *op = new CreateView();
  op->database_oid_ = database_oid;
  op->namespace_oid_ = namespace_oid;
  op->view_name_ = std::move(view_name);
  op->view_query_ = view_query;
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(op));
}

common::hash_t CreateView::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(database_oid_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(namespace_oid_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(view_name_));
  if (view_query_ != nullptr) hash = common::HashUtil::CombineHashes(hash, view_query_->Hash());
  return hash;
}

bool CreateView::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::CREATEVIEW) return false;
  const CreateView &node = *dynamic_cast<const CreateView *>(&r);
  if (database_oid_ != node.database_oid_) return false;
  if (namespace_oid_ != node.namespace_oid_) return false;
  if (view_name_ != node.view_name_) return false;
  if (view_query_ == nullptr) return node.view_query_ == nullptr;
  return node.view_query_ != nullptr && *view_query_ == *node.view_query_;
}

//===--------------------------------------------------------------------===//
// CreateFunction
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *CreateFunction::Copy() const { return new CreateFunction(*this); }

Operator CreateFunction::Make(catalog::db_oid_t database_oid, catalog::namespace_oid_t namespace_oid,
                              std::string function_name, parser::PLType language,
                              std::vector<std::string> &&function_body, std::vector<std::string> &&function_param_names,
                              std::vector<parser::BaseFunctionParameter::DataType> &&function_param_types,
                              parser::BaseFunctionParameter::DataType return_type, size_t param_count, bool replace) {
  NOISEPAGE_ASSERT(function_param_names.size() == param_count && function_param_types.size() == param_count,
                   ""Mismatched number of items in vector and number of function parameters"");
  auto *op = new CreateFunction();
  op->database_oid_ = database_oid;
  op->namespace_oid_ = namespace_oid;
  op->function_name_ = std::move(function_name);
  op->function_body_ = std::move(function_body);
  op->function_param_names_ = std::move(function_param_names);
  op->function_param_types_ = std::move(function_param_types);
  op->is_replace_ = replace;
  op->param_count_ = param_count;
  op->return_type_ = return_type;
  op->language_ = language;
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(op));
}

common::hash_t CreateFunction::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(database_oid_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(namespace_oid_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(function_name_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(param_count_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(is_replace_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(return_type_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(language_));
  hash = common::HashUtil::CombineHashInRange(hash, function_body_.begin(), function_body_.end());
  hash = common::HashUtil::CombineHashInRange(hash, function_param_names_.begin(), function_param_names_.end());
  hash = common::HashUtil::CombineHashInRange(hash, function_param_types_.begin(), function_param_types_.end());
  return hash;
}

bool CreateFunction::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::CREATEFUNCTION) return false;
  const CreateFunction &node = *dynamic_cast<const CreateFunction *>(&r);
  if (database_oid_ != node.database_oid_) return false;
  if (namespace_oid_ != node.namespace_oid_) return false;
  if (function_name_ != node.function_name_) return false;
  if (function_body_ != node.function_body_) return false;
  if (param_count_ != node.param_count_) return false;
  if (return_type_ != node.return_type_) return false;
  if (function_param_types_ != node.function_param_types_) return false;
  if (function_param_names_ != node.function_param_names_) return false;
  if (is_replace_ != node.is_replace_) return false;
  return language_ == node.language_;
}

//===--------------------------------------------------------------------===//
// DropDatabase
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *DropDatabase::Copy() const { return new DropDatabase(*this); }

Operator DropDatabase::Make(catalog::db_oid_t db_oid) {
  auto *op = new DropDatabase();
  op->db_oid_ = db_oid;
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(op));
}

common::hash_t DropDatabase::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(db_oid_));
  return hash;
}

bool DropDatabase::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::DROPDATABASE) return false;
  const DropDatabase &node = *dynamic_cast<const DropDatabase *>(&r);
  return node.db_oid_ == db_oid_;
}

//===--------------------------------------------------------------------===//
// DropTable
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *DropTable::Copy() const { return new DropTable(*this); }

Operator DropTable::Make(catalog::table_oid_t table_oid) {
  auto *op = new DropTable();
  op->table_oid_ = table_oid;
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(op));
}

common::hash_t DropTable::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(table_oid_));
  return hash;
}

bool DropTable::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::DROPTABLE) return false;
  const DropTable &node = *dynamic_cast<const DropTable *>(&r);
  return node.table_oid_ == table_oid_;
}

//===--------------------------------------------------------------------===//
// DropIndex
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *DropIndex::Copy() const { return new DropIndex(*this); }

Operator DropIndex::Make(catalog::index_oid_t index_oid) {
  auto *op = new DropIndex();
  op->index_oid_ = index_oid;
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(op));
}

common::hash_t DropIndex::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(index_oid_));
  return hash;
}

bool DropIndex::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::DROPINDEX) return false;
  const DropIndex &node = *dynamic_cast<const DropIndex *>(&r);
  return node.index_oid_ == index_oid_;
}

//===--------------------------------------------------------------------===//
// DropNamespace
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *DropNamespace::Copy() const { return new DropNamespace(*this); }

Operator DropNamespace::Make(catalog::namespace_oid_t namespace_oid) {
  auto *op = new DropNamespace();
  op->namespace_oid_ = namespace_oid;
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(op));
}

common::hash_t DropNamespace::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(namespace_oid_));
  return hash;
}

bool DropNamespace::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::DROPNAMESPACE) return false;
  const DropNamespace &node = *dynamic_cast<const DropNamespace *>(&r);
  return node.namespace_oid_ == namespace_oid_;
}

//===--------------------------------------------------------------------===//
// DropTrigger
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *DropTrigger::Copy() const { return new DropTrigger(*this); }

Operator DropTrigger::Make(catalog::db_oid_t database_oid, catalog::trigger_oid_t trigger_oid, bool if_exists) {
  auto *op = new DropTrigger();
  op->database_oid_ = database_oid;
  op->trigger_oid_ = trigger_oid;
  op->if_exists_ = if_exists;
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(op));
}

common::hash_t DropTrigger::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(database_oid_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(trigger_oid_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(if_exists_));
  return hash;
}

bool DropTrigger::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::DROPTRIGGER) return false;
  const DropTrigger &node = *dynamic_cast<const DropTrigger *>(&r);
  if (database_oid_ != node.database_oid_) return false;
  if (trigger_oid_ != node.trigger_oid_) return false;
  if (if_exists_ != node.if_exists_) return false;
  return node.namespace_oid_ == namespace_oid_;
}

//===--------------------------------------------------------------------===//
// DropView
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *DropView::Copy() const { return new DropView(*this); }

Operator DropView::Make(catalog::db_oid_t database_oid, catalog::view_oid_t view_oid, bool if_exists) {
  auto *op = new DropView();
  op->database_oid_ = database_oid;
  op->view_oid_ = view_oid;
  op->if_exists_ = if_exists;
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(op));
}

common::hash_t DropView::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(database_oid_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(view_oid_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(if_exists_));
  return hash;
}

bool DropView::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::DROPVIEW) return false;
  const DropView &node = *dynamic_cast<const DropView *>(&r);
  if (database_oid_ != node.database_oid_) return false;
  if (view_oid_ != node.view_oid_) return false;
  return if_exists_ == node.if_exists_;
}

//===--------------------------------------------------------------------===//
// Analyze
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *Analyze::Copy() const { return new Analyze(*this); }

Operator Analyze::Make(catalog::db_oid_t database_oid, catalog::table_oid_t table_oid,
                       std::vector<catalog::col_oid_t> &&columns) {
  auto *op = new Analyze();
  op->database_oid_ = database_oid;
  op->table_oid_ = table_oid;
  op->columns_ = std::move(columns);
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(op));
}

common::hash_t Analyze::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(database_oid_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(table_oid_));
  hash = common::HashUtil::CombineHashInRange(hash, columns_.begin(), columns_.end());
  return hash;
}

bool Analyze::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::ANALYZE) return false;
  const Analyze &node = *dynamic_cast<const Analyze *>(&r);
  if (database_oid_ != node.database_oid_) return false;
  if (table_oid_ != node.table_oid_) return false;
  if (columns_ != node.columns_) return false;
  return true;
}

//===--------------------------------------------------------------------===//
// PhysicalCteScan
//===--------------------------------------------------------------------===//
BaseOperatorNodeContents *CteScan::Copy() const { return new CteScan(*this); }

Operator CteScan::Make(std::vector<std::vector<common::ManagedPointer<parser::AbstractExpression>>> child_expressions,
                       std::string table_name, catalog::table_oid_t table_oid, parser::CteType cte_type,
                       std::vector<AnnotatedExpression> &&scan_predicate, catalog::Schema &&table_schema) {
  auto *cte_scan_op = new CteScan();
  cte_scan_op->child_expressions_ = std::move(child_expressions);
  cte_scan_op->table_name_ = std::move(table_name);
  cte_scan_op->table_oid_ = table_oid;
  cte_scan_op->cte_type_ = cte_type;
  cte_scan_op->scan_predicate_ = std::move(scan_predicate);
  cte_scan_op->table_schema_ = std::move(table_schema);
  return Operator(common::ManagedPointer<BaseOperatorNodeContents>(cte_scan_op));
}

bool CteScan::operator==(const BaseOperatorNodeContents &r) {
  if (r.GetOpType() != OpType::CTESCAN) return false;
  const CteScan &node = *dynamic_cast<const CteScan *>(&r);
  return table_name_ == node.GetTableName();
}

common::hash_t CteScan::Hash() const {
  common::hash_t hash = BaseOperatorNodeContents::Hash();
  hash = common::HashUtil::CombineHashes(hash, static_cast<uint32_t>(cte_type_));
  hash = common::HashUtil::CombineHashes(hash, common::HashUtil::Hash(table_name_));
  hash = common::HashUtil::CombineHashInRange(hash, scan_predicate_.begin(), scan_predicate_.end());
  return hash;
}

//===--------------------------------------------------------------------===//
template <>
const char *OperatorNodeContents<TableFreeScan>::name = ""TableFreeScan"";
template <>
const char *OperatorNodeContents<SeqScan>::name = ""SeqScan"";
template <>
const char *OperatorNodeContents<IndexScan>::name = ""IndexScan"";
template <>
const char *OperatorNodeContents<ExternalFileScan>::name = ""ExternalFileScan"";
template <>
const char *OperatorNodeContents<QueryDerivedScan>::name = ""QueryDerivedScan"";
template <>
const char *OperatorNodeContents<OrderBy>::name = ""OrderBy"";
template <>
const char *OperatorNodeContents<Limit>::name = ""Limit"";
template <>
const char *OperatorNodeContents<InnerIndexJoin>::name = ""InnerIndexJoin"";
template <>
const char *OperatorNodeContents<InnerNLJoin>::name = ""InnerNLJoin"";
template <>
const char *OperatorNodeContents<LeftNLJoin>::name = ""LeftNLJoin"";
template <>
const char *OperatorNodeContents<RightNLJoin>::name = ""RightNLJoin"";
template <>
const char *OperatorNodeContents<OuterNLJoin>::name = ""OuterNLJoin"";
template <>
const char *OperatorNodeContents<InnerHashJoin>::name = ""InnerHashJoin"";
template <>
const char *OperatorNodeContents<LeftSemiHashJoin>::name = ""LeftSemiHashJoin"";
template <>
const char *OperatorNodeContents<LeftHashJoin>::name = ""LeftHashJoin"";
template <>
const char *OperatorNodeContents<RightHashJoin>::name = ""RightHashJoin"";
template <>
const char *OperatorNodeContents<OuterHashJoin>::name = ""OuterHashJoin"";
template <>
const char *OperatorNodeContents<Insert>::name = ""Insert"";
template <>
const char *OperatorNodeContents<InsertSelect>::name = ""InsertSelect"";
template <>
const char *OperatorNodeContents<Delete>::name = ""Delete"";
template <>
const char *OperatorNodeContents<Update>::name = ""Update"";
template <>
const char *OperatorNodeContents<HashGroupBy>::name = ""HashGroupBy"";
template <>
const char *OperatorNodeContents<SortGroupBy>::name = ""SortGroupBy"";
template <>
const char *OperatorNodeContents<Aggregate>::name = ""Aggregate"";
template <>
const char *OperatorNodeContents<ExportExternalFile>::name = ""ExportExternalFile"";
template <>
const char *OperatorNodeContents<CreateDatabase>::name = ""CreateDatabase"";
template <>
const char *OperatorNodeContents<CreateTable>::name = ""CreateTable"";
template <>
const char *OperatorNodeContents<CreateIndex>::name = ""CreateIndex"";
template <>
const char *OperatorNodeContents<CreateFunction>::name = ""CreateFunction"";
template <>
const char *OperatorNodeContents<CreateNamespace>::name = ""CreateNamespace"";
template <>
const char *OperatorNodeContents<CreateTrigger>::name = ""CreateTrigger"";
template <>
const char *OperatorNodeContents<CreateView>::name = ""CreateView"";
template <>
const char *OperatorNodeContents<DropDatabase>::name = ""DropDatabase"";
template <>
const char *OperatorNodeContents<DropTable>::name = ""DropTable"";
template <>
const char *OperatorNodeContents<DropIndex>::name = ""DropIndex"";
template <>
const char *OperatorNodeContents<DropNamespace>::name = ""DropNamespace"";
template <>
const char *OperatorNodeContents<DropTrigger>::name = ""DropTrigger"";
template <>
const char *OperatorNodeContents<DropView>::name = ""DropView"";
template <>
const char *OperatorNodeContents<Analyze>::name = ""Analyze"";
template <>
const char *OperatorNodeContents<CteScan>::name = ""CteScan"";

//===--------------------------------------------------------------------===//
template <>
OpType OperatorNodeContents<TableFreeScan>::type = OpType::TABLEFREESCAN;
template <>
OpType OperatorNodeContents<SeqScan>::type = OpType::SEQSCAN;
template <>
OpType OperatorNodeContents<IndexScan>::type = OpType::INDEXSCAN;
template <>
OpType OperatorNodeContents<ExternalFileScan>::type = OpType::EXTERNALFILESCAN;
template <>
OpType OperatorNodeContents<QueryDerivedScan>::type = OpType::QUERYDERIVEDSCAN;
template <>
OpType OperatorNodeContents<OrderBy>::type = OpType::ORDERBY;
template <>
OpType OperatorNodeContents<Limit>::type = OpType::LIMIT;
template <>
OpType OperatorNodeContents<InnerIndexJoin>::type = OpType::INNERINDEXJOIN;
template <>
OpType OperatorNodeContents<InnerNLJoin>::type = OpType::INNERNLJOIN;
template <>
OpType OperatorNodeContents<LeftNLJoin>::type = OpType::LEFTNLJOIN;
template <>
OpType OperatorNodeContents<RightNLJoin>::type = OpType::RIGHTNLJOIN;
template <>
OpType OperatorNodeContents<OuterNLJoin>::type = OpType::OUTERNLJOIN;
template <>
OpType OperatorNodeContents<InnerHashJoin>::type = OpType::INNERHASHJOIN;
template <>
OpType OperatorNodeContents<LeftSemiHashJoin>::type = OpType::LEFTSEMIHASHJOIN;
template <>
OpType OperatorNodeContents<LeftHashJoin>::type = OpType::LEFTHASHJOIN;
template <>
OpType OperatorNodeContents<RightHashJoin>::type = OpType::RIGHTHASHJOIN;
template <>
OpType OperatorNodeContents<OuterHashJoin>::type = OpType::OUTERHASHJOIN;
template <>
OpType OperatorNodeContents<Insert>::type = OpType::INSERT;
template <>
OpType OperatorNodeContents<InsertSelect>::type = OpType::INSERTSELECT;
template <>
OpType OperatorNodeContents<Delete>::type = OpType::DELETE;
template <>
OpType OperatorNodeContents<Update>::type = OpType::UPDATE;
template <>
OpType OperatorNodeContents<HashGroupBy>::type = OpType::HASHGROUPBY;
template <>
OpType OperatorNodeContents<SortGroupBy>::type = OpType::SORTGROUPBY;
template <>
OpType OperatorNodeContents<Aggregate>::type = OpType::AGGREGATE;
template <>
OpType OperatorNodeContents<ExportExternalFile>::type = OpType::EXPORTEXTERNALFILE;
template <>
OpType OperatorNodeContents<CreateDatabase>::type = OpType::CREATEDATABASE;
template <>
OpType OperatorNodeContents<CreateTable>::type = OpType::CREATETABLE;
template <>
OpType OperatorNodeContents<CreateIndex>::type = OpType::CREATEINDEX;
template <>
OpType OperatorNodeContents<CreateFunction>::type = OpType::CREATEFUNCTION;
template <>
OpType OperatorNodeContents<CreateNamespace>::type = OpType::CREATENAMESPACE;
template <>
OpType OperatorNodeContents<CreateTrigger>::type = OpType::CREATETRIGGER;
template <>
OpType OperatorNodeContents<CreateView>::type = OpType::CREATEVIEW;
template <>
OpType OperatorNodeContents<DropDatabase>::type = OpType::DROPDATABASE;
template <>
OpType OperatorNodeContents<DropTable>::type = OpType::DROPTABLE;
template <>
OpType OperatorNodeContents<DropIndex>::type = OpType::DROPINDEX;
template <>
OpType OperatorNodeContents<DropNamespace>::type = OpType::DROPNAMESPACE;
template <>
OpType OperatorNodeContents<DropTrigger>::type = OpType::DROPTRIGGER;
template <>
OpType OperatorNodeContents<DropView>::type = OpType::DROPVIEW;
template <>
OpType OperatorNodeContents<Analyze>::type = OpType::ANALYZE;
template <>
OpType OperatorNodeContents<CteScan>::type = OpType::CTESCAN;

}  // namespace noisepage::optimizer
",16288,True,4067.6773401499167,median
"/******************************************************************************
 *
 * Project:  PDF driver
 * Purpose:  GDALDataset driver for PDF dataset.
 * Author:   Even Rouault, <even dot rouault at spatialys.com>
 *
 ******************************************************************************
 *
 * Support for open-source PDFium library
 *
 * Copyright (C) 2015 Klokan Technologies GmbH (http://www.klokantech.com/)
 * Author: Martin Mikita <martin.mikita@klokantech.com>, xmikit00 @ FIT VUT Brno
 *
 ******************************************************************************
 * Copyright (c) 2011-2013, Even Rouault <even dot rouault at spatialys.com>
 *
 * 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 ""gdal_pdf.h""

#include <vector>
#include ""pdfobject.h""

CPL_CVSID(""$Id$"")

/************************************************************************/
/*                        ROUND_TO_INT_IF_CLOSE()                       */
/************************************************************************/

double ROUND_TO_INT_IF_CLOSE(double x, double eps)
{
    if( eps == 0.0 )
        eps = fabs(x) < 1 ? 1e-10 : 1e-8;
    int nClosestInt = (int)floor(x + 0.5);
    if ( fabs(x - nClosestInt) < eps )
        return nClosestInt;
    else
        return x;
}

/************************************************************************/
/*                         GDALPDFGetPDFString()                        */
/************************************************************************/

static CPLString GDALPDFGetPDFString(const char* pszStr)
{
    GByte* pabyData = (GByte*)pszStr;
    int i;
    GByte ch;
    for(i=0;(ch = pabyData[i]) != '\\0';i++)
    {
        if (ch < 32 || ch > 127 ||
            ch == '(' || ch == ')' ||
            ch == '\\\\' || ch == '%' || ch == '#')
            break;
    }
    CPLString osStr;
    if (ch == 0)
    {
        osStr = ""("";
        osStr += pszStr;
        osStr += "")"";
        return osStr;
    }

    wchar_t* pwszDest = CPLRecodeToWChar( pszStr, CPL_ENC_UTF8, CPL_ENC_UCS2 );
    osStr = ""<FEFF"";
    for(i=0;pwszDest[i] != 0;i++)
    {
#ifndef _WIN32
        if (pwszDest[i] >= 0x10000 /* && pwszDest[i] <= 0x10FFFF */)
        {
            /* Generate UTF-16 surrogate pairs (on Windows, CPLRecodeToWChar does it for us)  */
            int nHeadSurrogate = ((pwszDest[i] - 0x10000) >> 10) | 0xd800;
            int nTrailSurrogate = ((pwszDest[i] - 0x10000) & 0x3ff) | 0xdc00;
            osStr += CPLSPrintf(""%02X"", (nHeadSurrogate >> 8) & 0xff);
            osStr += CPLSPrintf(""%02X"", (nHeadSurrogate) & 0xff);
            osStr += CPLSPrintf(""%02X"", (nTrailSurrogate >> 8) & 0xff);
            osStr += CPLSPrintf(""%02X"", (nTrailSurrogate) & 0xff);
        }
        else
#endif
        {
            osStr += CPLSPrintf(""%02X"", (int)(pwszDest[i] >> 8) & 0xff);
            osStr += CPLSPrintf(""%02X"", (int)(pwszDest[i]) & 0xff);
        }
    }
    osStr += "">"";
    CPLFree(pwszDest);
    return osStr;
}

#if defined(HAVE_POPPLER) || defined(HAVE_PDFIUM)

/************************************************************************/
/*                     GDALPDFGetUTF8StringFromBytes()                  */
/************************************************************************/

static CPLString GDALPDFGetUTF8StringFromBytes(const GByte* pabySrc, int nLen)
{
    int bLEUnicodeMarker = nLen > 2 && pabySrc[0] == 0xFE && pabySrc[1] == 0xFF;
    int bBEUnicodeMarker = nLen > 2 && pabySrc[0] == 0xFF && pabySrc[1] == 0xFE;
    if (!bLEUnicodeMarker && !bBEUnicodeMarker)
    {
        CPLString osStr;
        osStr.resize( nLen + 1 );
        osStr.assign( (const char*)pabySrc, (size_t)nLen );
        osStr[nLen] = 0;
        const char* pszStr = osStr.c_str();
        if (CPLIsUTF8(pszStr, -1))
            return osStr;
        else
        {
            char* pszUTF8 = CPLRecode( pszStr, CPL_ENC_ISO8859_1, CPL_ENC_UTF8 );
            CPLString osRet = pszUTF8;
            CPLFree(pszUTF8);
            return osRet;
        }
    }

    /* This is UTF-16 content */
    pabySrc += 2;
    nLen = (nLen - 2) / 2;
    wchar_t *pwszSource = new wchar_t[nLen + 1];
    int j = 0;
    for(int i=0; i<nLen; i++, j++)
    {
        if (!bBEUnicodeMarker)
            pwszSource[j] = (pabySrc[2 * i] << 8) + pabySrc[2 * i + 1];
        else
            pwszSource[j] = (pabySrc[2 * i + 1] << 8) + pabySrc[2 * i];
#ifndef _WIN32
        /* Is there a surrogate pair ? See http://en.wikipedia.org/wiki/UTF-16 */
        /* On Windows, CPLRecodeFromWChar does this for us, because wchar_t is only */
        /* 2 bytes wide, whereas on Unix it is 32bits */
        if (pwszSource[j] >= 0xD800 && pwszSource[j] <= 0xDBFF && i + 1 < nLen)
        {
            /* should be in the range 0xDC00... 0xDFFF */
            wchar_t nTrailSurrogate;
            if (!bBEUnicodeMarker)
                nTrailSurrogate = (pabySrc[2 * (i+1)] << 8) + pabySrc[2 * (i+1) + 1];
            else
                nTrailSurrogate = (pabySrc[2 * (i+1) + 1] << 8) + pabySrc[2 * (i+1)];
            if (nTrailSurrogate >= 0xDC00 && nTrailSurrogate <= 0xDFFF)
            {
                pwszSource[j] = ((pwszSource[j] - 0xD800) << 10) + (nTrailSurrogate - 0xDC00) + 0x10000;
                i++;
            }
        }
#endif
    }
    pwszSource[j] = 0;

    char* pszUTF8 = CPLRecodeFromWChar( pwszSource, CPL_ENC_UCS2, CPL_ENC_UTF8 );
    delete[] pwszSource;
    CPLString osStrUTF8(pszUTF8);
    CPLFree(pszUTF8);
    return osStrUTF8;
}

#endif // defined(HAVE_POPPLER) || defined(HAVE_PDFIUM)

/************************************************************************/
/*                          GDALPDFGetPDFName()                         */
/************************************************************************/

static CPLString GDALPDFGetPDFName(const char* pszStr)
{
    GByte* pabyData = (GByte*)pszStr;
    int i;
    GByte ch;
    CPLString osStr;
    for(i=0;(ch = pabyData[i]) != '\\0';i++)
    {
        if (!((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || (ch >= '0' && ch <= '9') || ch == '-'))
            osStr += '_';
        else
            osStr += ch;
    }
    return osStr;
}

/************************************************************************/
/* ==================================================================== */
/*                            GDALPDFObject                             */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                            ~GDALPDFObject()                          */
/************************************************************************/

GDALPDFObject::~GDALPDFObject()
{
}

/************************************************************************/
/*                            LookupObject()                            */
/************************************************************************/

GDALPDFObject* GDALPDFObject::LookupObject(const char* pszPath)
{
    if( GetType() != PDFObjectType_Dictionary )
        return nullptr;
    return GetDictionary()->LookupObject(pszPath);
}

/************************************************************************/
/*                             GetTypeName()                            */
/************************************************************************/

const char* GDALPDFObject::GetTypeName()
{
    switch(GetType())
    {
        case PDFObjectType_Unknown: return GetTypeNameNative();
        case PDFObjectType_Null: return ""null"";
        case PDFObjectType_Bool: return ""bool"";
        case PDFObjectType_Int: return ""int"";
        case PDFObjectType_Real: return ""real"";
        case PDFObjectType_String: return ""string"";
        case PDFObjectType_Name: return ""name"";
        case PDFObjectType_Array: return ""array"";
        case PDFObjectType_Dictionary: return ""dictionary"";
        default: return GetTypeNameNative();
    }
}

/************************************************************************/
/*                             Serialize()                              */
/************************************************************************/

void GDALPDFObject::Serialize(CPLString& osStr, bool bEmitRef)
{
    auto nRefNum = GetRefNum();
    if( bEmitRef && nRefNum.toBool() )
    {
        int nRefGen = GetRefGen();
        osStr.append(CPLSPrintf(""%d %d R"", nRefNum.toInt(), nRefGen));
        return;
    }

    switch(GetType())
    {
        case PDFObjectType_Null: osStr.append(""null""); return;
        case PDFObjectType_Bool: osStr.append(GetBool() ? ""true"": ""false""); return;
        case PDFObjectType_Int: osStr.append(CPLSPrintf(""%d"", GetInt())); return;
        case PDFObjectType_Real:
        {
            char szReal[512];
            double dfRealNonRounded = GetReal();
            double dfReal = ROUND_TO_INT_IF_CLOSE(dfRealNonRounded);
            if (dfReal == (double)(GIntBig)dfReal)
                snprintf(szReal, sizeof(szReal), CPL_FRMT_GIB, (GIntBig)dfReal);
            else if (CanRepresentRealAsString())
            {
                /* Used for OGC BP numeric values */
                CPLsnprintf(szReal, sizeof(szReal), ""(%.*g)"", GetPrecision(), dfReal);
            }
            else
            {
                CPLsnprintf(szReal, sizeof(szReal), ""%.*f"", GetPrecision(), dfReal);

                /* Remove non significant trailing zeroes */
                char* pszDot = strchr(szReal, '.');
                if (pszDot)
                {
                    int iDot = (int)(pszDot - szReal);
                    int nLen = (int)strlen(szReal);
                    for(int i=nLen-1; i > iDot; i --)
                    {
                        if (szReal[i] == '0')
                            szReal[i] = '\\0';
                        else
                            break;
                    }
                }
            }
            osStr.append(szReal);
            return;
        }
        case PDFObjectType_String: osStr.append(GDALPDFGetPDFString(GetString())); return;
        case PDFObjectType_Name: osStr.append(""/""); osStr.append(GDALPDFGetPDFName(GetName())); return;
        case PDFObjectType_Array: GetArray()->Serialize(osStr); return;
        case PDFObjectType_Dictionary: GetDictionary()->Serialize(osStr); return;
        case PDFObjectType_Unknown:
        default: CPLError(CE_Warning, CPLE_AppDefined,
                          ""Serializing unknown object !""); return;
    }
}

/************************************************************************/
/*                               Clone()                                */
/************************************************************************/

GDALPDFObjectRW* GDALPDFObject::Clone()
{
    auto nRefNum = GetRefNum();
    if( nRefNum.toBool() )
    {
        int nRefGen = GetRefGen();
        return GDALPDFObjectRW::CreateIndirect(nRefNum, nRefGen);
    }

    switch(GetType())
    {
        case PDFObjectType_Null: return GDALPDFObjectRW::CreateNull();
        case PDFObjectType_Bool: return GDALPDFObjectRW::CreateBool(GetBool());
        case PDFObjectType_Int: return GDALPDFObjectRW::CreateInt(GetInt());
        case PDFObjectType_Real: return GDALPDFObjectRW::CreateReal(GetReal());
        case PDFObjectType_String: return GDALPDFObjectRW::CreateString(GetString());
        case PDFObjectType_Name: return GDALPDFObjectRW::CreateName(GetName());
        case PDFObjectType_Array: return GDALPDFObjectRW::CreateArray(GetArray()->Clone());
        case PDFObjectType_Dictionary: return GDALPDFObjectRW::CreateDictionary(GetDictionary()->Clone());
        case PDFObjectType_Unknown:
        default: CPLError(CE_Warning, CPLE_AppDefined,
                          ""Cloning unknown object !""); return nullptr;
    }
}

/************************************************************************/
/* ==================================================================== */
/*                         GDALPDFDictionary                            */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                        ~GDALPDFDictionary()                          */
/************************************************************************/

GDALPDFDictionary::~GDALPDFDictionary()
{
}

/************************************************************************/
/*                            LookupObject()                            */
/************************************************************************/

GDALPDFObject* GDALPDFDictionary::LookupObject(const char* pszPath)
{
    GDALPDFObject* poCurObj = nullptr;
    char** papszTokens = CSLTokenizeString2(pszPath, ""."", 0);
    for(int i=0; papszTokens[i] != nullptr; i++)
    {
        int iElt = -1;
        char* pszBracket = strchr(papszTokens[i], '[');
        if( pszBracket != nullptr )
        {
            iElt = atoi(pszBracket + 1);
            *pszBracket = '\\0';
        }

        if( i == 0 )
        {
            poCurObj = Get(papszTokens[i]);
        }
        else
        {
            if( poCurObj->GetType() != PDFObjectType_Dictionary )
            {
                poCurObj = nullptr;
                break;
            }
            poCurObj = poCurObj->GetDictionary()->Get(papszTokens[i]);
        }

        if( poCurObj == nullptr )
        {
            poCurObj = nullptr;
            break;
        }

        if( iElt >= 0 )
        {
            if( poCurObj->GetType() != PDFObjectType_Array )
            {
                poCurObj = nullptr;
                break;
            }
            poCurObj = poCurObj->GetArray()->Get(iElt);
        }
    }
    CSLDestroy(papszTokens);
    return poCurObj;
}

/************************************************************************/
/*                             Serialize()                              */
/************************************************************************/

void GDALPDFDictionary::Serialize(CPLString& osStr)
{
    osStr.append(""<< "");
    std::map<CPLString, GDALPDFObject*>& oMap = GetValues();
    std::map<CPLString, GDALPDFObject*>::iterator oIter = oMap.begin();
    std::map<CPLString, GDALPDFObject*>::iterator oEnd = oMap.end();
    for(;oIter != oEnd;++oIter)
    {
        const char* pszKey = oIter->first.c_str();
        GDALPDFObject* poObj = oIter->second;
        osStr.append(""/"");
        osStr.append(pszKey);
        osStr.append("" "");
        poObj->Serialize(osStr);
        osStr.append("" "");
    }
    osStr.append("">>"");
}

/************************************************************************/
/*                               Clone()                                */
/************************************************************************/

GDALPDFDictionaryRW* GDALPDFDictionary::Clone()
{
    GDALPDFDictionaryRW* poDict = new GDALPDFDictionaryRW();
    std::map<CPLString, GDALPDFObject*>& oMap = GetValues();
    std::map<CPLString, GDALPDFObject*>::iterator oIter = oMap.begin();
    std::map<CPLString, GDALPDFObject*>::iterator oEnd = oMap.end();
    for(;oIter != oEnd;++oIter)
    {
        const char* pszKey = oIter->first.c_str();
        GDALPDFObject* poObj = oIter->second;
        poDict->Add(pszKey, poObj->Clone());
    }
    return poDict;
}

/************************************************************************/
/* ==================================================================== */
/*                           GDALPDFArray                               */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                           ~GDALPDFArray()                            */
/************************************************************************/

GDALPDFArray::~GDALPDFArray()
{
}

/************************************************************************/
/*                             Serialize()                              */
/************************************************************************/

void GDALPDFArray::Serialize(CPLString& osStr)
{
    int nLength = GetLength();
    int i;

    osStr.append(""[ "");
    for(i=0;i<nLength;i++)
    {
        Get(i)->Serialize(osStr);
        osStr.append("" "");
    }
    osStr.append(""]"");
}

/************************************************************************/
/*                               Clone()                                */
/************************************************************************/

GDALPDFArrayRW* GDALPDFArray::Clone()
{
    GDALPDFArrayRW* poArray = new GDALPDFArrayRW();
    int nLength = GetLength();
    int i;
    for(i=0;i<nLength;i++)
    {
        poArray->Add(Get(i)->Clone());
    }
    return poArray;
}

/************************************************************************/
/* ==================================================================== */
/*                           GDALPDFStream                              */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                           ~GDALPDFStream()                           */
/************************************************************************/

GDALPDFStream::~GDALPDFStream()
{
}

/************************************************************************/
/* ==================================================================== */
/*                           GDALPDFObjectRW                            */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                           GDALPDFObjectRW()                          */
/************************************************************************/

GDALPDFObjectRW::GDALPDFObjectRW(GDALPDFObjectType eType) :
    m_eType(eType),
    m_nVal(0),
    m_dfVal(0.0),
    // m_osVal
    m_poDict(nullptr),
    m_poArray(nullptr),
    m_nNum(0),
    m_nGen(0),
    m_bCanRepresentRealAsString(FALSE)
{}

/************************************************************************/
/*                             ~GDALPDFObjectRW()                       */
/************************************************************************/

GDALPDFObjectRW::~GDALPDFObjectRW()
{
    delete m_poDict;
    delete m_poArray;
}

/************************************************************************/
/*                            CreateIndirect()                          */
/************************************************************************/

GDALPDFObjectRW* GDALPDFObjectRW::CreateIndirect(const GDALPDFObjectNum& nNum, int nGen)
{
    GDALPDFObjectRW* poObj = new GDALPDFObjectRW(PDFObjectType_Unknown);
    poObj->m_nNum = nNum;
    poObj->m_nGen = nGen;
    return poObj;
}

/************************************************************************/
/*                             CreateNull()                             */
/************************************************************************/

GDALPDFObjectRW* GDALPDFObjectRW::CreateNull()
{
    return new GDALPDFObjectRW(PDFObjectType_Null);
}

/************************************************************************/
/*                             CreateBool()                             */
/************************************************************************/

GDALPDFObjectRW* GDALPDFObjectRW::CreateBool(int bVal)
{
    GDALPDFObjectRW* poObj = new GDALPDFObjectRW(PDFObjectType_Bool);
    poObj->m_nVal = bVal;
    return poObj;
}

/************************************************************************/
/*                             CreateInt()                              */
/************************************************************************/

GDALPDFObjectRW* GDALPDFObjectRW::CreateInt(int nVal)
{
    GDALPDFObjectRW* poObj = new GDALPDFObjectRW(PDFObjectType_Int);
    poObj->m_nVal = nVal;
    return poObj;
}

/************************************************************************/
/*                            CreateReal()                              */
/************************************************************************/

GDALPDFObjectRW* GDALPDFObjectRW::CreateReal(double dfVal,
                                             int bCanRepresentRealAsString)
{
    GDALPDFObjectRW* poObj = new GDALPDFObjectRW(PDFObjectType_Real);
    poObj->m_dfVal = dfVal;
    poObj->m_bCanRepresentRealAsString = bCanRepresentRealAsString;
    return poObj;
}

/************************************************************************/
/*                       CreateRealWithPrecision()                      */
/************************************************************************/

GDALPDFObjectRW* GDALPDFObjectRW::CreateRealWithPrecision(double dfVal,
                                             int nPrecision)
{
    GDALPDFObjectRW* poObj = new GDALPDFObjectRW(PDFObjectType_Real);
    poObj->m_dfVal = dfVal;
    poObj->m_nPrecision = nPrecision;
    return poObj;
}

/************************************************************************/
/*                           CreateString()                             */
/************************************************************************/

GDALPDFObjectRW* GDALPDFObjectRW::CreateString(const char* pszStr)
{
    GDALPDFObjectRW* poObj = new GDALPDFObjectRW(PDFObjectType_String);
    poObj->m_osVal = pszStr;
    return poObj;
}

/************************************************************************/
/*                            CreateName()                              */
/************************************************************************/

GDALPDFObjectRW* GDALPDFObjectRW::CreateName(const char* pszName)
{
    GDALPDFObjectRW* poObj = new GDALPDFObjectRW(PDFObjectType_Name);
    poObj->m_osVal = pszName;
    return poObj;
}

/************************************************************************/
/*                          CreateDictionary()                          */
/************************************************************************/

GDALPDFObjectRW* GDALPDFObjectRW::CreateDictionary(GDALPDFDictionaryRW* poDict)
{
    CPLAssert(poDict);
    GDALPDFObjectRW* poObj = new GDALPDFObjectRW(PDFObjectType_Dictionary);
    poObj->m_poDict = poDict;
    return poObj;
}

/************************************************************************/
/*                            CreateArray()                             */
/************************************************************************/

GDALPDFObjectRW* GDALPDFObjectRW::CreateArray(GDALPDFArrayRW* poArray)
{
    CPLAssert(poArray);
    GDALPDFObjectRW* poObj = new GDALPDFObjectRW(PDFObjectType_Array);
    poObj->m_poArray = poArray;
    return poObj;
}

/************************************************************************/
/*                          GetTypeNameNative()                         */
/************************************************************************/

const char* GDALPDFObjectRW::GetTypeNameNative()
{
    CPLError(CE_Failure, CPLE_AppDefined, ""Should not go here"");
    return """";
}

/************************************************************************/
/*                             GetType()                                */
/************************************************************************/

GDALPDFObjectType GDALPDFObjectRW::GetType()
{
    return m_eType;
}

/************************************************************************/
/*                             GetBool()                                */
/************************************************************************/

int GDALPDFObjectRW::GetBool()
{
    if (m_eType == PDFObjectType_Bool)
        return m_nVal;

    return FALSE;
}

/************************************************************************/
/*                               GetInt()                               */
/************************************************************************/

int GDALPDFObjectRW::GetInt()
{
    if (m_eType == PDFObjectType_Int)
        return m_nVal;

    return 0;
}

/************************************************************************/
/*                              GetReal()                               */
/************************************************************************/

double GDALPDFObjectRW::GetReal()
{
   return m_dfVal;
}

/************************************************************************/
/*                             GetString()                              */
/************************************************************************/

const CPLString& GDALPDFObjectRW::GetString()
{
    return m_osVal;
}

/************************************************************************/
/*                              GetName()                               */
/************************************************************************/

const CPLString& GDALPDFObjectRW::GetName()
{
    return m_osVal;
}

/************************************************************************/
/*                            GetDictionary()                           */
/************************************************************************/

GDALPDFDictionary* GDALPDFObjectRW::GetDictionary()
{
    return m_poDict;
}

/************************************************************************/
/*                              GetArray()                              */
/************************************************************************/

GDALPDFArray* GDALPDFObjectRW::GetArray()
{
    return m_poArray;
}

/************************************************************************/
/*                              GetStream()                             */
/************************************************************************/

GDALPDFStream* GDALPDFObjectRW::GetStream()
{
    return nullptr;
}

/************************************************************************/
/*                              GetRefNum()                             */
/************************************************************************/

GDALPDFObjectNum GDALPDFObjectRW::GetRefNum()
{
    return m_nNum;
}

/************************************************************************/
/*                              GetRefGen()                             */
/************************************************************************/

int GDALPDFObjectRW::GetRefGen()
{
    return m_nGen;
}

/************************************************************************/
/* ==================================================================== */
/*                          GDALPDFDictionaryRW                         */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                           GDALPDFDictionaryRW()                      */
/************************************************************************/

GDALPDFDictionaryRW::GDALPDFDictionaryRW() {}

/************************************************************************/
/*                          ~GDALPDFDictionaryRW()                      */
/************************************************************************/

GDALPDFDictionaryRW::~GDALPDFDictionaryRW()
{
    std::map<CPLString, GDALPDFObject*>::iterator oIter = m_map.begin();
    std::map<CPLString, GDALPDFObject*>::iterator oEnd = m_map.end();
    for(; oIter != oEnd; ++oIter)
        delete oIter->second;
}

/************************************************************************/
/*                                   Get()                              */
/************************************************************************/

GDALPDFObject* GDALPDFDictionaryRW::Get(const char* pszKey)
{
    std::map<CPLString, GDALPDFObject*>::iterator oIter = m_map.find(pszKey);
    if (oIter != m_map.end())
        return oIter->second;
    return nullptr;
}

/************************************************************************/
/*                               GetValues()                            */
/************************************************************************/

std::map<CPLString, GDALPDFObject*>& GDALPDFDictionaryRW::GetValues()
{
    return m_map;
}

/************************************************************************/
/*                                 Add()                                */
/************************************************************************/

GDALPDFDictionaryRW& GDALPDFDictionaryRW::Add(const char* pszKey, GDALPDFObject* poVal)
{
    std::map<CPLString, GDALPDFObject*>::iterator oIter = m_map.find(pszKey);
    if (oIter != m_map.end())
    {
        delete oIter->second;
        oIter->second = poVal;
    }
    else
        m_map[pszKey] = poVal;

    return *this;
}

/************************************************************************/
/*                                Remove()                              */
/************************************************************************/

GDALPDFDictionaryRW& GDALPDFDictionaryRW::Remove(const char* pszKey)
{
    std::map<CPLString, GDALPDFObject*>::iterator oIter = m_map.find(pszKey);
    if (oIter != m_map.end())
    {
        delete oIter->second;
        m_map.erase(pszKey);
    }

    return *this;
}

/************************************************************************/
/* ==================================================================== */
/*                            GDALPDFArrayRW                            */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                             GDALPDFArrayRW()                         */
/************************************************************************/

GDALPDFArrayRW::GDALPDFArrayRW() {}

/************************************************************************/
/*                            ~GDALPDFArrayRW()                         */
/************************************************************************/

GDALPDFArrayRW::~GDALPDFArrayRW()
{
    for( size_t i = 0; i < m_array.size(); i++ )
        delete m_array[i];
}

/************************************************************************/
/*                               GetLength()                             */
/************************************************************************/

int GDALPDFArrayRW::GetLength()
{
    return static_cast<int>(m_array.size());
}

/************************************************************************/
/*                                  Get()                               */
/************************************************************************/

GDALPDFObject* GDALPDFArrayRW::Get(int nIndex)
{
    if (nIndex < 0 || nIndex >= GetLength())
        return nullptr;
    return m_array[nIndex];
}

/************************************************************************/
/*                                  Add()                               */
/************************************************************************/

GDALPDFArrayRW& GDALPDFArrayRW::Add(GDALPDFObject* poObj)
{
    m_array.push_back(poObj);
    return *this;
}

/************************************************************************/
/*                                  Add()                               */
/************************************************************************/

GDALPDFArrayRW& GDALPDFArrayRW::Add(double* padfVal, int nCount,
                                    int bCanRepresentRealAsString)
{
    for(int i=0;i<nCount;i++)
        m_array.push_back(GDALPDFObjectRW::CreateReal(padfVal[i], bCanRepresentRealAsString));
    return *this;
}

#ifdef HAVE_POPPLER

/************************************************************************/
/* ==================================================================== */
/*                         GDALPDFDictionaryPoppler                     */
/* ==================================================================== */
/************************************************************************/

class GDALPDFDictionaryPoppler: public GDALPDFDictionary
{
    private:
        Dict* m_poDict;
        std::map<CPLString, GDALPDFObject*> m_map;

    public:
        GDALPDFDictionaryPoppler(Dict* poDict) : m_poDict(poDict) {}
        virtual ~GDALPDFDictionaryPoppler();

        virtual GDALPDFObject* Get(const char* pszKey) override;
        virtual std::map<CPLString, GDALPDFObject*>& GetValues() override;
};

/************************************************************************/
/* ==================================================================== */
/*                           GDALPDFArrayPoppler                        */
/* ==================================================================== */
/************************************************************************/

class GDALPDFArrayPoppler : public GDALPDFArray
{
    private:
        Array* m_poArray;
        std::vector<GDALPDFObject*> m_v;

    public:
        GDALPDFArrayPoppler(Array* poArray) : m_poArray(poArray) {}
        virtual ~GDALPDFArrayPoppler();

        virtual int GetLength() override;
        virtual GDALPDFObject* Get(int nIndex) override;
};

/************************************************************************/
/* ==================================================================== */
/*                           GDALPDFStreamPoppler                       */
/* ==================================================================== */
/************************************************************************/

class GDALPDFStreamPoppler : public GDALPDFStream
{
    private:
        int     m_nLength = -1;
        Stream* m_poStream;
        int     m_nRawLength = -1;

    public:
        GDALPDFStreamPoppler(Stream* poStream) : m_poStream(poStream) {}
        virtual ~GDALPDFStreamPoppler() {}

        virtual int GetLength() override;
        virtual char* GetBytes() override;

        virtual int GetRawLength() override;
        virtual char* GetRawBytes() override;
};

/************************************************************************/
/* ==================================================================== */
/*                         GDALPDFObjectPoppler                         */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                          ~GDALPDFObjectPoppler()                     */
/************************************************************************/

GDALPDFObjectPoppler::~GDALPDFObjectPoppler()
{
#if !(POPPLER_MAJOR_VERSION >= 1 || POPPLER_MINOR_VERSION >= 58)
    m_po->free();
#endif
    if (m_bDestroy)
        delete m_po;
    delete m_poDict;
    delete m_poArray;
    delete m_poStream;
}

/************************************************************************/
/*                              GetType()                               */
/************************************************************************/

GDALPDFObjectType GDALPDFObjectPoppler::GetType()
{
    switch(m_po->getType())
    {
        case objNull:       return PDFObjectType_Null;
        case objBool:       return PDFObjectType_Bool;
        case objInt:        return PDFObjectType_Int;
        case objReal:       return PDFObjectType_Real;
        case objString:     return PDFObjectType_String;
        case objName:       return PDFObjectType_Name;
        case objArray:      return PDFObjectType_Array;
        case objDict:       return PDFObjectType_Dictionary;
        case objStream:     return PDFObjectType_Dictionary;
        default:            return PDFObjectType_Unknown;
    }
}

/************************************************************************/
/*                          GetTypeNameNative()                         */
/************************************************************************/

const char* GDALPDFObjectPoppler::GetTypeNameNative()
{
    return m_po->getTypeName();
}

/************************************************************************/
/*                               GetBool()                              */
/************************************************************************/

int GDALPDFObjectPoppler::GetBool()
{
    if (GetType() == PDFObjectType_Bool)
        return m_po->getBool();
    else
        return 0;
}

/************************************************************************/
/*                               GetInt()                               */
/************************************************************************/

int GDALPDFObjectPoppler::GetInt()
{
    if (GetType() == PDFObjectType_Int)
        return m_po->getInt();
    else
        return 0;
}

/************************************************************************/
/*                               GetReal()                              */
/************************************************************************/

double GDALPDFObjectPoppler::GetReal()
{
    if (GetType() == PDFObjectType_Real)
        return m_po->getReal();
    else
        return 0.0;
}

/************************************************************************/
/*                              GetString()                             */
/************************************************************************/

const CPLString& GDALPDFObjectPoppler::GetString()
{
    if (GetType() == PDFObjectType_String)
    {
#if POPPLER_MAJOR_VERSION >= 1 || POPPLER_MINOR_VERSION >= 58
        // At least available since poppler 0.41
        const GooString* gooString = m_po->getString();
#else
        GooString* gooString = m_po->getString();
#endif
#if (POPPLER_MAJOR_VERSION >= 1 || POPPLER_MINOR_VERSION >= 72)
        return (osStr = GDALPDFGetUTF8StringFromBytes(reinterpret_cast<const GByte*>(gooString->c_str()),
                                                      static_cast<int>(gooString->getLength())));
#else
        return (osStr = GDALPDFGetUTF8StringFromBytes(reinterpret_cast<const GByte*>(gooString->getCString()),
                                                      static_cast<int>(gooString->getLength())));
#endif
    }
    else
        return (osStr = """");
}

/************************************************************************/
/*                               GetName()                              */
/************************************************************************/

const CPLString& GDALPDFObjectPoppler::GetName()
{
    if (GetType() == PDFObjectType_Name)
        return (osStr = m_po->getName());
    else
        return (osStr = """");
}

/************************************************************************/
/*                            GetDictionary()                           */
/************************************************************************/

GDALPDFDictionary* GDALPDFObjectPoppler::GetDictionary()
{
    if (GetType() != PDFObjectType_Dictionary)
        return nullptr;

    if (m_poDict)
        return m_poDict;

    Dict* poDict = (m_po->getType() == objStream) ? m_po->getStream()->getDict() : m_po->getDict();
    if (poDict == nullptr)
        return nullptr;
    m_poDict = new GDALPDFDictionaryPoppler(poDict);
    return m_poDict;
}

/************************************************************************/
/*                              GetArray()                              */
/************************************************************************/

GDALPDFArray* GDALPDFObjectPoppler::GetArray()
{
    if (GetType() != PDFObjectType_Array)
        return nullptr;

    if (m_poArray)
        return m_poArray;

    Array* poArray = m_po->getArray();
    if (poArray == nullptr)
        return nullptr;
    m_poArray = new GDALPDFArrayPoppler(poArray);
    return m_poArray;
}

/************************************************************************/
/*                             GetStream()                              */
/************************************************************************/

GDALPDFStream* GDALPDFObjectPoppler::GetStream()
{
    if (m_po->getType() != objStream)
        return nullptr;

    if (m_poStream)
        return m_poStream;
    m_poStream = new GDALPDFStreamPoppler(m_po->getStream());
    return m_poStream;
}

/************************************************************************/
/*                           SetRefNumAndGen()                          */
/************************************************************************/

void GDALPDFObjectPoppler::SetRefNumAndGen(const GDALPDFObjectNum& nNum, int nGen)
{
    m_nRefNum = nNum;
    m_nRefGen = nGen;
}

/************************************************************************/
/*                               GetRefNum()                            */
/************************************************************************/

GDALPDFObjectNum GDALPDFObjectPoppler::GetRefNum()
{
    return m_nRefNum;
}

/************************************************************************/
/*                               GetRefGen()                            */
/************************************************************************/

int GDALPDFObjectPoppler::GetRefGen()
{
    return m_nRefGen;
}

/************************************************************************/
/* ==================================================================== */
/*                        GDALPDFDictionaryPoppler                      */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                       ~GDALPDFDictionaryPoppler()                    */
/************************************************************************/

GDALPDFDictionaryPoppler::~GDALPDFDictionaryPoppler()
{
    std::map<CPLString, GDALPDFObject*>::iterator oIter = m_map.begin();
    std::map<CPLString, GDALPDFObject*>::iterator oEnd = m_map.end();
    for(; oIter != oEnd; ++oIter)
        delete oIter->second;
}

/************************************************************************/
/*                                  Get()                               */
/************************************************************************/

GDALPDFObject* GDALPDFDictionaryPoppler::Get(const char* pszKey)
{
    std::map<CPLString, GDALPDFObject*>::iterator oIter = m_map.find(pszKey);
    if (oIter != m_map.end())
        return oIter->second;

#if POPPLER_MAJOR_VERSION >= 1 || POPPLER_MINOR_VERSION >= 58
    auto&& o(m_poDict->lookupNF(((char*)pszKey)));
    if (!o.isNull())
    {
        GDALPDFObjectNum nRefNum;
        int nRefGen = 0;
        if( o.isRef())
        {
            nRefNum = o.getRefNum();
            nRefGen = o.getRefGen();
            Object o2(m_poDict->lookup((char*)pszKey));
            if( !o2.isNull() )
            {
                GDALPDFObjectPoppler* poObj = new GDALPDFObjectPoppler(new Object(std::move(o2)), TRUE);
                poObj->SetRefNumAndGen(nRefNum, nRefGen);
                m_map[pszKey] = poObj;
                return poObj;
            }
        }
        else
        {
            GDALPDFObjectPoppler* poObj = new GDALPDFObjectPoppler(new Object(o.copy()), TRUE);
            poObj->SetRefNumAndGen(nRefNum, nRefGen);
            m_map[pszKey] = poObj;
            return poObj;
        }
    }
    return nullptr;
#else
    Object* po = new Object;
    if (m_poDict->lookupNF((char*)pszKey, po) && !po->isNull())
    {
        GDALPDFObjectNum nRefNum;
        int nRefGen = 0;
        if( po->isRef())
        {
            nRefNum = po->getRefNum();
            nRefGen = po->getRefGen();
        }
        if( !po->isRef() || (m_poDict->lookup((char*)pszKey, po) && !po->isNull()) )
        {
            GDALPDFObjectPoppler* poObj = new GDALPDFObjectPoppler(po, TRUE);
            poObj->SetRefNumAndGen(nRefNum, nRefGen);
            m_map[pszKey] = poObj;
            return poObj;
        }
        else
        {
            delete po;
            return nullptr;
        }
    }
    else
    {
        delete po;
        return nullptr;
    }
#endif
}

/************************************************************************/
/*                                GetValues()                           */
/************************************************************************/

std::map<CPLString, GDALPDFObject*>& GDALPDFDictionaryPoppler::GetValues()
{
    int i = 0;
    int nLength = m_poDict->getLength();
    for(i=0;i<nLength;i++)
    {
        const char* pszKey = (const char*)m_poDict->getKey(i);
        Get(pszKey);
    }
    return m_map;
}

/************************************************************************/
/* ==================================================================== */
/*                          GDALPDFArrayPoppler                         */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                           GDALPDFCreateArray()                       */
/************************************************************************/

GDALPDFArray* GDALPDFCreateArray(Array* array)
{
    return new GDALPDFArrayPoppler(array);
}

/************************************************************************/
/*                           ~GDALPDFArrayPoppler()                     */
/************************************************************************/

GDALPDFArrayPoppler::~GDALPDFArrayPoppler()
{
    for(size_t i=0;i<m_v.size();i++)
    {
        delete m_v[i];
    }
}

/************************************************************************/
/*                               GetLength()                            */
/************************************************************************/

int GDALPDFArrayPoppler::GetLength()
{
    return m_poArray->getLength();
}

/************************************************************************/
/*                                 Get()                                */
/************************************************************************/

GDALPDFObject* GDALPDFArrayPoppler::Get(int nIndex)
{
    if (nIndex < 0 || nIndex >= GetLength())
        return nullptr;

    int nOldSize = static_cast<int>(m_v.size());
    if (nIndex >= nOldSize)
    {
        m_v.resize(nIndex+1);
        for(int i=nOldSize;i<=nIndex;i++)
        {
            m_v[i] = nullptr;
        }
    }

    if (m_v[nIndex] != nullptr)
        return m_v[nIndex];

#if POPPLER_MAJOR_VERSION >= 1 || POPPLER_MINOR_VERSION >= 58
    auto&& o(m_poArray->getNF(nIndex));
    if( !o.isNull() )
    {
        GDALPDFObjectNum nRefNum;
        int nRefGen = 0;
        if( o.isRef())
        {
            nRefNum = o.getRefNum();
            nRefGen = o.getRefGen();
            Object o2(m_poArray->get(nIndex));
            if( !o2.isNull() )
            {
                GDALPDFObjectPoppler* poObj = new GDALPDFObjectPoppler(new Object(std::move(o2)), TRUE);
                poObj->SetRefNumAndGen(nRefNum, nRefGen);
                m_v[nIndex] = poObj;
                return poObj;
            }
        }
        else
        {
            GDALPDFObjectPoppler* poObj = new GDALPDFObjectPoppler(new Object(o.copy()), TRUE);
            poObj->SetRefNumAndGen(nRefNum, nRefGen);
            m_v[nIndex] = poObj;
            return poObj;
        }
    }
    return nullptr;
#else
    Object* po = new Object;
    if (m_poArray->getNF(nIndex, po))
    {
        GDALPDFObjectNum nRefNum;
        int nRefGen = 0;
        if( po->isRef())
        {
            nRefNum = po->getRefNum();
            nRefGen = po->getRefGen();
        }
        if( !po->isRef() || (m_poArray->get(nIndex, po)) )
        {
            GDALPDFObjectPoppler* poObj = new GDALPDFObjectPoppler(po, TRUE);
            poObj->SetRefNumAndGen(nRefNum, nRefGen);
            m_v[nIndex] = poObj;
            return poObj;
        }
        else
        {
            delete po;
            return nullptr;
        }
    }
    else
    {
        delete po;
        return nullptr;
    }
#endif
}

/************************************************************************/
/* ==================================================================== */
/*                          GDALPDFStreamPoppler                        */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                               GetLength()                            */
/************************************************************************/

int GDALPDFStreamPoppler::GetLength()
{
    if (m_nLength >= 0)
        return m_nLength;

    m_poStream->reset();
    m_nLength = 0;
    while(m_poStream->getChar() != EOF)
        m_nLength ++;
    return m_nLength;
}

/************************************************************************/
/*                         GooStringToCharStart()                       */
/************************************************************************/

static char* GooStringToCharStart(GooString& gstr)
{
    auto nLength = gstr.getLength();
    if( nLength )
    {
        char* pszContent = (char*) VSIMalloc(nLength + 1);
        if (pszContent)
        {
#if (POPPLER_MAJOR_VERSION >= 1 || POPPLER_MINOR_VERSION >= 72)
            const char* srcStr = gstr.c_str();
#else
            const char* srcStr = gstr.getCString();
#endif
            memcpy(pszContent, srcStr, nLength);
            pszContent[nLength] = '\\0';
        }
        return pszContent;
    }
    return nullptr;
}

/************************************************************************/
/*                               GetBytes()                             */
/************************************************************************/

char* GDALPDFStreamPoppler::GetBytes()
{
    GooString gstr;
    m_poStream->fillGooString(&gstr);
    m_nLength = gstr.getLength();
    return GooStringToCharStart(gstr);
}

/************************************************************************/
/*                            GetRawLength()                            */
/************************************************************************/

int GDALPDFStreamPoppler::GetRawLength()
{
    if (m_nRawLength >= 0)
        return m_nRawLength;

    auto undecodeStream = m_poStream->getUndecodedStream();
    undecodeStream->reset();
    m_nRawLength = 0;
    while(undecodeStream->getChar() != EOF)
        m_nRawLength ++;
    return m_nRawLength;
}

/************************************************************************/
/*                             GetRawBytes()                            */
/************************************************************************/

char* GDALPDFStreamPoppler::GetRawBytes()
{
    GooString gstr;
    auto undecodeStream = m_poStream->getUndecodedStream();
    undecodeStream->fillGooString(&gstr);
    m_nRawLength = gstr.getLength();
    return GooStringToCharStart(gstr);
}


#endif // HAVE_POPPLER

#ifdef HAVE_PODOFO

/************************************************************************/
/* ==================================================================== */
/*                         GDALPDFDictionaryPodofo                      */
/* ==================================================================== */
/************************************************************************/

class GDALPDFDictionaryPodofo: public GDALPDFDictionary
{
    private:
        PoDoFo::PdfDictionary* m_poDict;
        PoDoFo::PdfVecObjects& m_poObjects;
        std::map<CPLString, GDALPDFObject*> m_map;

    public:
        GDALPDFDictionaryPodofo(PoDoFo::PdfDictionary* poDict, PoDoFo::PdfVecObjects& poObjects) : m_poDict(poDict), m_poObjects(poObjects) {}
        virtual ~GDALPDFDictionaryPodofo();

        virtual GDALPDFObject* Get(const char* pszKey) override;
        virtual std::map<CPLString, GDALPDFObject*>& GetValues() override;
};

/************************************************************************/
/* ==================================================================== */
/*                           GDALPDFArrayPodofo                         */
/* ==================================================================== */
/************************************************************************/

class GDALPDFArrayPodofo : public GDALPDFArray
{
    private:
        PoDoFo::PdfArray* m_poArray;
        PoDoFo::PdfVecObjects& m_poObjects;
        std::vector<GDALPDFObject*> m_v;

    public:
        GDALPDFArrayPodofo(PoDoFo::PdfArray* poArray, PoDoFo::PdfVecObjects& poObjects) : m_poArray(poArray), m_poObjects(poObjects) {}
        virtual ~GDALPDFArrayPodofo();

        virtual int GetLength() override;
        virtual GDALPDFObject* Get(int nIndex) override;
};

/************************************************************************/
/* ==================================================================== */
/*                          GDALPDFStreamPodofo                         */
/* ==================================================================== */
/************************************************************************/

class GDALPDFStreamPodofo : public GDALPDFStream
{
    private:
        PoDoFo::PdfStream* m_pStream;

    public:
        GDALPDFStreamPodofo(PoDoFo::PdfStream* pStream) : m_pStream(pStream) { }
        virtual ~GDALPDFStreamPodofo() { }

        virtual int GetLength() override;
        virtual char* GetBytes() override;

        virtual int GetRawLength() override;
        virtual char* GetRawBytes() override;
};

/************************************************************************/
/* ==================================================================== */
/*                          GDALPDFObjectPodofo                         */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                          GDALPDFObjectPodofo()                       */
/************************************************************************/

GDALPDFObjectPodofo::GDALPDFObjectPodofo(PoDoFo::PdfObject* po,
                                         PoDoFo::PdfVecObjects& poObjects) :
    m_po(po),
    m_poObjects(poObjects),
    m_poDict(nullptr),
    m_poArray(nullptr),
    m_poStream(nullptr)
{
    try
    {
        if (m_po->GetDataType() == PoDoFo::ePdfDataType_Reference)
        {
            PoDoFo::PdfObject* poObj = m_poObjects.GetObject(m_po->GetReference());
            if (poObj)
                m_po = poObj;
        }
    }
    catch(PoDoFo::PdfError& oError)
    {
        CPLError(CE_Failure, CPLE_AppDefined, ""Invalid PDF : %s"", oError.what());
    }
}

/************************************************************************/
/*                         ~GDALPDFObjectPodofo()                       */
/************************************************************************/

GDALPDFObjectPodofo::~GDALPDFObjectPodofo()
{
    delete m_poDict;
    delete m_poArray;
    delete m_poStream;
}

/************************************************************************/
/*                               GetType()                              */
/************************************************************************/

GDALPDFObjectType GDALPDFObjectPodofo::GetType()
{
    try
    {
        switch(m_po->GetDataType())
        {
            case PoDoFo::ePdfDataType_Null:       return PDFObjectType_Null;
            case PoDoFo::ePdfDataType_Bool:       return PDFObjectType_Bool;
            case PoDoFo::ePdfDataType_Number:     return PDFObjectType_Int;
            case PoDoFo::ePdfDataType_Real:       return PDFObjectType_Real;
            case PoDoFo::ePdfDataType_HexString:  return PDFObjectType_String;
            case PoDoFo::ePdfDataType_String:     return PDFObjectType_String;
            case PoDoFo::ePdfDataType_Name:       return PDFObjectType_Name;
            case PoDoFo::ePdfDataType_Array:      return PDFObjectType_Array;
            case PoDoFo::ePdfDataType_Dictionary: return PDFObjectType_Dictionary;
            default:                              return PDFObjectType_Unknown;
        }
    }
    catch(PoDoFo::PdfError& oError)
    {
        CPLError(CE_Failure, CPLE_AppDefined, ""Invalid PDF : %s"", oError.what());
        return PDFObjectType_Unknown;
    }
}

/************************************************************************/
/*                          GetTypeNameNative()                         */
/************************************************************************/

const char* GDALPDFObjectPodofo::GetTypeNameNative()
{
    try
    {
        return m_po->GetDataTypeString();
    }
    catch(PoDoFo::PdfError& oError)
    {
        CPLError(CE_Failure, CPLE_AppDefined, ""Invalid PDF : %s"", oError.what());
        return ""unknown"";
    }
}

/************************************************************************/
/*                              GetBool()                               */
/************************************************************************/

int GDALPDFObjectPodofo::GetBool()
{
    if (m_po->GetDataType() == PoDoFo::ePdfDataType_Bool)
        return m_po->GetBool();
    else
        return 0;
}

/************************************************************************/
/*                              GetInt()                                */
/************************************************************************/

int GDALPDFObjectPodofo::GetInt()
{
    if (m_po->GetDataType() == PoDoFo::ePdfDataType_Number)
        return static_cast<int>(m_po->GetNumber());
    else
        return 0;
}

/************************************************************************/
/*                              GetReal()                               */
/************************************************************************/

double GDALPDFObjectPodofo::GetReal()
{
    if (GetType() == PDFObjectType_Real)
        return m_po->GetReal();
    else
        return 0.0;
}

/************************************************************************/
/*                              GetString()                             */
/************************************************************************/

const CPLString& GDALPDFObjectPodofo::GetString()
{
    if (GetType() == PDFObjectType_String)
        return (osStr = m_po->GetString().GetStringUtf8());
    else
        return (osStr = """");
}

/************************************************************************/
/*                              GetName()                               */
/************************************************************************/

const CPLString&  GDALPDFObjectPodofo::GetName()
{
    if (GetType() == PDFObjectType_Name)
        return (osStr = m_po->GetName().GetName());
    else
        return (osStr = """");
}

/************************************************************************/
/*                             GetDictionary()                          */
/************************************************************************/

GDALPDFDictionary* GDALPDFObjectPodofo::GetDictionary()
{
    if (GetType() != PDFObjectType_Dictionary)
        return nullptr;

    if (m_poDict)
        return m_poDict;

    m_poDict = new GDALPDFDictionaryPodofo(&m_po->GetDictionary(), m_poObjects);
    return m_poDict;
}

/************************************************************************/
/*                                GetArray()                            */
/************************************************************************/

GDALPDFArray* GDALPDFObjectPodofo::GetArray()
{
    if (GetType() != PDFObjectType_Array)
        return nullptr;

    if (m_poArray)
        return m_poArray;

    m_poArray = new GDALPDFArrayPodofo(&m_po->GetArray(), m_poObjects);
    return m_poArray;
}

/************************************************************************/
/*                               GetStream()                            */
/************************************************************************/

GDALPDFStream* GDALPDFObjectPodofo::GetStream()
{
    try
    {
        if (!m_po->HasStream())
            return nullptr;
    }
    catch(PoDoFo::PdfError& oError)
    {
        CPLError(CE_Failure, CPLE_AppDefined, ""Invalid object : %s"", oError.what());
        return nullptr;
    }
    catch(...)
    {
        CPLError(CE_Failure, CPLE_AppDefined, ""Invalid object"");
        return nullptr;
    }

    if (m_poStream == nullptr)
        m_poStream = new GDALPDFStreamPodofo(m_po->GetStream());
    return m_poStream;
}

/************************************************************************/
/*                               GetRefNum()                            */
/************************************************************************/

GDALPDFObjectNum GDALPDFObjectPodofo::GetRefNum()
{
    return GDALPDFObjectNum(m_po->Reference().ObjectNumber());
}

/************************************************************************/
/*                               GetRefGen()                            */
/************************************************************************/

int GDALPDFObjectPodofo::GetRefGen()
{
    return m_po->Reference().GenerationNumber();
}

/************************************************************************/
/* ==================================================================== */
/*                         GDALPDFDictionaryPodofo                      */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                         ~GDALPDFDictionaryPodofo()                   */
/************************************************************************/

GDALPDFDictionaryPodofo::~GDALPDFDictionaryPodofo()
{
    std::map<CPLString, GDALPDFObject*>::iterator oIter = m_map.begin();
    std::map<CPLString, GDALPDFObject*>::iterator oEnd = m_map.end();
    for(; oIter != oEnd; ++oIter)
        delete oIter->second;
}

/************************************************************************/
/*                                  Get()                               */
/************************************************************************/

GDALPDFObject* GDALPDFDictionaryPodofo::Get(const char* pszKey)
{
    std::map<CPLString, GDALPDFObject*>::iterator oIter = m_map.find(pszKey);
    if (oIter != m_map.end())
        return oIter->second;

    PoDoFo::PdfObject* poVal = m_poDict->GetKey(PoDoFo::PdfName(pszKey));
    if (poVal)
    {
         GDALPDFObjectPodofo* poObj = new GDALPDFObjectPodofo(poVal, m_poObjects);
         m_map[pszKey] = poObj;
         return poObj;
    }
    else
    {
        return nullptr;
    }
}

/************************************************************************/
/*                              GetValues()                             */
/************************************************************************/

std::map<CPLString, GDALPDFObject*>& GDALPDFDictionaryPodofo::GetValues()
{
    PoDoFo::TKeyMap::iterator oIter = m_poDict->GetKeys().begin();
    PoDoFo::TKeyMap::iterator oEnd = m_poDict->GetKeys().end();
    for( ; oIter != oEnd; ++oIter)
    {
        const char* pszKey = oIter->first.GetName().c_str();
        Get(pszKey);
    }

    return m_map;
}

/************************************************************************/
/* ==================================================================== */
/*                           GDALPDFArrayPodofo                         */
/* ==================================================================== */
/************************************************************************/

GDALPDFArrayPodofo::~GDALPDFArrayPodofo()
{
    for(size_t i=0;i<m_v.size();i++)
    {
        delete m_v[i];
    }
}

/************************************************************************/
/*                              GetLength()                             */
/************************************************************************/

int GDALPDFArrayPodofo::GetLength()
{
    return static_cast<int>(m_poArray->GetSize());
}

/************************************************************************/
/*                                Get()                                 */
/************************************************************************/

GDALPDFObject* GDALPDFArrayPodofo::Get(int nIndex)
{
    if (nIndex < 0 || nIndex >= GetLength())
        return nullptr;

    int nOldSize = static_cast<int>(m_v.size());
    if (nIndex >= nOldSize)
    {
        m_v.resize(nIndex+1);
        for(int i=nOldSize;i<=nIndex;i++)
        {
            m_v[i] = nullptr;
        }
    }

    if (m_v[nIndex] != nullptr)
        return m_v[nIndex];

    PoDoFo::PdfObject& oVal = (*m_poArray)[nIndex];
    GDALPDFObjectPodofo* poObj = new GDALPDFObjectPodofo(&oVal, m_poObjects);
    m_v[nIndex] = poObj;
    return poObj;
}

/************************************************************************/
/* ==================================================================== */
/*                           GDALPDFStreamPodofo                        */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                              GetLength()                             */
/************************************************************************/

int GDALPDFStreamPodofo::GetLength()
{
    char* pBuffer = nullptr;
    PoDoFo::pdf_long nLen = 0;
    try
    {
        m_pStream->GetFilteredCopy( &pBuffer, &nLen );
        PoDoFo::podofo_free(pBuffer);
        return (int)nLen;
    }
    catch( PoDoFo::PdfError & e )
    {
    }
    return 0;
}

/************************************************************************/
/*                               GetBytes()                             */
/************************************************************************/

char* GDALPDFStreamPodofo::GetBytes()
{
    char* pBuffer = nullptr;
    PoDoFo::pdf_long nLen = 0;
    try
    {
        m_pStream->GetFilteredCopy( &pBuffer, &nLen );
    }
    catch( PoDoFo::PdfError & e )
    {
        return nullptr;
    }
    char* pszContent = (char*) VSIMalloc(nLen + 1);
    if (!pszContent)
    {
        PoDoFo::podofo_free(pBuffer);
        return nullptr;
    }
    memcpy(pszContent, pBuffer, nLen);
    PoDoFo::podofo_free(pBuffer);
    pszContent[nLen] = '\\0';
    return pszContent;
}

/************************************************************************/
/*                             GetRawLength()                           */
/************************************************************************/

int GDALPDFStreamPodofo::GetRawLength()
{
    try
    {
        auto nLen = m_pStream->GetLength();
        return (int)nLen;
    }
    catch( PoDoFo::PdfError & e )
    {
    }
    return 0;
}

/************************************************************************/
/*                              GetRawBytes()                           */
/************************************************************************/

char* GDALPDFStreamPodofo::GetRawBytes()
{
    char* pBuffer = nullptr;
    PoDoFo::pdf_long nLen = 0;
    try
    {
        m_pStream->GetCopy( &pBuffer, &nLen );
    }
    catch( PoDoFo::PdfError & e )
    {
        return nullptr;
    }
    char* pszContent = (char*) VSIMalloc(nLen + 1);
    if (!pszContent)
    {
        PoDoFo::podofo_free(pBuffer);
        return nullptr;
    }
    memcpy(pszContent, pBuffer, nLen);
    PoDoFo::podofo_free(pBuffer);
    pszContent[nLen] = '\\0';
    return pszContent;
}

#endif // HAVE_PODOFO

#ifdef HAVE_PDFIUM

/************************************************************************/
/* ==================================================================== */
/*                         GDALPDFDictionaryPdfium                      */
/* ==================================================================== */
/************************************************************************/

class GDALPDFDictionaryPdfium: public GDALPDFDictionary
{
    private:
        CPDF_Dictionary* m_poDict;
        std::map<CPLString, GDALPDFObject*> m_map;

    public:
        GDALPDFDictionaryPdfium(CPDF_Dictionary* poDict) : m_poDict(poDict) {}
        virtual ~GDALPDFDictionaryPdfium();

        virtual GDALPDFObject* Get(const char* pszKey) override;
        virtual std::map<CPLString, GDALPDFObject*>& GetValues() override;
};

/************************************************************************/
/* ==================================================================== */
/*                           GDALPDFArrayPdfium                         */
/* ==================================================================== */
/************************************************************************/

class GDALPDFArrayPdfium : public GDALPDFArray
{
    private:
        CPDF_Array* m_poArray;
        std::vector<GDALPDFObject*> m_v;

    public:
        GDALPDFArrayPdfium(CPDF_Array* poArray) : m_poArray(poArray) {}
        virtual ~GDALPDFArrayPdfium();

        virtual int GetLength() override;
        virtual GDALPDFObject* Get(int nIndex) override;
};

/************************************************************************/
/* ==================================================================== */
/*                          GDALPDFStreamPdfium                         */
/* ==================================================================== */
/************************************************************************/

class GDALPDFStreamPdfium : public GDALPDFStream
{
    private:
        CPDF_Stream* m_pStream;
        int m_nSize = 0;
        std::unique_ptr<uint8_t, CPLFreeReleaser> m_pData = nullptr;
        int m_nRawSize = 0;
        std::unique_ptr<uint8_t, CPLFreeReleaser> m_pRawData = nullptr;

        void Decompress();
        void FillRaw();

    public:
        GDALPDFStreamPdfium( CPDF_Stream* pStream ) :
            m_pStream(pStream) {}
        virtual ~GDALPDFStreamPdfium() {}

        virtual int GetLength() override;
        virtual char* GetBytes() override;

        virtual int GetRawLength() override;
        virtual char* GetRawBytes() override;
};

/************************************************************************/
/* ==================================================================== */
/*                          GDALPDFObjectPdfium                         */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                          GDALPDFObjectPdfium()                       */
/************************************************************************/

GDALPDFObjectPdfium::GDALPDFObjectPdfium( CPDF_Object *po ) :
    m_po(po),
    m_poDict(nullptr),
    m_poArray(nullptr),
    m_poStream(nullptr)
{
    CPLAssert(m_po != nullptr);
}

/************************************************************************/
/*                         ~GDALPDFObjectPdfium()                       */
/************************************************************************/

GDALPDFObjectPdfium::~GDALPDFObjectPdfium()
{
    delete m_poDict;
    delete m_poArray;
    delete m_poStream;
}

/************************************************************************/
/*                               Build()                                */
/************************************************************************/

GDALPDFObjectPdfium* GDALPDFObjectPdfium::Build(CPDF_Object *poVal)
{
    if( poVal == nullptr )
        return nullptr;
    if( poVal->GetType() == CPDF_Object::Type::kReference )
    {
        poVal = poVal->GetDirect();
        if( poVal == nullptr )
        {
            CPLError(CE_Failure, CPLE_AppDefined, ""Cannot resolve indirect object"");
            return nullptr;
        }
    }
    return new GDALPDFObjectPdfium(poVal);
}

/************************************************************************/
/*                               GetType()                              */
/************************************************************************/

GDALPDFObjectType GDALPDFObjectPdfium::GetType()
{
    switch(m_po->GetType())
    {
        case CPDF_Object::Type::kNullobj:                  return PDFObjectType_Null;
        case CPDF_Object::Type::kBoolean:                  return PDFObjectType_Bool;
        case CPDF_Object::Type::kNumber:
          return (reinterpret_cast<CPDF_Number*>(m_po))->IsInteger()
              ? PDFObjectType_Int
              : PDFObjectType_Real;
        case CPDF_Object::Type::kString:                   return PDFObjectType_String;
        case CPDF_Object::Type::kName:                     return PDFObjectType_Name;
        case CPDF_Object::Type::kArray:                    return PDFObjectType_Array;
        case CPDF_Object::Type::kDictionary:               return PDFObjectType_Dictionary;
        case CPDF_Object::Type::kStream:                   return PDFObjectType_Dictionary;
        case CPDF_Object::Type::kReference:
            // unresolved reference
            return PDFObjectType_Unknown;
        default:
          CPLAssert(false);
          return PDFObjectType_Unknown;
    }
}

/************************************************************************/
/*                          GetTypeNameNative()                         */
/************************************************************************/

const char* GDALPDFObjectPdfium::GetTypeNameNative()
{
    if(m_po->GetType() == CPDF_Object::Type::kStream)
      return ""stream"";
    else
      return """";
}

/************************************************************************/
/*                              GetBool()                               */
/************************************************************************/

int GDALPDFObjectPdfium::GetBool()
{
    return m_po->GetInteger();
}

/************************************************************************/
/*                              GetInt()                                */
/************************************************************************/

int GDALPDFObjectPdfium::GetInt()
{
    return m_po->GetInteger();
}

/************************************************************************/
/*                       CPLRoundToMoreLikelyDouble()                   */
/************************************************************************/

// We try to compensate for rounding errors when converting the number
// in the PDF expressed as a string (e.g 297.84) to float32 by pdfium : 297.8399963378906
// Which is technically correct per the PDF spec, but in practice poppler or podofo use double
// and Geospatial PDF are often encoded with double precision.

static double CPLRoundToMoreLikelyDouble(float f)
{
    if( (float)(int)f == f )
        return f;

    char szBuffer[80];
    CPLsnprintf(szBuffer, 80, ""%f\\n"", f);
    double d = f;
    char* pszDot = strchr(szBuffer, '.');
    if( pszDot == nullptr )
        return d;
    pszDot ++;
    if( pszDot[0] == 0 || pszDot[1] == 0 )
        return d;
    if( STARTS_WITH(pszDot + 2, ""99"") )
    {
        pszDot[2] = 0;
        double d2 = CPLAtof(szBuffer) + 0.01;
        float f2 = (float)d2;
        if( f == f2 || nextafterf(f,f+1.0f) == f2 || nextafterf(f,f-1.0f) == f2 )
            d = d2;
    }
    else if( STARTS_WITH(pszDot + 2, ""00"") )
    {
        pszDot[2] = 0;
        double d2 = CPLAtof(szBuffer);
        float f2 = (float)d2;
        if( f == f2 || nextafterf(f,f+1.0f) == f2 || nextafterf(f,f-1.0f) == f2 )
            d = d2;
    }
    return d;
}

/************************************************************************/
/*                              GetReal()                               */
/************************************************************************/

double GDALPDFObjectPdfium::GetReal()
{
    return CPLRoundToMoreLikelyDouble(m_po->GetNumber());
}

/************************************************************************/
/*                              GetString()                             */
/************************************************************************/

const CPLString& GDALPDFObjectPdfium::GetString()
{
    if (GetType() == PDFObjectType_String) {
        const auto bs = m_po->GetString();
        // If empty string, code crashes
        if(bs.IsEmpty())
          return (osStr = """");
        return (osStr = GDALPDFGetUTF8StringFromBytes(static_cast<const GByte*>(bs.raw_str()),
                                                      static_cast<int>(bs.GetLength())));
    }
    else
        return (osStr = """");
}

/************************************************************************/
/*                              GetName()                               */
/************************************************************************/

const CPLString&  GDALPDFObjectPdfium::GetName()
{
    if (GetType() == PDFObjectType_Name)
        return (osStr = m_po->GetString().c_str());
    else
        return (osStr = """");
}

/************************************************************************/
/*                             GetDictionary()                          */
/************************************************************************/

GDALPDFDictionary* GDALPDFObjectPdfium::GetDictionary()
{
    if (GetType() != PDFObjectType_Dictionary)
        return nullptr;

    if (m_poDict)
        return m_poDict;

    m_poDict = new GDALPDFDictionaryPdfium(m_po->GetDict());
    return m_poDict;
}

/************************************************************************/
/*                                GetArray()                            */
/************************************************************************/

GDALPDFArray* GDALPDFObjectPdfium::GetArray()
{
    if (GetType() != PDFObjectType_Array)
        return nullptr;

    if (m_poArray)
        return m_poArray;

    m_poArray = new GDALPDFArrayPdfium(reinterpret_cast<CPDF_Array*>(m_po));
    return m_poArray;
}

/************************************************************************/
/*                               GetStream()                            */
/************************************************************************/

GDALPDFStream* GDALPDFObjectPdfium::GetStream()
{
    if (m_po->GetType() != CPDF_Object::Type::kStream)
        return nullptr;

    if (m_poStream)
        return m_poStream;
    CPDF_Stream* pStream = reinterpret_cast<CPDF_Stream*>(m_po);
    if (pStream)
    {
        m_poStream = new GDALPDFStreamPdfium(pStream);
        return m_poStream;
    }
    else
        return nullptr;
}

/************************************************************************/
/*                               GetRefNum()                            */
/************************************************************************/

GDALPDFObjectNum GDALPDFObjectPdfium::GetRefNum()
{
    return GDALPDFObjectNum(m_po->GetObjNum());
}

/************************************************************************/
/*                               GetRefGen()                            */
/************************************************************************/

int GDALPDFObjectPdfium::GetRefGen()
{
    return m_po->GetGenNum();
}

/************************************************************************/
/* ==================================================================== */
/*                         GDALPDFDictionaryPdfium                      */
/* ==================================================================== */
/************************************************************************/

/************************************************************************/
/*                         ~GDALPDFDictionaryPdfium()                   */
/************************************************************************/

GDALPDFDictionaryPdfium::~GDALPDFDictionaryPdfium()
{
    std::map<CPLString, GDALPDFObject*>::iterator oIter = m_map.begin();
    std::map<CPLString, GDALPDFObject*>::iterator oEnd = m_map.end();
    for(; oIter != oEnd; ++oIter)
        delete oIter->second;
}

/************************************************************************/
/*                                  Get()                               */
/************************************************************************/

GDALPDFObject* GDALPDFDictionaryPdfium::Get(const char* pszKey)
{
    std::map<CPLString, GDALPDFObject*>::iterator oIter = m_map.find(pszKey);
    if (oIter != m_map.end())
        return oIter->second;

    ByteString pdfiumKey(pszKey);
    CPDF_Object* poVal = m_poDict->GetObjectFor(pdfiumKey);
    GDALPDFObjectPdfium* poObj = GDALPDFObjectPdfium::Build(poVal);
    if (poObj)
    {
        m_map[pszKey] = poObj;
        return poObj;
    }
    else
    {
        return nullptr;
    }
}

/************************************************************************/
/*                              GetValues()                             */
/************************************************************************/

std::map<CPLString, GDALPDFObject*>& GDALPDFDictionaryPdfium::GetValues()
{
    CPDF_DictionaryLocker dictIterator(m_poDict);
    for( const auto& iter: dictIterator )
    {
        // No object for this key
        if( !iter.second )
            continue;

        const char* pszKey = iter.first.c_str();
        // Objects exists in the map
        if(m_map.find(pszKey) != m_map.end())
          continue;
        GDALPDFObjectPdfium* poObj = GDALPDFObjectPdfium::Build(iter.second.Get());
        if( poObj == nullptr )
            continue;
        m_map[pszKey] = poObj;
    }

    return m_map;
}

/************************************************************************/
/* ==================================================================== */
/*                           GDALPDFArrayPdfium                         */
/* ==================================================================== */
/************************************************************************/

GDALPDFArrayPdfium::~GDALPDFArrayPdfium()
{
    for(size_t i=0;i<m_v.size();i++)
    {
        delete m_v[i];
    }
}

/************************************************************************/
/*                              GetLength()                             */
/************************************************************************/

int GDALPDFArrayPdfium::GetLength()
{
    return static_cast<int>(m_poArray->size());
}

/************************************************************************/
/*                                Get()                                 */
/************************************************************************/

GDALPDFObject* GDALPDFArrayPdfium::Get(int nIndex)
{
    if (nIndex < 0 || nIndex >= GetLength())
        return nullptr;

    int nOldSize = static_cast<int>(m_v.size());
    if (nIndex >= nOldSize)
    {
        m_v.resize(nIndex+1);
        for(int i=nOldSize;i<=nIndex;i++)
        {
            m_v[i] = nullptr;
        }
    }

    if (m_v[nIndex] != nullptr)
        return m_v[nIndex];

    CPDF_Object* poVal = m_poArray->GetObjectAt(nIndex);
    GDALPDFObjectPdfium* poObj = GDALPDFObjectPdfium::Build(poVal);
    if( poObj == nullptr )
        return nullptr;
    m_v[nIndex] = poObj;
    return poObj;
}

/************************************************************************/
/* ==================================================================== */
/*                           GDALPDFStreamPdfium                        */
/* ==================================================================== */
/************************************************************************/

void GDALPDFStreamPdfium::Decompress()
{
    if( m_pData != nullptr )
        return;
    auto acc(pdfium::MakeRetain<CPDF_StreamAcc>(m_pStream));
    acc->LoadAllDataFiltered();
    m_nSize = static_cast<int>(acc->GetSize());
    m_pData.reset();
    // We don't use m_pData->Detach() as we don't want to deal with
    // std::unique_ptr<uint8_t, FxFreeDeleter>, and FxFreeDeleter behavior
    // depends on whether GDAL and pdfium are compiled with the same
    // NDEBUG and DCHECK_ALWAYS_ON settings
    if( m_nSize )
    {
        m_pData.reset(static_cast<uint8_t*>(CPLMalloc(m_nSize)));
        memcpy(&m_pData.get()[0], acc->GetData(), m_nSize);
    }
}

/************************************************************************/
/*                              GetLength()                             */
/************************************************************************/

int GDALPDFStreamPdfium::GetLength()
{
    Decompress();
    return m_nSize;
}

/************************************************************************/
/*                               GetBytes()                             */
/************************************************************************/

char* GDALPDFStreamPdfium::GetBytes()
{
    int nLength = GetLength();
    if(nLength == 0)
      return nullptr;
    char* pszContent = (char*) VSIMalloc(sizeof(char)*(nLength + 1));
    if (!pszContent)
        return nullptr;
    memcpy( pszContent, m_pData.get(), nLength);
    pszContent[nLength] = '\\0';
    return pszContent;
}

/************************************************************************/
/*                                FillRaw()                             */
/************************************************************************/

void GDALPDFStreamPdfium::FillRaw()
{
    if( m_pRawData != nullptr )
        return;
    auto acc(pdfium::MakeRetain<CPDF_StreamAcc>(m_pStream));
    acc->LoadAllDataRaw();
    m_nRawSize = static_cast<int>(acc->GetSize());
    m_pRawData.reset();
    // We don't use m_pData->Detach() as we don't want to deal with
    // std::unique_ptr<uint8_t, FxFreeDeleter>, and FxFreeDeleter behavior
    // depends on whether GDAL and pdfium are compiled with the same
    // NDEBUG and DCHECK_ALWAYS_ON settings
    if( m_nRawSize )
    {
        m_pRawData.reset(static_cast<uint8_t*>(CPLMalloc(m_nRawSize)));
        memcpy(&m_pRawData.get()[0], acc->GetData(), m_nRawSize);
    }
}

/************************************************************************/
/*                            GetRawLength()                            */
/************************************************************************/

int GDALPDFStreamPdfium::GetRawLength()
{
    FillRaw();
    return m_nRawSize;
}

/************************************************************************/
/*                             GetRawBytes()                            */
/************************************************************************/

char* GDALPDFStreamPdfium::GetRawBytes()
{
    int nLength = GetRawLength();
    if(nLength == 0)
      return nullptr;
    char* pszContent = (char*) VSIMalloc(sizeof(char)*(nLength + 1));
    if (!pszContent)
        return nullptr;
    memcpy( pszContent, m_pRawData.get(), nLength);
    pszContent[nLength] = '\\0';
    return pszContent;
}


#endif // HAVE_PDFIUM
",16278,True,3268.4796816615185,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 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]
----
@Repository
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]
----
@Repository
public interface GroupRepository extends CrudRepository<GroupInfo, String> {

  @EntityGraph(attributePaths = { ""members"" })
  GroupInfo getByGroupName(String name);

}
----
====


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 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. For details, see JavaDoc of link:$$https://docs.spring.io/spring-data/data-jpa/docs/current/api/index.html?org/springframework/data/jpa/repository/support/SimpleJpaRepository.html$$[`SimpleJpaRepository`]. 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
class UserManagementImpl implements UserManagement {

  private final UserRepository userRepository;
  private final RoleRepository roleRepository;

  @Autowired
  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)
public 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();
  }
}
----
",12075,False,2001.4945823520488,median
"[[export-cypher]]
== Export to Cypher Script

[abstract]
--
This section describes procedures that can be used to export data in Cypher format.
--

The export to Cypher procedures export data as Cypher statements that can then be used to import the data into another Neo4j instance.


[NOTE]
====
When exporting nodes, if a node label does not contain a unique constraint the exporter will add a `UNIQUE IMPORT LABEL` label and `UNIQUE IMPORT ID` property to those nodes to ensure uniqueness of nodes when the export script is executed on a new database.
The final step of the export script removes the `UNIQUE IMPORT LABEL` label and  `UNIQUE IMPORT ID`, so they won't exist in the new database once the script has finished executing.

If a node label does have a unique constraint, the property on which the unique constraint is defined will be used to ensure uniqueness.
====

This section includes:

* <<export-cypher-available-procedures, Available Procedures>>
* <<export-cypher-config, Configuration parameters>>
* <<export-cypher-file-export, Exporting to a file>>
* <<export-cypher-stream-export, Exporting a stream>>
* <<export-cypher-examples, Examples>>
    ** <<export-cypher-cypher-shell, Export to Cypher Shell format>>
    ** <<export-cypher-neo4j-browser, Export to Neo4j Browser friendly format>>
    ** <<export-cypher-multiple-files, Export to multiple files or columns>>
    ** <<export-cypher-different-cypher-format, Export using different Cypher update formats>>
    ** <<export-cypher-examples-roundtrip, Round trip>>


//    ** <<export-cypher-whole-database, Export whole database>>
//    ** <<export-cypher-nodes-relationships, Export specified nodes and relationships>>
//    ** <<export-cypher-graph, Export virtual graph>>
//    ** <<export-cypher-cypher-query, Export results of Cypher query>>
//    ** <<export-cypher-schema, Export database schema>>
//    ** <<export-cypher-examples-roundtrip, Roundtrip Example>>

[[export-cypher-available-procedures]]
=== Available Procedures

The table below describes the available procedures:

// tag::export.cypher[]
[separator=¦,opts=header,cols=""1,1m,1m,5""]
|===
include::../../../build/generated-documentation/apoc.export.cypher.csv[]
|===
// end::export.cypher[]

[NOTE]
The labels exported are ordered alphabetically.
The output of `labels()` function is not sorted, use it in combination with `apoc.coll.sort()`.

[[export-cypher-config]]
=== Configuration parameters
The procedures support the following config parameters:

.Config parameters
[opts=header]
|===
| name | type | default | description
| format | String | cypher-shell a| Export format. The following values are supported:

* `cypher-shell` - for import with Cypher Shell
* `neo4j-shell` - for import with Neo4j Shell and partly the `apoc.cypher.runFile` procedure
* `plain` - exports plain Cypher without `begin`, `commit`, or `await` commands. For import with Neo4j Browser

| cypherFormat | String | create a| Cypher update operation type. The following values are supported:

* `create` - only uses the `CREATE` clause
* `updateAll` - uses `MERGE` instead of `CREATE`
* `addStructure` - uses `MATCH` for nodes and `MERGE` for relationships
* `updateStructure` - uses `MERGE` and `MATCH` for nodes and relationships
| separateFiles | boolean | false | Export to separate files? This is useful for later use with the `apoc.cypher.runFiles` and `apoc.cypher.runSchemaFiles` procedures.
| useOptimizations | Map a| `{type: ""UNWIND_BATCH"", unwindBatchSize: 20}` a| Optimizations to use for Cypher statement generation. `type` supports the following values:

* `NONE` - exports the file with `CREATE` statement
* `UNWIND_BATCH` - exports the file by batching the entities with the `UNWIND` method as explained in Michael Hunger's article on https://medium.com/neo4j/5-tips-tricks-for-fast-batched-updates-of-graph-structures-with-neo4j-and-cypher-73c7f693c8cc[fast batched writes^].
* `UNWIND_BATCH_PARAMS` - similar to `UNWIND_BATCH`, but also uses parameters where appropriate
| awaitForIndexes | Long | 300 | Timeout to use for `db.awaitIndexes` when using `format: ""cypher-shell""`
|===

[[export-cypher-file-export]]
=== Exporting to a file

include::enableFileExport.adoc[]

[[export-cypher-stream-export]]
=== Exporting a stream

If we don't want to export to a file, we can stream results back by providing a file name of `null`.

By default all Cypher statements will be returned in a single row in the `cypherStatements` column.

.The following exports the whole database as a single row
[source,cypher]
----
CALL apoc.export.cypher.all(null);
----

If we're exporting a large database, we can batch these statements across multiple rows by providing the `streamStatements:true` config and configuring the `batchSize` config.

.The following exports the whole database across multiple rows based on batch size
[source,cypher]
----
CALL apoc.export.cypher.all(null, {
    streamStatements: true,
    batchSize: 100
});
----

[[export-cypher-examples]]
=== Examples

This section includes examples showing how to use the export to Cypher procedures.
These examples are based on a movies dataset, which can be imported by running the following Cypher query:

include::createExportGraph.adoc[]

The Neo4j Browser visualization below shows the imported graph:

image::play-movies.png[title=""Movies Graph Visualization""]

[[export-cypher-cypher-shell]]
==== Export to Cypher Shell format

By default, the Cypher statements generated by the export to Cypher procedures are in the Cypher Shell format.


.The following query exports the whole database to `all.cypher` in the default `cypher-shell` format using the default `UNWIND_BATCH` optimization
[source,cypher]
----
// default config populated for illustration
CALL apoc.export.cypher.all(""all.cypher"", {
    format: ""cypher-shell"",
    useOptimizations: {type: ""UNWIND_BATCH"", unwindBatchSize: 20}
})
YIELD file, batches, source, format, nodes, relationships, properties, time, rows, batchSize
RETURN file, batches, source, format, nodes, relationships, properties, time, rows, batchSize;
----

.Results
[opts=""header""]
|===
| file         | batches | source                        | format   | nodes | relationships | properties | time | rows | batchSize
| ""all.cypher"" | 1       | ""database: nodes(8), rels(7)"" | ""cypher"" | 8     | 7             | 21         | 10   | 15   | 20000
|===

The contents of `all.cypher`, with extra lines added for readability, are shown below:

.all.cypher
[source,cypher]
----
:begin
CREATE CONSTRAINT ON (node:`UNIQUE IMPORT LABEL`) ASSERT (node.`UNIQUE IMPORT ID`) IS UNIQUE;
:commit

:begin
UNWIND [{_id:0, properties:{tagline:""Welcome to the Real World"", title:""The Matrix"", released:1999}}] AS row
CREATE (n:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row._id}) SET n += row.properties SET n:Movie;

UNWIND [{_id:1, properties:{born:1964, name:""Keanu Reeves""}}, {_id:2, properties:{born:1967, name:""Carrie-Anne Moss""}}, {_id:3, properties:{born:1961, name:""Laurence Fishburne""}}, {_id:4, properties:{born:1960, name:""Hugo Weaving""}}, {_id:5, properties:{born:1967, name:""Lilly Wachowski""}}, {_id:6, properties:{born:1965, name:""Lana Wachowski""}}, {_id:7, properties:{born:1952, name:""Joel Silver""}}] AS row
CREATE (n:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row._id}) SET n += row.properties SET n:Person;
:commit

:begin
UNWIND [{start: {_id:1}, end: {_id:0}, properties:{roles:[""Neo""]}}, {start: {_id:2}, end: {_id:0}, properties:{roles:[""Trinity""]}}, {start: {_id:3}, end: {_id:0}, properties:{roles:[""Morpheus""]}}, {start: {_id:4}, end: {_id:0}, properties:{roles:[""Agent Smith""]}}] AS row
MATCH (start:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.start._id})
MATCH (end:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.end._id})
CREATE (start)-[r:ACTED_IN]->(end) SET r += row.properties;

UNWIND [{start: {_id:7}, end: {_id:0}, properties:{}}] AS row
MATCH (start:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.start._id})
MATCH (end:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.end._id})
CREATE (start)-[r:PRODUCED]->(end) SET r += row.properties;

UNWIND [{start: {_id:5}, end: {_id:0}, properties:{}}, {start: {_id:6}, end: {_id:0}, properties:{}}] AS row
MATCH (start:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.start._id})
MATCH (end:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.end._id})
CREATE (start)-[r:DIRECTED]->(end) SET r += row.properties;
:commit

:begin
MATCH (n:`UNIQUE IMPORT LABEL`)  WITH n LIMIT 20000 REMOVE n:`UNIQUE IMPORT LABEL` REMOVE n.`UNIQUE IMPORT ID`;
:commit

:begin
DROP CONSTRAINT ON (node:`UNIQUE IMPORT LABEL`) ASSERT (node.`UNIQUE IMPORT ID`) IS UNIQUE;
:commit
----

This Cypher script executes 5 transactions, each surrounded by `:begin` and `:commit` commands.
The transactions do the following:

. Create a unique constraint on the `UNIQUE IMPORT LABEL` label and `UNIQUE IMPORT ID` property
. Import the `Person` and `Movie` nodes
. Create `ACTED_IN`, `PRODUCED`, and `DIRECTED` relationships between these nodes
. Remove the `UNIQUE IMPORT LABEL` label and `UNIQUE IMPORT ID` property from the nodes
. Drop the unique constraint on the `UNIQUE IMPORT LABEL` label and `UNIQUE IMPORT ID` property

This script can be executed using the https://neo4j.com/docs/operations-manual/current/tools/cypher-shell/[Cypher Shell^] command line tool.

For example, we could import the contents of `all.cypher` into a https://neo4j.com/aura[Neo4j Aura^] database by running the following command:

[source,bash]
----
cat all.cypher | ./bin/cypher-shell -a <bolt-url> -u neo4j -p <password> --format verbose
----

[NOTE]
====
Don't forget to replace <bolt-url> and <password> with the appropriate credentials.
====

If we run this command against an empty database, we'll see the following output:

[source,text]
----
0 rows available after 70 ms, consumed after another 0 ms
Added 1 constraints
0 rows available after 16 ms, consumed after another 0 ms
Added 2 nodes, Set 8 properties, Added 4 labels
0 rows available after 40 ms, consumed after another 0 ms
Added 14 nodes, Set 42 properties, Added 28 labels
0 rows available after 51 ms, consumed after another 0 ms
Created 8 relationships, Set 8 properties
0 rows available after 38 ms, consumed after another 0 ms
Created 2 relationships
0 rows available after 38 ms, consumed after another 0 ms
Created 4 relationships
0 rows available after 20 ms, consumed after another 0 ms
Set 16 properties, Removed 16 labels
0 rows available after 3 ms, consumed after another 0 ms
Removed 1 constraints
----

.Troubleshooting
[NOTE]
====
If you are experimenting with imports that are failing you can add the `--debug` command line parameter, to see which statement was executed last and caused the failure.

Also check the memory configuration of your Neo4j instance, you might want to increase the HEAP size to *2–4GB* using the `dbms.memory.heap.max_size=2G` setting in `neo4j.conf`.

We can also provide more memory to cypher-shell itself by prefixing the command with: `JAVA_OPTS=-Xmx4G bin/cypher-shell …`
====


If we don't have file system access, or don't want to write to a file for another reason, we can stream back the export statements.

.The following query streams back the whole database in the `cypherStatements` column
[source,cypher]
----
CALL apoc.export.cypher.all(null, {
    batchSize: 5,
    streamStatements: true,
    format: ""cypher-shell"",
    useOptimizations: {type: ""UNWIND_BATCH"", unwindBatchSize: 5}
})
YIELD nodes, relationships, properties, cypherStatements
RETURN nodes, relationships, properties, cypherStatements;
----

.Results
[opts=""header""]
|===
| nodes | relationships | properties | cypherStatements
| 16    | 0             | 34         a| "":begin
  CREATE CONSTRAINT ON (node:`UNIQUE IMPORT LABEL`) ASSERT (node.`UNIQUE IMPORT ID`) IS UNIQUE;
  :commit
  :begin
  UNWIND [{_id:0, properties:{tagline:\\""Welcome to the Real World\\"", title:\\""The Matrix\\"", released:1999}}, {_id:1, properties:{tagline:\\""Welcome to the Real World\\"", title:\\""The Matrix\\"", released:1999}}] AS row
  CREATE (n:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row._id}) SET n += row.properties SET n:Movie;
  UNWIND [{_id:35, properties:{born:1967, name:\\""Carrie-Anne Moss\\""}}, {_id:36, properties:{born:1961, name:\\""Laurence Fishburne\\""}}, {_id:37, properties:{born:1965, name:\\""Lana Wachowski\\""}}] AS row
  CREATE (n:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row._id}) SET n += row.properties SET n:Person;
  :commit
  :begin
  UNWIND [{_id:38, properties:{born:1964, name:\\""Keanu Reeves\\""}}, {_id:39, properties:{born:1952, name:\\""Joel Silver\\""}}, {_id:40, properties:{born:1960, name:\\""Hugo Weaving\\""}}, {_id:41, properties:{born:1967, name:\\""Lilly Wachowski\\""}}, {_id:42, properties:{born:1967, name:\\""Carrie-Anne Moss\\""}}] AS row
  CREATE (n:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row._id}) SET n += row.properties SET n:Person;
  :commit
  :begin
  UNWIND [{_id:43, properties:{born:1965, name:\\""Lana Wachowski\\""}}, {_id:50, properties:{born:1960, name:\\""Hugo Weaving\\""}}, {_id:51, properties:{born:1964, name:\\""Keanu Reeves\\""}}, {_id:57, properties:{born:1967, name:\\""Lilly Wachowski\\""}}, {_id:58, properties:{born:1961, name:\\""Laurence Fishburne\\""}}] AS row
  CREATE (n:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row._id}) SET n += row.properties SET n:Person;
  :commit
  :begin
  UNWIND [{_id:59, properties:{born:1952, name:\\""Joel Silver\\""}}] AS row
  CREATE (n:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row._id}) SET n += row.properties SET n:Person;
  :commit
  ""
| 16    | 14            | 42         a| "":begin
UNWIND [{start: {_id:35}, end: {_id:0}, properties:{roles:[\\""Trinity\\""]}}, {start: {_id:36}, end: {_id:0}, properties:{roles:[\\""Morpheus\\""]}}, {start: {_id:50}, end: {_id:1}, properties:{roles:[\\""Agent Smith\\""]}}, {start: {_id:40}, end: {_id:0}, properties:{roles:[\\""Agent Smith\\""]}}, {start: {_id:51}, end: {_id:1}, properties:{roles:[\\""Neo\\""]}}] AS row
MATCH (start:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.start._id})
MATCH (end:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.end._id})
CREATE (start)-[r:ACTED_IN]->(end) SET r += row.properties;
:commit
:begin
UNWIND [{start: {_id:42}, end: {_id:1}, properties:{roles:[\\""Trinity\\""]}}, {start: {_id:38}, end: {_id:0}, properties:{roles:[\\""Neo\\""]}}, {start: {_id:58}, end: {_id:1}, properties:{roles:[\\""Morpheus\\""]}}] AS row
MATCH (start:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.start._id})
MATCH (end:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.end._id})
CREATE (start)-[r:ACTED_IN]->(end) SET r += row.properties;
UNWIND [{start: {_id:59}, end: {_id:1}, properties:{}}, {start: {_id:39}, end: {_id:0}, properties:{}}] AS row
MATCH (start:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.start._id})
MATCH (end:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.end._id})
CREATE (start)-[r:PRODUCED]->(end) SET r += row.properties;
:commit
:begin
UNWIND [{start: {_id:37}, end: {_id:0}, properties:{}}, {start: {_id:57}, end: {_id:0}, properties:{}}, {start: {_id:43}, end: {_id:1}, properties:{}}, {start: {_id:41}, end: {_id:1}, properties:{}}] AS row
MATCH (start:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.start._id})
MATCH (end:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.end._id})
CREATE (start)-[r:DIRECTED]->(end) SET r += row.properties;
:commit
""
| 16    | 14            | 42         a| "":begin
MATCH (n:`UNIQUE IMPORT LABEL`)  WITH n LIMIT 5 REMOVE n:`UNIQUE IMPORT LABEL` REMOVE n.`UNIQUE IMPORT ID`;
:commit
:begin
MATCH (n:`UNIQUE IMPORT LABEL`)  WITH n LIMIT 5 REMOVE n:`UNIQUE IMPORT LABEL` REMOVE n.`UNIQUE IMPORT ID`;
:commit
:begin
MATCH (n:`UNIQUE IMPORT LABEL`)  WITH n LIMIT 5 REMOVE n:`UNIQUE IMPORT LABEL` REMOVE n.`UNIQUE IMPORT ID`;
:commit
:begin
MATCH (n:`UNIQUE IMPORT LABEL`)  WITH n LIMIT 5 REMOVE n:`UNIQUE IMPORT LABEL` REMOVE n.`UNIQUE IMPORT ID`;
:commit
:begin
DROP CONSTRAINT ON (node:`UNIQUE IMPORT LABEL`) ASSERT (node.`UNIQUE IMPORT ID`) IS UNIQUE;
:commit
""
|===

We can then copy/paste the content of the `cypherStatements` column (excluding the double quotes) into a Cypher Shell session, or into a local file that we stream into a Cypher Shell session.


[[export-cypher-neo4j-browser]]
==== Export to Neo4j Browser friendly format

The export to Cypher procedures support the config `format: ""plain""`, which is useful for later import using the https://neo4j.com/developer/neo4j-browser/[Neo4j Browser^].

.The following query exports the whole database to `all-plain.cypher`
[source,cypher]
----
CALL apoc.export.cypher.all(""all-plain.cypher"", {
    format: ""plain"",
    useOptimizations: {type: ""UNWIND_BATCH"", unwindBatchSize: 20}
})
YIELD file, batches, source, format, nodes, relationships, properties, time, rows, batchSize
RETURN file, batches, source, format, nodes, relationships, properties, time, rows, batchSize;
----

.Results
[opts=""header""]
|===
| file         | batches | source                        | format   | nodes | relationships | properties | time | rows | batchSize
| ""all-plain.cypher"" | 1       | ""database: nodes(8), rels(7)"" | ""cypher"" | 8     | 7             | 21         | 9    | 15   | 20000
|===

The contents of `all-plain.cypher`, with extra lines added for readability, are shown below:

.all-plain.cypher
[source,cypher]
----
CREATE CONSTRAINT ON (node:`UNIQUE IMPORT LABEL`) ASSERT (node.`UNIQUE IMPORT ID`) IS UNIQUE;

UNWIND [{_id:0, properties:{tagline:""Welcome to the Real World"", title:""The Matrix"", released:1999}}] AS row
CREATE (n:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row._id}) SET n += row.properties SET n:Movie;

UNWIND [{_id:1, properties:{born:1964, name:""Keanu Reeves""}}, {_id:2, properties:{born:1967, name:""Carrie-Anne Moss""}}, {_id:3, properties:{born:1961, name:""Laurence Fishburne""}}, {_id:4, properties:{born:1960, name:""Hugo Weaving""}}, {_id:5, properties:{born:1967, name:""Lilly Wachowski""}}, {_id:6, properties:{born:1965, name:""Lana Wachowski""}}, {_id:7, properties:{born:1952, name:""Joel Silver""}}] AS row
CREATE (n:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row._id}) SET n += row.properties SET n:Person;

UNWIND [{start: {_id:1}, end: {_id:0}, properties:{roles:[""Neo""]}}, {start: {_id:2}, end: {_id:0}, properties:{roles:[""Trinity""]}}, {start: {_id:3}, end: {_id:0}, properties:{roles:[""Morpheus""]}}, {start: {_id:4}, end: {_id:0}, properties:{roles:[""Agent Smith""]}}] AS row
MATCH (start:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.start._id})
MATCH (end:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.end._id})
CREATE (start)-[r:ACTED_IN]->(end) SET r += row.properties;

UNWIND [{start: {_id:7}, end: {_id:0}, properties:{}}] AS row
MATCH (start:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.start._id})
MATCH (end:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.end._id})
CREATE (start)-[r:PRODUCED]->(end) SET r += row.properties;

UNWIND [{start: {_id:5}, end: {_id:0}, properties:{}}, {start: {_id:6}, end: {_id:0}, properties:{}}] AS row
MATCH (start:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.start._id})
MATCH (end:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.end._id})
CREATE (start)-[r:DIRECTED]->(end) SET r += row.properties;

MATCH (n:`UNIQUE IMPORT LABEL`)  WITH n LIMIT 20000 REMOVE n:`UNIQUE IMPORT LABEL` REMOVE n.`UNIQUE IMPORT ID`;

DROP CONSTRAINT ON (node:`UNIQUE IMPORT LABEL`) ASSERT (node.`UNIQUE IMPORT ID`) IS UNIQUE;
----

We can then take the `all-plain.cypher` file and drag it onto the Neo4j Browser window.
We should then see the following prompt:

image::export-cypher-plain-drag.png[title=""Neo4j Browser prompt when we drag a file onto it""]

And if we click `Paste in editor`, the contents of the file will appear in the query editor:

image::export-cypher-plain-editor.png[title=""Neo4j Browser query editor with the contents of `all-plain.cypher`"", width=""800px""]

We can then press the play button next in the editor and the data will be imported.

[[export-cypher-different-cypher-format]]
==== Export using different Cypher update formats

The export to Cypher procedures generate Cypher statements using the `CREATE`, `MATCH` and `MERGE` clauses.
The format is configured by the `cypherFormat` parameter.
The following values are supported:

* `create` - only uses the `CREATE` clause (default)
* `updateAll` - uses `MERGE` instead of `CREATE`
* `addStructure` - uses `MATCH` for nodes and `MERGE` for relationships
* `updateStructure` - uses `MERGE` and `MATCH` for nodes and relationships

If we're exporting a database for the first time we should use the default `create` format, but for subsequent exports the other formats may be more suitable.

.The following exports the `ACTED_IN` relationships and surrounding nodes to `export-cypher-format-create.cypher` using the `create` format
[source,cypher]
----
MATCH (person)-[r:ACTED_IN]->(movie)
WITH collect(DISTINCT person) + collect(DISTINCT  movie) AS importNodes, collect(r) AS importRels
CALL apoc.export.cypher.data(importNodes, importRels,
  ""export-cypher-format-create.cypher"",
  { format: ""plain"", cypherFormat: ""create"" })
YIELD file, batches, source, format, nodes, relationships, properties, time, rows, batchSize
RETURN file, batches, source, format, nodes, relationships, properties, time, rows, batchSize;
----

.Results
[opts=""header""]
|===
| file                                 | batches | source                         | format   | nodes | relationships | properties | time | rows | batchSize
| ""export-cypher-format-create.cypher"" | 1       | ""data: nodes(5), rels(4)"" | ""cypher"" | 5     | 4             | 15         | 2    | 9    | 20000
|===

.export-cypher-format-create.cypher
[source,cypher]
----
CREATE CONSTRAINT ON (node:`UNIQUE IMPORT LABEL`) ASSERT (node.`UNIQUE IMPORT ID`) IS UNIQUE;
UNWIND [{_id:0, properties:{tagline:""Welcome to the Real World"", title:""The Matrix"", released:1999}}] AS row
CREATE (n:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row._id}) SET n += row.properties SET n:Movie;

UNWIND [{_id:7, properties:{born:1967, name:""Carrie-Anne Moss""}},
        {_id:80, properties:{born:1960, name:""Hugo Weaving""}},
        {_id:27, properties:{born:1964, name:""Keanu Reeves""}},
        {_id:44, properties:{born:1961, name:""Laurence Fishburne""}}] AS row
CREATE (n:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row._id}) SET n += row.properties SET n:Person;

UNWIND [{start: {_id:27}, end: {_id:0}, properties:{roles:[""Neo""]}},
        {start: {_id:7}, end: {_id:0}, properties:{roles:[""Trinity""]}},
        {start: {_id:44}, end: {_id:0}, properties:{roles:[""Morpheus""]}},
        {start: {_id:80}, end: {_id:0}, properties:{roles:[""Agent Smith""]}}] AS row
MATCH (start:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.start._id})
MATCH (end:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.end._id})
CREATE (start)-[r:ACTED_IN]->(end) SET r += row.properties;

MATCH (n:`UNIQUE IMPORT LABEL`)  WITH n LIMIT 20000 REMOVE n:`UNIQUE IMPORT LABEL` REMOVE n.`UNIQUE IMPORT ID`;
DROP CONSTRAINT ON (node:`UNIQUE IMPORT LABEL`) ASSERT (node.`UNIQUE IMPORT ID`) IS UNIQUE;
----

The creation of all graph entities uses the Cypher `CREATE` clause.
If those entities may already exist in the destination database, we may choose to use another format.
Using `cypherFormat: ""updateAll""` means that the `MERGE` clause will be used instead of `CREATE` when creating entities.

.The following exports the `ACTED_IN` relationships and surrounding nodes to `export-cypher-format-create.cypher` using the `updateAll` format
[source,cypher]
----
MATCH (person)-[r:ACTED_IN]->(movie)
WITH collect(DISTINCT person) + collect(DISTINCT  movie) AS importNodes, collect(r) AS importRels
CALL apoc.export.cypher.data(importNodes, importRels,
  ""export-cypher-format-updateAll.cypher"",
  { format: ""plain"", cypherFormat: ""updateAll"" })
YIELD file, batches, source, format, nodes, relationships, properties, time, rows, batchSize
RETURN file, batches, source, format, nodes, relationships, properties, time, rows, batchSize;
----

.Results
[opts=""header""]
|===
| file                                 | batches | source                         | format   | nodes | relationships | properties | time | rows | batchSize
| ""export-cypher-format-updateAll.cypher"" | 1       | ""data: nodes(5), rels(4)"" | ""cypher"" | 5     | 4             | 15         | 8    | 9    | 20000
|===


.export-cypher-format-updateAll.cypher
[source,cypher]
----
CREATE CONSTRAINT ON (node:`UNIQUE IMPORT LABEL`) ASSERT (node.`UNIQUE IMPORT ID`) IS UNIQUE;
UNWIND [{_id:0, properties:{tagline:""Welcome to the Real World"", title:""The Matrix"", released:1999}}] AS row
MERGE (n:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row._id}) SET n += row.properties SET n:Movie;

UNWIND [{_id:80, properties:{born:1960, name:""Hugo Weaving""}},
        {_id:7, properties:{born:1967, name:""Carrie-Anne Moss""}},
        {_id:44, properties:{born:1961, name:""Laurence Fishburne""}},
        {_id:27, properties:{born:1964, name:""Keanu Reeves""}}] AS row
MERGE (n:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row._id}) SET n += row.properties SET n:Person;

UNWIND [{start: {_id:27}, end: {_id:0}, properties:{roles:[""Neo""]}},
        {start: {_id:7}, end: {_id:0}, properties:{roles:[""Trinity""]}},
        {start: {_id:44}, end: {_id:0}, properties:{roles:[""Morpheus""]}},
        {start: {_id:80}, end: {_id:0}, properties:{roles:[""Agent Smith""]}}] AS row
MATCH (start:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.start._id})
MATCH (end:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.end._id})
MERGE (start)-[r:ACTED_IN]->(end) SET r += row.properties;

MATCH (n:`UNIQUE IMPORT LABEL`)  WITH n LIMIT 20000 REMOVE n:`UNIQUE IMPORT LABEL` REMOVE n.`UNIQUE IMPORT ID`;
DROP CONSTRAINT ON (node:`UNIQUE IMPORT LABEL`) ASSERT (node.`UNIQUE IMPORT ID`) IS UNIQUE;
----

If we already have the nodes in our destination database, we can use `cypherFormat: ""addStructure""` to create Cypher `CREATE` statements for just the relationships.

.The following exports the `ACTED_IN` relationships and surrounding nodes to `export-cypher-format-addStructure.cypher` using the `addStructure` format
[source,cypher]
----
MATCH (person)-[r:ACTED_IN]->(movie)
WITH collect(DISTINCT person) + collect(DISTINCT  movie) AS importNodes, collect(r) AS importRels
CALL apoc.export.cypher.data(importNodes, importRels,
  ""export-cypher-format-addStructure.cypher"",
  { format: ""plain"", cypherFormat: ""addStructure"" })
YIELD file, batches, source, format, nodes, relationships, properties, time, rows, batchSize
RETURN file, batches, source, format, nodes, relationships, properties, time, rows, batchSize;
----

.Results
[opts=""header""]
|===
| file                                 | batches | source                         | format   | nodes | relationships | properties | time | rows | batchSize
| ""export-cypher-format-addStructure.cypher"" | 1       | ""data: nodes(5), rels(4)"" | ""cypher"" | 5     | 4             | 15         | 4    | 9    | 20000
|===

.export-cypher-format-addStructure.cypher
[source,cypher]
----
UNWIND [{_id:0, properties:{tagline:""Welcome to the Real World"", title:""The Matrix"", released:1999}}] AS row
MERGE (n:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row._id}) ON CREATE SET n += row.properties SET n:Movie;

UNWIND [{_id:7, properties:{born:1967, name:""Carrie-Anne Moss""}},
        {_id:27, properties:{born:1964, name:""Keanu Reeves""}},
        {_id:80, properties:{born:1960, name:""Hugo Weaving""}},
        {_id:44, properties:{born:1961, name:""Laurence Fishburne""}}] AS row
MERGE (n:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row._id}) ON CREATE SET n += row.properties SET n:Person;

UNWIND [{start: {_id:27}, end: {_id:0}, properties:{roles:[""Neo""]}},
        {start: {_id:7}, end: {_id:0}, properties:{roles:[""Trinity""]}},
        {start: {_id:44}, end: {_id:0}, properties:{roles:[""Morpheus""]}},
        {start: {_id:80}, end: {_id:0}, properties:{roles:[""Agent Smith""]}}] AS row
MATCH (start:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.start._id})
MATCH (end:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.end._id})
CREATE (start)-[r:ACTED_IN]->(end)  SET r += row.properties;
----

In this example we're using the `MERGE` clause to create a node if it doesn't already exist, and are only creating properties if the node doesn't already exist.
In this example, relationships don't exist in the destination database and need to be created.

If those relationships do exist but have properties that need to be updated, we can use `cypherFormat: ""updateStructure""` to create our import script.

.The following exports the `ACTED_IN` relationships and surrounding nodes to `export-cypher-format-updateStructure.cypher` using the `updateStructure` format
[source,cypher]
----
MATCH (person)-[r:ACTED_IN]->(movie)
WITH collect(DISTINCT person) + collect(DISTINCT  movie) AS importNodes, collect(r) AS importRels
CALL apoc.export.cypher.data(importNodes, importRels,
  ""export-cypher-format-updateStructure.cypher"",
  { format: ""plain"", cypherFormat: ""updateStructure"" })
YIELD file, batches, source, format, nodes, relationships, properties, time, rows, batchSize
RETURN file, batches, source, format, nodes, relationships, properties, time, rows, batchSize;
----

.Results
[opts=""header""]
|===
| file                                 | batches | source                         | format   | nodes | relationships | properties | time | rows | batchSize
| ""export-cypher-format-updateStructure.cypher"" | 1       | ""data: nodes(5), rels(4)"" | ""cypher"" | 0     | 4             | 4          | 2    | 4    | 20000
|===

.export-cypher-format-updateStructure.cypher
[source,cypher]
----
UNWIND [{start: {_id:27}, end: {_id:0}, properties:{roles:[""Neo""]}},
        {start: {_id:7}, end: {_id:0}, properties:{roles:[""Trinity""]}},
        {start: {_id:44}, end: {_id:0}, properties:{roles:[""Morpheus""]}},
        {start: {_id:80}, end: {_id:0}, properties:{roles:[""Agent Smith""]}}] AS row
MATCH (start:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.start._id})
MATCH (end:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.end._id})
MERGE (start)-[r:ACTED_IN]->(end) SET r += row.properties;

----


[[export-cypher-multiple-files]]
==== Export to multiple files or columns

The export to Cypher procedures all support writing to multiple files or multiple columns.
We can enable this mode by passing in the config `separateFiles: true`

.The following query exports all the `ACTED_IN` relationships and corresponding nodes into files with an `actedIn` prefix
[source,cypher]
----
CALL apoc.export.cypher.query(
  ""MATCH ()-[r:ACTED_IN]->()
   RETURN *"",
  ""actedIn.cypher"",
  { format: ""cypher-shell"", separateFiles: true })
YIELD file, batches, source, format, nodes, relationships, time, rows, batchSize
RETURN file, batches, source, format, nodes, relationships, time, rows, batchSize;
----

.Results
[opts=""header""]
|===
| file | batches | source                          | format   | nodes | relationships | time | rows | batchSize
| ""actedIn.cypher"" | 1       | ""statement: nodes(10), rels(8)"" | ""cypher"" | 10    | 8             | 3    | 18   | 20000
|===

This will result in the following files being created:

.Results
[opts=""header""]
|===
| Name | Size in bytes | Number of lines
| actedIn.cleanup.cypher | 234 | 6
| actedIn.nodes.cypher | 893 | 6
| actedIn.relationships.cypher | 757 | 6
| actedIn.schema.cypher | 109 | 3
|===

Each of those files contains one particular part of the graph.
Let's have a look at their content:

.actedIn.cleanup.cypher
[source,cypher]
----
:begin
MATCH (n:`UNIQUE IMPORT LABEL`)  WITH n LIMIT 20000 REMOVE n:`UNIQUE IMPORT LABEL` REMOVE n.`UNIQUE IMPORT ID`;
:commit
:begin
DROP CONSTRAINT ON (node:`UNIQUE IMPORT LABEL`) ASSERT (node.`UNIQUE IMPORT ID`) IS UNIQUE;
:commit
----

.actedIn.nodes.cypher
[source,cypher]
----
:begin
UNWIND [{_id:28, properties:{tagline:""Welcome to the Real World"", title:""The Matrix"", released:1999}}, {_id:37, properties:{tagline:""Welcome to the Real World"", title:""The Matrix"", released:1999}}] AS row
CREATE (n:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row._id}) SET n += row.properties SET n:Movie;
UNWIND [{_id:31, properties:{born:1961, name:""Laurence Fishburne""}}, {_id:30, properties:{born:1967, name:""Carrie-Anne Moss""}}, {_id:42, properties:{born:1964, name:""Keanu Reeves""}}, {_id:0, properties:{born:1960, name:""Hugo Weaving""}}, {_id:29, properties:{born:1964, name:""Keanu Reeves""}}, {_id:38, properties:{born:1960, name:""Hugo Weaving""}}, {_id:43, properties:{born:1967, name:""Carrie-Anne Moss""}}, {_id:57, properties:{born:1961, name:""Laurence Fishburne""}}] AS row
CREATE (n:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row._id}) SET n += row.properties SET n:Person;
:commit
----

.actedIn.relationships.cypher
[source,cypher]
----
:begin
UNWIND [{start: {_id:31}, end: {_id:28}, properties:{roles:[""Morpheus""]}}, {start: {_id:42}, end: {_id:37}, properties:{roles:[""Neo""]}}, {start: {_id:38}, end: {_id:37}, properties:{roles:[""Agent Smith""]}}, {start: {_id:0}, end: {_id:28}, properties:{roles:[""Agent Smith""]}}, {start: {_id:29}, end: {_id:28}, properties:{roles:[""Neo""]}}, {start: {_id:43}, end: {_id:37}, properties:{roles:[""Trinity""]}}, {start: {_id:30}, end: {_id:28}, properties:{roles:[""Trinity""]}}, {start: {_id:57}, end: {_id:37}, properties:{roles:[""Morpheus""]}}] AS row
MATCH (start:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.start._id})
MATCH (end:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.end._id})
CREATE (start)-[r:ACTED_IN]->(end) SET r += row.properties;
:commit
----

.actedIn.schema.cypher
[source,cypher]
----
:begin
CREATE CONSTRAINT ON (node:`UNIQUE IMPORT LABEL`) ASSERT (node.`UNIQUE IMPORT ID`) IS UNIQUE;
:commit
----

We can then apply these files to our destination Neo4j instance, either by streaming their contents into Cypher Shell or by using the procedures described in <<running-cypher>>

We can also use the `separateFiles` when returning a stream of export statements.
The results will appear in columns named `nodeStatements`, `relationshipStatements`, `cleanupStatements`, and `schemaStatements` rather than `cypherStatements`.


.The following query returns a stream all the `ACTED_IN` relationships and corresponding nodes
[source,cypher]
----
CALL apoc.export.cypher.query(
  ""MATCH ()-[r:ACTED_IN]->()
   RETURN *"",
  null,
  { format: ""cypher-shell"", separateFiles: true })
YIELD nodes, relationships, properties, nodeStatements, relationshipStatements, cleanupStatements, schemaStatements
RETURN nodes, relationships, properties, nodeStatements, relationshipStatements, cleanupStatements, schemaStatements;
----

.Results
[opts=""header""]
|===
| nodes | relationships | properties | nodeStatements | relationshipStatements | cleanupStatements | schemaStatements
| 10    | 8             | 30         | "":begin
  UNWIND [{_id:28, properties:{tagline:\\""Welcome to the Real World\\"", title:\\""The Matrix\\"", released:1999}}, {_id:37, properties:{tagline:\\""Welcome to the Real World\\"", title:\\""The Matrix\\"", released:1999}}] AS row
  CREATE (n:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row._id}) SET n += row.properties SET n:Movie;
  UNWIND [{_id:0, properties:{born:1960, name:\\""Hugo Weaving\\""}}, {_id:42, properties:{born:1964, name:\\""Keanu Reeves\\""}}, {_id:31, properties:{born:1961, name:\\""Laurence Fishburne\\""}}, {_id:29, properties:{born:1964, name:\\""Keanu Reeves\\""}}, {_id:30, properties:{born:1967, name:\\""Carrie-Anne Moss\\""}}, {_id:43, properties:{born:1967, name:\\""Carrie-Anne Moss\\""}}, {_id:38, properties:{born:1960, name:\\""Hugo Weaving\\""}}, {_id:57, properties:{born:1961, name:\\""Laurence Fishburne\\""}}] AS row
  CREATE (n:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row._id}) SET n += row.properties SET n:Person;
  :commit
  "" | "":begin
  UNWIND [{start: {_id:31}, end: {_id:28}, properties:{roles:[\\""Morpheus\\""]}}, {start: {_id:38}, end: {_id:37}, properties:{roles:[\\""Agent Smith\\""]}}, {start: {_id:0}, end: {_id:28}, properties:{roles:[\\""Agent Smith\\""]}}, {start: {_id:30}, end: {_id:28}, properties:{roles:[\\""Trinity\\""]}}, {start: {_id:29}, end: {_id:28}, properties:{roles:[\\""Neo\\""]}}, {start: {_id:43}, end: {_id:37}, properties:{roles:[\\""Trinity\\""]}}, {start: {_id:42}, end: {_id:37}, properties:{roles:[\\""Neo\\""]}}, {start: {_id:57}, end: {_id:37}, properties:{roles:[\\""Morpheus\\""]}}] AS row
  MATCH (start:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.start._id})
  MATCH (end:`UNIQUE IMPORT LABEL`{`UNIQUE IMPORT ID`: row.end._id})
  CREATE (start)-[r:ACTED_IN]->(end) SET r += row.properties;
  :commit
  "" | "":begin
  MATCH (n:`UNIQUE IMPORT LABEL`)  WITH n LIMIT 20000 REMOVE n:`UNIQUE IMPORT LABEL` REMOVE n.`UNIQUE IMPORT ID`;
  :commit
  :begin
  DROP CONSTRAINT ON (node:`UNIQUE IMPORT LABEL`) ASSERT (node.`UNIQUE IMPORT ID`) IS UNIQUE;
  :commit
  "" | "":begin
  CREATE CONSTRAINT ON (node:`UNIQUE IMPORT LABEL`) ASSERT (node.`UNIQUE IMPORT ID`) IS UNIQUE;
  :commit
  ""
|===

We can then copy/paste the content of each of these columns (excluding the double quotes) into a Cypher Shell session, or into a local file that we stream into a Cypher Shell session.
If we want to export Cypher statements that can be pasted into the Neo4j Browser query editor, we need to use the config `format: ""plain""`, as described in <<export-cypher-neo4j-browser>>.

[[export-cypher-examples-roundtrip]]
==== Round trip

This example shows how to export data from one Neo4j instance (the source database) and import it into another one (the destination database).


.The following exports 100 nodes and relationships from the source database in `plain` format into multiple files
[source,cypher]
----
CALL apoc.export.cypher.query(
    ""match (n)-[r]->(n2) return * limit 100"",
    ""/tmp/mysubset.cypher"",
    {format:'plain',separateFiles:true}
)
YIELD file, batches, source, format, nodes, relationships, time, rows, batchSize
RETURN file, batches, source, format, nodes, relationships, time, rows, batchSize;
----

.Results
[opts=""header""]
|===
| file                   | batches | source                           | format   | nodes | relationships | time | rows | batchSize
|  ""/tmp/mysubset.cypher"" | 1       | ""statement: nodes(16), rels(14)"" | ""cypher"" | 16    | 14            | 9    | 30   | 20000
|===


This should result in 4 files in your directory.

[source,shell]
----
ls -1 /tmp/mysubset.*
/tmp/mysubset.cleanup.cypher
/tmp/mysubset.nodes.cypher
/tmp/mysubset.relationships.cypher
/tmp/mysubset.schema.cypher
----

Now let's copy those files so they're accessible from our destination database.
We'll need to first add the following property to `apoc.conf`:

.apoc.conf
[source,properties]
----
apoc.import.file.enabled=true
----

And now we're going to use procedures from <<running-cypher>> to import the data.

.The following imports the schema
[source,cypher]
----
CALL apoc.cypher.runSchemaFile('/tmp/mysubset.schema.cypher');
----

.Results
[opts=""header""]
|===
| row | result
|  -1  | {constraintsRemoved: 0, indexesRemoved: 0, nodesCreated: 0, rows: 0, propertiesSet: 0, labelsRemoved: 0, relationshipsDeleted: 0, constraintsAdded: 0, nodesDeleted: 0, indexesAdded: 0, labelsAdded: 0, r
   elationshipsCreated: 0, time: 0}
|===

.The following imports the nodes and relationships
[source,cypher]
----
CALL apoc.cypher.runFiles(['/tmp/mysubset.nodes.cypher','/tmp/mysubset.relationships.cypher']);
----

.Results
[opts=""header""]
|===
| row | result
| -1  | {constraintsRemoved: 0, indexesRemoved: 0, nodesCreated: 2, rows: 0, propertiesSet: 8, labelsRemoved: 0, relationshipsDeleted: 0, constraintsAdded: 0, nodesDeleted: 0, indexesAdded: 0, labelsAdded: 4, r
elationshipsCreated: 0, time: 0}
| -1  | {constraintsRemoved: 0, indexesRemoved: 0, nodesCreated: 14, rows: 0, propertiesSet: 42, labelsRemoved: 0, relationshipsDeleted: 0, constraintsAdded: 0, nodesDeleted: 0, indexesAdded: 0, labelsAdded: 28
, relationshipsCreated: 0, time: 0}
| -1  | {constraintsRemoved: 0, indexesRemoved: 0, nodesCreated: 0, rows: 0, propertiesSet: 8, labelsRemoved: 0, relationshipsDeleted: 0, constraintsAdded: 0, nodesDeleted: 0, indexesAdded: 0, labelsAdded: 0, r
elationshipsCreated: 8, time: 0}
| -1  | {constraintsRemoved: 0, indexesRemoved: 0, nodesCreated: 0, rows: 0, propertiesSet: 0, labelsRemoved: 0, relationshipsDeleted: 0, constraintsAdded: 0, nodesDeleted: 0, indexesAdded: 0, labelsAdded: 0, r
elationshipsCreated: 2, time: 0}
| -1  | {constraintsRemoved: 0, indexesRemoved: 0, nodesCreated: 0, rows: 0, propertiesSet: 0, labelsRemoved: 0, relationshipsDeleted: 0, constraintsAdded: 0, nodesDeleted: 0, indexesAdded: 0, labelsAdded: 0, r
elationshipsCreated: 4, time: 0}
|===

.The following removes temporary node labels and properties
[source,cypher]
----
CALL apoc.cypher.runFile('/tmp/mysubset.cleanup.cypher');
----

.Results
[opts=""header""]
|===
| row | result
|  -1  | {constraintsRemoved: 0, indexesRemoved: 0, nodesCreated: 0, rows: 0, propertiesSet: 16, labelsRemoved: 16, relationshipsDeleted: 0, constraintsAdded: 0, nodesDeleted: 0, indexesAdded: 0, labelsAdded: 0,
    relationshipsCreated: 0, time: 0}
|===

.The following drops the import specific constraint
[source,cypher]
----
CALL apoc.cypher.runSchemaFile('/tmp/mysubset.cleanup.cypher');
----

.Results
[opts=""header""]
|===
| row | result
|  -1  | {constraintsRemoved: 1, indexesRemoved: 0, nodesCreated: 0, rows: 0, propertiesSet: 0, labelsRemoved: 0, relationshipsDeleted: 0, constraintsAdded: 0, nodesDeleted: 0, indexesAdded: 0, labelsAdded: 0, r
   elationshipsCreated: 0, time: 0}
|===


The `apoc.cypher.run*` procedures have some optional config:

* `{statistics:true/false}` to output a row of update-stats per statement, default is true
* `{timeout:1 or 10}` for how long the stream waits for new data, default is 10

Make sure to set the config options in your `neo4j.conf`

",12227,True,2864.2263491741896,median
"[[features.testing]]
== Testing
Spring Boot provides a number of utilities and annotations to help when testing your application.
Test support is provided by two modules: `spring-boot-test` contains core items, and `spring-boot-test-autoconfigure` supports auto-configuration for tests.

Most developers use the `spring-boot-starter-test` ""`Starter`"", which imports both Spring Boot test modules as well as JUnit Jupiter, AssertJ, Hamcrest, and a number of other useful libraries.

[TIP]
====
If you have tests that use JUnit 4, JUnit 5's vintage engine can be used to run them.
To use the vintage engine, add a dependency on `junit-vintage-engine`, as shown in the following example:

[source,xml,indent=0,subs=""verbatim""]
----
	<dependency>
		<groupId>org.junit.vintage</groupId>
		<artifactId>junit-vintage-engine</artifactId>
		<scope>test</scope>
		<exclusions>
			<exclusion>
				<groupId>org.hamcrest</groupId>
				<artifactId>hamcrest-core</artifactId>
			</exclusion>
		</exclusions>
	</dependency>
----
====

`hamcrest-core` is excluded in favor of `org.hamcrest:hamcrest` that is part of `spring-boot-starter-test`.



[[features.testing.test-scope-dependencies]]
=== Test Scope Dependencies
The `spring-boot-starter-test` ""`Starter`"" (in the `test` `scope`) contains the following provided libraries:

* https://junit.org/junit5/[JUnit 5]: The de-facto standard for unit testing Java applications.
* {spring-framework-docs}/testing.html#integration-testing[Spring Test] & Spring Boot Test: Utilities and integration test support for Spring Boot applications.
* https://assertj.github.io/doc/[AssertJ]: A fluent assertion library.
* https://github.com/hamcrest/JavaHamcrest[Hamcrest]: A library of matcher objects (also known as constraints or predicates).
* https://site.mockito.org/[Mockito]: A Java mocking framework.
* https://github.com/skyscreamer/JSONassert[JSONassert]: An assertion library for JSON.
* https://github.com/jayway/JsonPath[JsonPath]: XPath for JSON.

We generally find these common libraries to be useful when writing tests.
If these libraries do not suit your needs, you can add additional test dependencies of your own.



[[features.testing.spring-applications]]
=== Testing Spring Applications
One of the major advantages of dependency injection is that it should make your code easier to unit test.
You can instantiate objects by using the `new` operator without even involving Spring.
You can also use _mock objects_ instead of real dependencies.

Often, you need to move beyond unit testing and start integration testing (with a Spring `ApplicationContext`).
It is useful to be able to perform integration testing without requiring deployment of your application or needing to connect to other infrastructure.

The Spring Framework includes a dedicated test module for such integration testing.
You can declare a dependency directly to `org.springframework:spring-test` or use the `spring-boot-starter-test` ""`Starter`"" to pull it in transitively.

If you have not used the `spring-test` module before, you should start by reading the {spring-framework-docs}/testing.html#testing[relevant section] of the Spring Framework reference documentation.



[[features.testing.spring-boot-applications]]
=== Testing Spring Boot Applications
A Spring Boot application is a Spring `ApplicationContext`, so nothing very special has to be done to test it beyond what you would normally do with a vanilla Spring context.

NOTE: External properties, logging, and other features of Spring Boot are installed in the context by default only if you use `SpringApplication` to create it.

Spring Boot provides a `@SpringBootTest` annotation, which can be used as an alternative to the standard `spring-test` `@ContextConfiguration` annotation when you need Spring Boot features.
The annotation works by <<features#features.testing.spring-boot-applications.detecting-configuration,creating the `ApplicationContext` used in your tests through `SpringApplication`>>.
In addition to `@SpringBootTest` a number of other annotations are also provided for <<features#features.testing.spring-boot-applications.autoconfigured-tests,testing more specific slices>> of an application.

TIP: If you are using JUnit 4, don't forget to also add `@RunWith(SpringRunner.class)` to your test, otherwise the annotations will be ignored.
If you are using JUnit 5, there's no need to add the equivalent `@ExtendWith(SpringExtension.class)` as `@SpringBootTest` and the other `@...Test` annotations are already annotated with it.

By default, `@SpringBootTest` will not start a server.
You can use the `webEnvironment` attribute of `@SpringBootTest` to further refine how your tests run:

* `MOCK`(Default) : Loads a web `ApplicationContext` and provides a mock web environment.
  Embedded servers are not started when using this annotation.
	If a web environment is not available on your classpath, this mode transparently falls back to creating a regular non-web `ApplicationContext`.
	It can be used in conjunction with <<features#features.testing.spring-boot-applications.with-mock-environment, `@AutoConfigureMockMvc` or `@AutoConfigureWebTestClient`>> for mock-based testing of your web application.
* `RANDOM_PORT`: Loads a `WebServerApplicationContext` and provides a real web environment.
  Embedded servers are started and listen on a random port.
* `DEFINED_PORT`: Loads a `WebServerApplicationContext` and provides a real web environment.
  Embedded servers are started and listen on a defined port (from your `application.properties`) or on the default port of `8080`.
* `NONE`: Loads an `ApplicationContext` by using `SpringApplication` but does not provide _any_ web environment (mock or otherwise).

NOTE: If your test is `@Transactional`, it rolls back the transaction at the end of each test method by default.
However, as using this arrangement with either `RANDOM_PORT` or `DEFINED_PORT` implicitly provides a real servlet environment, the HTTP client and server run in separate threads and, thus, in separate transactions.
Any transaction initiated on the server does not roll back in this case.

NOTE: `@SpringBootTest` with `webEnvironment = WebEnvironment.RANDOM_PORT` will also start the management server on a separate random port if your application uses a different port for the management server.



[[features.testing.spring-boot-applications.detecting-web-app-type]]
==== Detecting Web Application Type
If Spring MVC is available, a regular MVC-based application context is configured.
If you have only Spring WebFlux, we'll detect that and configure a WebFlux-based application context instead.

If both are present, Spring MVC takes precedence.
If you want to test a reactive web application in this scenario, you must set the configprop:spring.main.web-application-type[] property:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/detectingwebapptype/MyWebFluxTests.java[]
----



[[features.testing.spring-boot-applications.detecting-configuration]]
==== Detecting Test Configuration
If you are familiar with the Spring Test Framework, you may be used to using `@ContextConfiguration(classes=...)` in order to specify which Spring `@Configuration` to load.
Alternatively, you might have often used nested `@Configuration` classes within your test.

When testing Spring Boot applications, this is often not required.
Spring Boot's `@*Test` annotations search for your primary configuration automatically whenever you do not explicitly define one.

The search algorithm works up from the package that contains the test until it finds a class annotated with `@SpringBootApplication` or `@SpringBootConfiguration`.
As long as you <<using#using.structuring-your-code, structured your code>> in a sensible way, your main configuration is usually found.

[NOTE]
====
If you use a <<features#features.testing.spring-boot-applications.autoconfigured-tests, test annotation to test a more specific slice of your application>>, you should avoid adding configuration settings that are specific to a particular area on the <<features#features.testing.spring-boot-applications.user-configuration-and-slicing, main method's application class>>.

The underlying component scan configuration of `@SpringBootApplication` defines exclude filters that are used to make sure slicing works as expected.
If you are using an explicit `@ComponentScan` directive on your `@SpringBootApplication`-annotated class, be aware that those filters will be disabled.
If you are using slicing, you should define them again.
====

If you want to customize the primary configuration, you can use a nested `@TestConfiguration` class.
Unlike a nested `@Configuration` class, which would be used instead of your application's primary configuration, a nested `@TestConfiguration` class is used in addition to your application's primary configuration.

NOTE: Spring's test framework caches application contexts between tests.
Therefore, as long as your tests share the same configuration (no matter how it is discovered), the potentially time-consuming process of loading the context happens only once.



[[features.testing.spring-boot-applications.excluding-configuration]]
==== Excluding Test Configuration
If your application uses component scanning (for example, if you use `@SpringBootApplication` or `@ComponentScan`), you may find top-level configuration classes that you created only for specific tests accidentally get picked up everywhere.

As we <<features#features.testing.spring-boot-applications.detecting-configuration,have seen earlier>>, `@TestConfiguration` can be used on an inner class of a test to customize the primary configuration.
When placed on a top-level class, `@TestConfiguration` indicates that classes in `src/test/java` should not be picked up by scanning.
You can then import that class explicitly where it is required, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/excludingconfiguration/MyTests.java[]
----

NOTE: If you directly use `@ComponentScan` (that is, not through `@SpringBootApplication`) you need to register the `TypeExcludeFilter` with it.
See {spring-boot-module-api}/context/TypeExcludeFilter.html[the Javadoc] for details.



[[features.testing.spring-boot-applications.using-application-arguments]]
==== Using Application Arguments
If your application expects <<features#features.spring-application.application-arguments,arguments>>, you can
have `@SpringBootTest` inject them using the `args` attribute.

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/usingapplicationarguments/MyApplicationArgumentTests.java[]
----



[[features.testing.spring-boot-applications.with-mock-environment]]
==== Testing with a mock environment
By default, `@SpringBootTest` does not start the server.
If you have web endpoints that you want to test against this mock environment, you can additionally configure {spring-framework-docs}/testing.html#spring-mvc-test-framework[`MockMvc`] as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/withmockenvironment/MyMockMvcTests.java[]
----

TIP: If you want to focus only on the web layer and not start a complete `ApplicationContext`, consider <<features#features.testing.spring-boot-applications.spring-mvc-tests,using `@WebMvcTest` instead>>.

Alternatively, you can configure a {spring-framework-docs}/testing.html#webtestclient-tests[`WebTestClient`] as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/withmockenvironment/MyMockWebTestClientTests.java[]
----

[TIP]
====
Testing within a mocked environment is usually faster than running with a full Servlet container.
However, since mocking occurs at the Spring MVC layer, code that relies on lower-level Servlet container behavior cannot be directly tested with MockMvc.

For example, Spring Boot's error handling is based on the ""`error page`"" support provided by the Servlet container.
This means that, whilst you can test your MVC layer throws and handles exceptions as expected, you cannot directly test that a specific <<features#features.developing-web-applications.spring-mvc.error-handling.error-pages, custom error page>> is rendered.
If you need to test these lower-level concerns, you can start a fully running server as described in the next section.
====



[[features.testing.spring-boot-applications.with-running-server]]
==== Testing with a running server
If you need to start a full running server, we recommend that you use random ports.
If you use `@SpringBootTest(webEnvironment=WebEnvironment.RANDOM_PORT)`, an available port is picked at random each time your test runs.

The `@LocalServerPort` annotation can be used to <<howto#howto.webserver.discover-port,inject the actual port used>> into your test.
For convenience, tests that need to make REST calls to the started server can additionally `@Autowire` a {spring-framework-docs}/testing.html#webtestclient-tests[`WebTestClient`], which resolves relative links to the running server and comes with a dedicated API for verifying responses, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/withrunningserver/MyRandomPortWebTestClientTests.java[]
----

This setup requires `spring-webflux` on the classpath.
If you can't or won't add webflux, Spring Boot also provides a `TestRestTemplate` facility:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/withrunningserver/MyRandomPortTestRestTemplateTests.java[]
----



[[features.testing.spring-boot-applications.customizing-web-test-client]]
==== Customizing WebTestClient
To customize the `WebTestClient` bean, configure a `WebTestClientBuilderCustomizer` bean.
Any such beans are called with the `WebTestClient.Builder` that is used to create the `WebTestClient`.



[[features.testing.spring-boot-applications.jmx]]
==== Using JMX
As the test context framework caches context, JMX is disabled by default to prevent identical components to register on the same domain.
If such test needs access to an `MBeanServer`, consider marking it dirty as well:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/jmx/MyJmxTests.java[]
----



[[features.testing.spring-boot-applications.metrics]]
==== Using Metrics
Regardless of your classpath, meter registries, except the in-memory backed, are not auto-configured when using `@SpringBootTest`.

If you need to export metrics to a different backend as part of an integration test, annotate it with `@AutoConfigureMetrics`.



[[features.testing.spring-boot-applications.mocking-beans]]
==== Mocking and Spying Beans
When running tests, it is sometimes necessary to mock certain components within your application context.
For example, you may have a facade over some remote service that is unavailable during development.
Mocking can also be useful when you want to simulate failures that might be hard to trigger in a real environment.

Spring Boot includes a `@MockBean` annotation that can be used to define a Mockito mock for a bean inside your `ApplicationContext`.
You can use the annotation to add new beans or replace a single existing bean definition.
The annotation can be used directly on test classes, on fields within your test, or on `@Configuration` classes and fields.
When used on a field, the instance of the created mock is also injected.
Mock beans are automatically reset after each test method.

[NOTE]
====
If your test uses one of Spring Boot's test annotations (such as `@SpringBootTest`), this feature is automatically enabled.
To use this feature with a different arrangement, listeners must be explicitly added, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/mockingbeans/listener/MyTests.java[]
----

====

The following example replaces an existing `RemoteService` bean with a mock implementation:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/mockingbeans/bean/MyTests.java[]
----

NOTE: `@MockBean` cannot be used to mock the behavior of a bean that's exercised during application context refresh.
By the time the test is executed, the application context refresh has completed and it is too late to configure the mocked behavior.
We recommend using a `@Bean` method to create and configure the mock in this situation.

Additionally, you can use `@SpyBean` to wrap any existing bean with a Mockito `spy`.
See the {spring-boot-test-module-api}/mock/mockito/SpyBean.html[Javadoc] for full details.

NOTE: CGLib proxies, such as those created for scoped beans, declare the proxied methods as `final`.
This stops Mockito from functioning correctly as it cannot mock or spy on `final` methods in its default configuration.
If you want to mock or spy on such a bean, configure Mockito to use its inline mock maker by adding `org.mockito:mockito-inline` to your application's test dependencies.
This allows Mockito to mock and spy on `final` methods.

NOTE: While Spring's test framework caches application contexts between tests and reuses a context for tests sharing the same configuration, the use of `@MockBean` or `@SpyBean` influences the cache key, which will most likely increase the number of contexts.

TIP: If you are using `@SpyBean` to spy on a bean with `@Cacheable` methods that refer to parameters by name, your application must be compiled with `-parameters`.
This ensures that the parameter names are available to the caching infrastructure once the bean has been spied upon.

TIP: When you are using `@SpyBean` to spy on a bean that is proxied by Spring, you may need to remove Spring's proxy in some situations, for example when setting expectations using `given` or `when`.
Use `AopTestUtils.getTargetObject(yourProxiedSpy)` to do so.



[[features.testing.spring-boot-applications.autoconfigured-tests]]
==== Auto-configured Tests
Spring Boot's auto-configuration system works well for applications but can sometimes be a little too much for tests.
It often helps to load only the parts of the configuration that are required to test a ""`slice`"" of your application.
For example, you might want to test that Spring MVC controllers are mapping URLs correctly, and you do not want to involve database calls in those tests, or you might want to test JPA entities, and you are not interested in the web layer when those tests run.

The `spring-boot-test-autoconfigure` module includes a number of annotations that can be used to automatically configure such ""`slices`"".
Each of them works in a similar way, providing a `@...Test` annotation that loads the `ApplicationContext` and one or more `@AutoConfigure...` annotations that can be used to customize auto-configuration settings.

NOTE: Each slice restricts component scan to appropriate components and loads a very restricted set of auto-configuration classes.
If you need to exclude one of them, most `@...Test` annotations provide an `excludeAutoConfiguration` attribute.
Alternatively, you can use `@ImportAutoConfiguration#exclude`.

NOTE: Including multiple ""`slices`"" by using several `@...Test` annotations in one test is not supported.
If you need multiple ""`slices`"", pick one of the `@...Test` annotations and include the `@AutoConfigure...` annotations of the other ""`slices`"" by hand.

TIP: It is also possible to use the `@AutoConfigure...` annotations with the standard `@SpringBootTest` annotation.
You can use this combination if you are not interested in ""`slicing`"" your application but you want some of the auto-configured test beans.



[[features.testing.spring-boot-applications.json-tests]]
==== Auto-configured JSON Tests
To test that object JSON serialization and deserialization is working as expected, you can use the `@JsonTest` annotation.
`@JsonTest` auto-configures the available supported JSON mapper, which can be one of the following libraries:

* Jackson `ObjectMapper`, any `@JsonComponent` beans and any Jackson ``Module``s
* `Gson`
* `Jsonb`

TIP: A list of the auto-configurations that are enabled by `@JsonTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

If you need to configure elements of the auto-configuration, you can use the `@AutoConfigureJsonTesters` annotation.

Spring Boot includes AssertJ-based helpers that work with the JSONAssert and JsonPath libraries to check that JSON appears as expected.
The `JacksonTester`, `GsonTester`, `JsonbTester`, and `BasicJsonTester` classes can be used for Jackson, Gson, Jsonb, and Strings respectively.
Any helper fields on the test class can be `@Autowired` when using `@JsonTest`.
The following example shows a test class for Jackson:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/jsontests/MyJsonTests.java[]
----

NOTE: JSON helper classes can also be used directly in standard unit tests.
To do so, call the `initFields` method of the helper in your `@Before` method if you do not use `@JsonTest`.

If you're using Spring Boot's AssertJ-based helpers to assert on a number value at a given JSON path, you might not be able to use `isEqualTo` depending on the type.
Instead, you can use AssertJ's `satisfies` to assert that the value matches the given condition.
For instance, the following example asserts that the actual number is a float value close to `0.15` within an offset of `0.01`.

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/jsontests/MyJsonAssertJTests.java[tag=*]
----



[[features.testing.spring-boot-applications.spring-mvc-tests]]
==== Auto-configured Spring MVC Tests
To test whether Spring MVC controllers are working as expected, use the `@WebMvcTest` annotation.
`@WebMvcTest` auto-configures the Spring MVC infrastructure and limits scanned beans to `@Controller`, `@ControllerAdvice`, `@JsonComponent`, `Converter`, `GenericConverter`, `Filter`, `HandlerInterceptor`, `WebMvcConfigurer`, and `HandlerMethodArgumentResolver`.
Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@WebMvcTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.

TIP: A list of the auto-configuration settings that are enabled by `@WebMvcTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

TIP: If you need to register extra components, such as the Jackson `Module`, you can import additional configuration classes by using `@Import` on your test.

Often, `@WebMvcTest` is limited to a single controller and is used in combination with `@MockBean` to provide mock implementations for required collaborators.

`@WebMvcTest` also auto-configures `MockMvc`.
Mock MVC offers a powerful way to quickly test MVC controllers without needing to start a full HTTP server.

TIP: You can also auto-configure `MockMvc` in a non-`@WebMvcTest` (such as `@SpringBootTest`) by annotating it with `@AutoConfigureMockMvc`.
The following example uses `MockMvc`:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/springmvctests/MyControllerTests.java[]
----

TIP: If you need to configure elements of the auto-configuration (for example, when servlet filters should be applied) you can use attributes in the `@AutoConfigureMockMvc` annotation.

If you use HtmlUnit or Selenium, auto-configuration also provides an HtmlUnit `WebClient` bean and/or a Selenium `WebDriver` bean.
The following example uses HtmlUnit:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/springmvctests/MyHtmlUnitTests.java[]
----

NOTE: By default, Spring Boot puts `WebDriver` beans in a special ""`scope`"" to ensure that the driver exits after each test and that a new instance is injected.
If you do not want this behavior, you can add `@Scope(""singleton"")` to your `WebDriver` `@Bean` definition.

WARNING: The `webDriver` scope created by Spring Boot will replace any user defined scope of the same name.
If you define your own `webDriver` scope you may find it stops working when you use `@WebMvcTest`.

If you have Spring Security on the classpath, `@WebMvcTest` will also scan `WebSecurityConfigurer` beans.
Instead of disabling security completely for such tests, you can use Spring Security's test support.
More details on how to use Spring Security's `MockMvc` support can be found in this _<<howto#howto.testing-with-spring-security>>_ how-to section.

TIP: Sometimes writing Spring MVC tests is not enough; Spring Boot can help you run <<features#features.testing.spring-boot-applications.with-running-server, full end-to-end tests with an actual server>>.



[[features.testing.spring-boot-applications.spring-webflux-tests]]
==== Auto-configured Spring WebFlux Tests
To test that {spring-framework-docs}/web-reactive.html[Spring WebFlux] controllers are working as expected, you can use the `@WebFluxTest` annotation.
`@WebFluxTest` auto-configures the Spring WebFlux infrastructure and limits scanned beans to `@Controller`, `@ControllerAdvice`, `@JsonComponent`, `Converter`, `GenericConverter`, `WebFilter`, and `WebFluxConfigurer`.
Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@WebFluxTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.

TIP: A list of the auto-configurations that are enabled by `@WebFluxTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

TIP: If you need to register extra components, such as Jackson `Module`, you can import additional configuration classes using `@Import` on your test.

Often, `@WebFluxTest` is limited to a single controller and used in combination with the `@MockBean` annotation to provide mock implementations for required collaborators.

`@WebFluxTest` also auto-configures {spring-framework-docs}/testing.html#webtestclient[`WebTestClient`], which offers a powerful way to quickly test WebFlux controllers without needing to start a full HTTP server.

TIP: You can also auto-configure `WebTestClient` in a non-`@WebFluxTest` (such as `@SpringBootTest`) by annotating it with `@AutoConfigureWebTestClient`.
The following example shows a class that uses both `@WebFluxTest` and a `WebTestClient`:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/springwebfluxtests/MyControllerTests.java[]
----

TIP: This setup is only supported by WebFlux applications as using `WebTestClient` in a mocked web application only works with WebFlux at the moment.

NOTE: `@WebFluxTest` cannot detect routes registered via the functional web framework.
For testing `RouterFunction` beans in the context, consider importing your `RouterFunction` yourself via `@Import` or using `@SpringBootTest`.

NOTE: `@WebFluxTest` cannot detect custom security configuration registered via a `@Bean` of type `SecurityWebFilterChain`.
To include that in your test, you will need to import the configuration that registers the bean via `@Import` or use `@SpringBootTest`.

TIP: Sometimes writing Spring WebFlux tests is not enough; Spring Boot can help you run <<features#features.testing.spring-boot-applications.with-running-server, full end-to-end tests with an actual server>>.



[[features.testing.spring-boot-applications.autoconfigured-spring-data-cassandra]]
==== Auto-configured Data Cassandra Tests
You can use `@DataCassandraTest` to test Cassandra applications.
By default, it configures a `CassandraTemplate`, scans for `@Table` classes, and configures Spring Data Cassandra repositories.
Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@DataCassandraTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.
(For more about using Cassandra with Spring Boot, see ""<<features#features.nosql.cassandra>>"", earlier in this chapter.)

TIP: A list of the auto-configuration settings that are enabled by `@DataCassandraTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

The following example shows a typical setup for using Cassandra tests in Spring Boot:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringdatacassandra/MyDataCassandraTests.java[]
----



[[features.testing.spring-boot-applications.autoconfigured-spring-data-jpa]]
==== Auto-configured Data JPA Tests
You can use the `@DataJpaTest` annotation to test JPA applications.
By default, it scans for `@Entity` classes and configures Spring Data JPA repositories.
If an embedded database is available on the classpath, it configures one as well.
SQL queries are logged by default by setting the `spring.jpa.show-sql` property to `true`.
This can be disabled using the `showSql()` attribute of the annotation.

Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@DataJpaTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.

TIP: A list of the auto-configuration settings that are enabled by `@DataJpaTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

By default, data JPA tests are transactional and roll back at the end of each test.
See the {spring-framework-docs}/testing.html#testcontext-tx-enabling-transactions[relevant section] in the Spring Framework Reference Documentation for more details.
If that is not what you want, you can disable transaction management for a test or for the whole class as follows:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringdatajpa/MyNonTransactionalTests.java[]
----

Data JPA tests may also inject a {spring-boot-test-autoconfigure-module-code}/orm/jpa/TestEntityManager.java[`TestEntityManager`] bean, which provides an alternative to the standard JPA `EntityManager` that is specifically designed for tests.
If you want to use `TestEntityManager` outside of `@DataJpaTest` instances, you can also use the `@AutoConfigureTestEntityManager` annotation.
A `JdbcTemplate` is also available if you need that.
The following example shows the `@DataJpaTest` annotation in use:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringdatajpa/withoutdb/MyRepositoryTests.java[]
----

In-memory embedded databases generally work well for tests, since they are fast and do not require any installation.
If, however, you prefer to run tests against a real database you can use the `@AutoConfigureTestDatabase` annotation, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringdatajpa/withdb/MyRepositoryTests.java[]
----



[[features.testing.spring-boot-applications.autoconfigured-jdbc]]
==== Auto-configured JDBC Tests
`@JdbcTest` is similar to `@DataJpaTest` but is for tests that only require a `DataSource` and do not use Spring Data JDBC.
By default, it configures an in-memory embedded database and a `JdbcTemplate`.
Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@JdbcTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.

TIP: A list of the auto-configurations that are enabled by `@JdbcTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

By default, JDBC tests are transactional and roll back at the end of each test.
See the {spring-framework-docs}/testing.html#testcontext-tx-enabling-transactions[relevant section] in the Spring Framework Reference Documentation for more details.
If that is not what you want, you can disable transaction management for a test or for the whole class, as follows:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredjdbc/MyTransactionalTests.java[]
----

If you prefer your test to run against a real database, you can use the `@AutoConfigureTestDatabase` annotation in the same way as for `DataJpaTest`.
(See ""<<features#features.testing.spring-boot-applications.autoconfigured-spring-data-jpa>>"".)



[[features.testing.spring-boot-applications.autoconfigured-spring-data-jdbc]]
==== Auto-configured Data JDBC Tests
`@DataJdbcTest` is similar to `@JdbcTest` but is for tests that use Spring Data JDBC repositories.
By default, it configures an in-memory embedded database, a `JdbcTemplate`, and Spring Data JDBC repositories.
Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@DataJdbcTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.

TIP: A list of the auto-configurations that are enabled by `@DataJdbcTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

By default, Data JDBC tests are transactional and roll back at the end of each test.
See the {spring-framework-docs}/testing.html#testcontext-tx-enabling-transactions[relevant section] in the Spring Framework Reference Documentation for more details.
If that is not what you want, you can disable transaction management for a test or for the whole test class as <<features#features.testing.spring-boot-applications.autoconfigured-jdbc,shown in the JDBC example>>.

If you prefer your test to run against a real database, you can use the `@AutoConfigureTestDatabase` annotation in the same way as for `DataJpaTest`.
(See ""<<features#features.testing.spring-boot-applications.autoconfigured-spring-data-jpa>>"".)



[[features.testing.spring-boot-applications.autoconfigured-jooq]]
==== Auto-configured jOOQ Tests
You can use `@JooqTest` in a similar fashion as `@JdbcTest` but for jOOQ-related tests.
As jOOQ relies heavily on a Java-based schema that corresponds with the database schema, the existing `DataSource` is used.
If you want to replace it with an in-memory database, you can use `@AutoConfigureTestDatabase` to override those settings.
(For more about using jOOQ with Spring Boot, see ""<<features#features.sql.jooq>>"", earlier in this chapter.)
Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@JooqTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.

TIP: A list of the auto-configurations that are enabled by `@JooqTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

`@JooqTest` configures a `DSLContext`.
The following example shows the `@JooqTest` annotation in use:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredjooq/MyJooqTests.java[]
----

JOOQ tests are transactional and roll back at the end of each test by default.
If that is not what you want, you can disable transaction management for a test or for the whole test class as <<features#features.testing.spring-boot-applications.autoconfigured-jdbc,shown in the JDBC example>>.



[[features.testing.spring-boot-applications.autoconfigured-spring-data-mongodb]]
==== Auto-configured Data MongoDB Tests
You can use `@DataMongoTest` to test MongoDB applications.
By default, it configures an in-memory embedded MongoDB (if available), configures a `MongoTemplate`, scans for `@Document` classes, and configures Spring Data MongoDB repositories.
Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@DataMongoTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.
(For more about using MongoDB with Spring Boot, see ""<<features#features.nosql.mongodb>>"", earlier in this chapter.)

TIP: A list of the auto-configuration settings that are enabled by `@DataMongoTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

The following class shows the `@DataMongoTest` annotation in use:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringdatamongodb/withoutdb/MyDataMongoDbTests.java[]
----

In-memory embedded MongoDB generally works well for tests, since it is fast and does not require any developer installation.
If, however, you prefer to run tests against a real MongoDB server, you should exclude the embedded MongoDB auto-configuration, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringdatamongodb/withdb/MyDataMongoDbTests.java[]
----



[[features.testing.spring-boot-applications.autoconfigured-spring-data-neo4j]]
==== Auto-configured Data Neo4j Tests
You can use `@DataNeo4jTest` to test Neo4j applications.
By default, it scans for `@Node` classes, and configures Spring Data Neo4j repositories.
Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@DataNeo4jTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.
(For more about using Neo4J with Spring Boot, see ""<<features#features.nosql.neo4j>>"", earlier in this chapter.)

TIP: A list of the auto-configuration settings that are enabled by `@DataNeo4jTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

The following example shows a typical setup for using Neo4J tests in Spring Boot:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringdataneo4j/propagation/MyDataNeo4jTests.java[]
----

By default, Data Neo4j tests are transactional and roll back at the end of each test.
See the {spring-framework-docs}/testing.html#testcontext-tx-enabling-transactions[relevant section] in the Spring Framework Reference Documentation for more details.
If that is not what you want, you can disable transaction management for a test or for the whole class, as follows:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringdataneo4j/nopropagation/MyDataNeo4jTests.java[]
----

NOTE: Transactional tests are not supported with reactive access.
If you are using this style, you must configure `@DataNeo4jTest` tests as described above.



[[features.testing.spring-boot-applications.autoconfigured-spring-data-redis]]
==== Auto-configured Data Redis Tests
You can use `@DataRedisTest` to test Redis applications.
By default, it scans for `@RedisHash` classes and configures Spring Data Redis repositories.
Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@DataRedisTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.
(For more about using Redis with Spring Boot, see ""<<features#features.nosql.redis>>"", earlier in this chapter.)

TIP: A list of the auto-configuration settings that are enabled by `@DataRedisTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

The following example shows the `@DataRedisTest` annotation in use:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringdataredis/MyDataRedisTests.java[]
----



[[features.testing.spring-boot-applications.autoconfigured-spring-data-ldap]]
==== Auto-configured Data LDAP Tests
You can use `@DataLdapTest` to test LDAP applications.
By default, it configures an in-memory embedded LDAP (if available), configures an `LdapTemplate`, scans for `@Entry` classes, and configures Spring Data LDAP repositories.
Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@DataLdapTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.
(For more about using LDAP with Spring Boot, see ""<<features#features.nosql.ldap>>"", earlier in this chapter.)

TIP: A list of the auto-configuration settings that are enabled by `@DataLdapTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

The following example shows the `@DataLdapTest` annotation in use:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringdataldap/inmemory/MyDataLdapTests.java[]
----

In-memory embedded LDAP generally works well for tests, since it is fast and does not require any developer installation.
If, however, you prefer to run tests against a real LDAP server, you should exclude the embedded LDAP auto-configuration, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringdataldap/server/MyDataLdapTests.java[]
----



[[features.testing.spring-boot-applications.autoconfigured-rest-client]]
==== Auto-configured REST Clients
You can use the `@RestClientTest` annotation to test REST clients.
By default, it auto-configures Jackson, GSON, and Jsonb support, configures a `RestTemplateBuilder`, and adds support for `MockRestServiceServer`.
Regular `@Component` and `@ConfigurationProperties` beans are not scanned when the `@RestClientTest` annotation is used.
`@EnableConfigurationProperties` can be used to include `@ConfigurationProperties` beans.

TIP: A list of the auto-configuration settings that are enabled by `@RestClientTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

The specific beans that you want to test should be specified by using the `value` or `components` attribute of `@RestClientTest`, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredrestclient/MyRestClientTests.java[]
----



[[features.testing.spring-boot-applications.autoconfigured-spring-restdocs]]
==== Auto-configured Spring REST Docs Tests
You can use the `@AutoConfigureRestDocs` annotation to use {spring-restdocs}[Spring REST Docs] in your tests with Mock MVC, REST Assured, or WebTestClient.
It removes the need for the JUnit extension in Spring REST Docs.

`@AutoConfigureRestDocs` can be used to override the default output directory (`target/generated-snippets` if you are using Maven or `build/generated-snippets` if you are using Gradle).
It can also be used to configure the host, scheme, and port that appears in any documented URIs.



[[features.testing.spring-boot-applications.autoconfigured-spring-restdocs.with-mock-mvc]]
===== Auto-configured Spring REST Docs Tests with Mock MVC
`@AutoConfigureRestDocs` customizes the `MockMvc` bean to use Spring REST Docs when testing Servlet-based web applications.
You can inject it by using `@Autowired` and use it in your tests as you normally would when using Mock MVC and Spring REST Docs, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringrestdocs/withmockmvc/MyUserDocumentationTests.java[]
----

If you require more control over Spring REST Docs configuration than offered by the attributes of `@AutoConfigureRestDocs`, you can use a `RestDocsMockMvcConfigurationCustomizer` bean, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringrestdocs/withmockmvc/MyRestDocsConfiguration.java[]
----

If you want to make use of Spring REST Docs support for a parameterized output directory, you can create a `RestDocumentationResultHandler` bean.
The auto-configuration calls `alwaysDo` with this result handler, thereby causing each `MockMvc` call to automatically generate the default snippets.
The following example shows a `RestDocumentationResultHandler` being defined:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringrestdocs/withmockmvc/MyResultHandlerConfiguration.java[]
----



[[features.testing.spring-boot-applications.autoconfigured-spring-restdocs.with-web-test-client]]
===== Auto-configured Spring REST Docs Tests with WebTestClient
`@AutoConfigureRestDocs` can also be used with `WebTestClient` when testing reactive web applications.
You can inject it by using `@Autowired` and use it in your tests as you normally would when using `@WebFluxTest` and Spring REST Docs, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringrestdocs/withwebtestclient/MyUsersDocumentationTests.java[]
----

If you require more control over Spring REST Docs configuration than offered by the attributes of `@AutoConfigureRestDocs`, you can use a `RestDocsWebTestClientConfigurationCustomizer` bean, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringrestdocs/withwebtestclient/MyRestDocsConfiguration.java[]
----



[[features.testing.spring-boot-applications.autoconfigured-spring-restdocs.with-rest-assured]]
===== Auto-configured Spring REST Docs Tests with REST Assured
`@AutoConfigureRestDocs` makes a `RequestSpecification` bean, preconfigured to use Spring REST Docs, available to your tests.
You can inject it by using `@Autowired` and use it in your tests as you normally would when using REST Assured and Spring REST Docs, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringrestdocs/withrestassured/MyUserDocumentationTests.java[]
----

If you require more control over Spring REST Docs configuration than offered by the attributes of `@AutoConfigureRestDocs`, a `RestDocsRestAssuredConfigurationCustomizer` bean can be used, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredspringrestdocs/withrestassured/MyRestDocsConfiguration.java[]
----



[[features.testing.spring-boot-applications.autoconfigured-webservices]]
==== Auto-configured Spring Web Services Tests
You can use `@WebServiceClientTest` to test applications that use call web services using the Spring Web Services project.
By default, it configures a mock `WebServiceServer` bean and automatically customizes your `WebServiceTemplateBuilder`.
(For more about using Web Services with Spring Boot, see ""<<features#features.webservices>>"", earlier in this chapter.)


TIP: A list of the auto-configuration settings that are enabled by `@WebServiceClientTest` can be <<test-auto-configuration#test-auto-configuration,found in the appendix>>.

The following example shows the `@WebServiceClientTest` annotation in use:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/autoconfiguredwebservices/MyWebServiceClientTests.java[]
----



[[features.testing.spring-boot-applications.additional-autoconfiguration-and-slicing]]
==== Additional Auto-configuration and Slicing
Each slice provides one or more `@AutoConfigure...` annotations that namely defines the auto-configurations that should be included as part of a slice.
Additional auto-configurations can be added on a test-by-test basis by creating a custom `@AutoConfigure...` annotation or by adding `@ImportAutoConfiguration` to the test as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/additionalautoconfigurationandslicing/MyJdbcTests.java[]
----

NOTE: Make sure to not use the regular `@Import` annotation to import auto-configurations as they are handled in a specific way by Spring Boot.

Alternatively, additional auto-configurations can be added for any use of a slice annotation by registering them in `META-INF/spring.factories` as shown in the following example:

[indent=0]
----
	org.springframework.boot.test.autoconfigure.jdbc.JdbcTest=com.example.IntegrationAutoConfiguration
----

TIP: A slice or `@AutoConfigure...` annotation can be customized this way as long as it is meta-annotated with `@ImportAutoConfiguration`.



[[features.testing.spring-boot-applications.user-configuration-and-slicing]]
==== User Configuration and Slicing
If you <<using#using.structuring-your-code, structure your code>> in a sensible way, your `@SpringBootApplication` class is <<features#features.testing.spring-boot-applications.detecting-configuration, used by default>> as the configuration of your tests.

It then becomes important not to litter the application's main class with configuration settings that are specific to a particular area of its functionality.

Assume that you are using Spring Batch and you rely on the auto-configuration for it.
You could define your `@SpringBootApplication` as follows:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/userconfigurationandslicing/MyApplication.java[]
----

Because this class is the source configuration for the test, any slice test actually tries to start Spring Batch, which is definitely not what you want to do.
A recommended approach is to move that area-specific configuration to a separate `@Configuration` class at the same level as your application, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/userconfigurationandslicing/MyBatchConfiguration.java[]
----

NOTE: Depending on the complexity of your application, you may either have a single `@Configuration` class for your customizations or one class per domain area.
The latter approach lets you enable it in one of your tests, if necessary, with the `@Import` annotation.

Test slices exclude `@Configuration` classes from scanning.
For example, for a `@WebMvcTest`, the following configuration will not include the given `WebMvcConfigurer` bean in the application context loaded by the test slice:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/userconfigurationandslicing/MyWebConfiguration.java[]
----

The configuration below will, however, cause the custom `WebMvcConfigurer` to be loaded by the test slice.

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/userconfigurationandslicing/MyWebMvcConfigurer.java[]
----

Another source of confusion is classpath scanning.
Assume that, while you structured your code in a sensible way, you need to scan an additional package.
Your application may resemble the following code:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/springbootapplications/userconfigurationandslicing/scan/MyApplication.java[]
----

Doing so effectively overrides the default component scan directive with the side effect of scanning those two packages regardless of the slice that you chose.
For instance, a `@DataJpaTest` seems to suddenly scan components and user configurations of your application.
Again, moving the custom directive to a separate class is a good way to fix this issue.

TIP: If this is not an option for you, you can create a `@SpringBootConfiguration` somewhere in the hierarchy of your test so that it is used instead.
Alternatively, you can specify a source for your test, which disables the behavior of finding a default one.



[[features.testing.spring-boot-applications.spock]]
==== Using Spock to Test Spring Boot Applications
If you wish to use Spock to test a Spring Boot application, you should add a dependency on Spock's `spock-spring` module to your application's build.
`spock-spring` integrates Spring's test framework into Spock.
See https://spockframework.org/spock/docs/2.0-M4/modules.html#_spring_module[the documentation for Spock's Spring module] for further details.

NOTE: As of Spring Boot 2.5.x and its support for Groovy 3.x you have two options to make use of Spock:
Either use the latest Spock 2.0 milestone or release that is compatible with Groovy 3.x or stick with Spock 1.3 and downgrade Spring Boot's Groovy version to 2.5.x.



[[features.testing.utilities]]
=== Test Utilities
A few test utility classes that are generally useful when testing your application are packaged as part of `spring-boot`.



[[features.testing.utilities.config-data-application-context-initializer]]
==== ConfigDataApplicationContextInitializer
`ConfigDataApplicationContextInitializer` is an `ApplicationContextInitializer` that you can apply to your tests to load Spring Boot `application.properties` files.
You can use it when you do not need the full set of features provided by `@SpringBootTest`, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/utilities/configdataapplicationcontextinitializer/MyConfigFileTests.java[]
----

NOTE: Using `ConfigDataApplicationContextInitializer` alone does not provide support for `@Value(""${...}"")` injection.
Its only job is to ensure that `application.properties` files are loaded into Spring's `Environment`.
For `@Value` support, you need to either additionally configure a `PropertySourcesPlaceholderConfigurer` or use `@SpringBootTest`, which auto-configures one for you.



[[features.testing.utilities.test-property-values]]
==== TestPropertyValues
`TestPropertyValues` lets you quickly add properties to a `ConfigurableEnvironment` or `ConfigurableApplicationContext`.
You can call it with `key=value` strings, as follows:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/utilities/testpropertyvalues/MyEnvironmentTests.java[]
----



[[features.testing.utilities.output-capture]]
==== OutputCapture
`OutputCapture` is a JUnit `Extension` that you can use to capture `System.out` and `System.err` output.
To use add `@ExtendWith(OutputCaptureExtension.class)` and inject `CapturedOutput` as an argument to your test class constructor or test method as follows:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/utilities/outputcapture/MyOutputCaptureTests.java[]
----



[[features.testing.utilities.test-rest-template]]
==== TestRestTemplate
`TestRestTemplate` is a convenience alternative to Spring's `RestTemplate` that is useful in integration tests.
You can get a vanilla template or one that sends Basic HTTP authentication (with a username and password).
In either case, the template behaves in a test-friendly way by not throwing exceptions on server-side errors.

TIP: Spring Framework 5.0 provides a new `WebTestClient` that works for <<features#features.testing.spring-boot-applications.spring-webflux-tests, WebFlux integration tests>> and both <<features#features.testing.spring-boot-applications.with-running-server, WebFlux and MVC end-to-end testing>>.
It provides a fluent API for assertions, unlike `TestRestTemplate`.

It is recommended, but not mandatory, to use the Apache HTTP Client (version 4.3.2 or better).
If you have that on your classpath, the `TestRestTemplate` responds by configuring the client appropriately.
If you do use Apache's HTTP client, some additional test-friendly features are enabled:

* Redirects are not followed (so you can assert the response location).
* Cookies are ignored (so the template is stateless).

`TestRestTemplate` can be instantiated directly in your integration tests, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/utilities/testresttemplate/MyTests.java[]
----

Alternatively, if you use the `@SpringBootTest` annotation with `WebEnvironment.RANDOM_PORT` or `WebEnvironment.DEFINED_PORT`, you can inject a fully configured `TestRestTemplate` and start using it.
If necessary, additional customizations can be applied through the `RestTemplateBuilder` bean.
Any URLs that do not specify a host and port automatically connect to the embedded server, as shown in the following example:

[source,java,indent=0,subs=""verbatim""]
----
include::{docs-java}/features/testing/utilities/testresttemplate/MySpringBootTests.java[]
----
",12389,True,2626.499896041375,median
"[[netty-component]]
= Netty Component
//THIS FILE IS COPIED: EDIT THE SOURCE FILE:
:page-source: components/camel-netty/src/main/docs/netty-component.adoc
:docTitle: Netty
:artifactId: camel-netty
:description: Socket level networking using TCP or UDP with the Netty 4.x.
:since: 2.14
:supportLevel: Stable
:component-header: Both producer and consumer are supported
include::{cq-version}@camel-quarkus:ROOT:partial$reference/components/netty.adoc[opts=optional]

*Since Camel {since}*

*{component-header}*

The Netty component in Camel is a socket communication component,
based on the http://netty.io/[Netty] project version 4. +
 Netty is a NIO client server framework which enables quick and easy
development of networkServerInitializerFactory applications such as
protocol servers and clients. +
 Netty greatly simplifies and streamlines network programming such as
TCP and UDP socket server.

This camel component supports both producer and consumer endpoints.

The Netty component has several options and allows fine-grained control
of a number of TCP/UDP communication parameters (buffer sizes,
keepAlives, tcpNoDelay, etc) and facilitates both In-Only and In-Out
communication on a Camel route.

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-netty</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>
----

== URI format

The URI scheme for a netty component is as follows

[source,text]
----
netty:tcp://0.0.0.0:99999[?options]
netty:udp://remotehost:99999/[?options]
----

This component supports producer and consumer endpoints for both TCP and
UDP.

You can append query options to the URI in the following format,
`?option=value&option=value&...`

== Options

// component options: START
The Netty component supports 72 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *configuration* (common) | To use the NettyConfiguration as configuration when creating endpoints. |  | NettyConfiguration
| *disconnect* (common) | Whether or not to disconnect(close) from Netty Channel right after use. Can be used for both consumer and producer. | false | boolean
| *keepAlive* (common) | Setting to ensure socket is not closed due to inactivity | true | boolean
| *reuseAddress* (common) | Setting to facilitate socket multiplexing | true | boolean
| *reuseChannel* (common) | This option allows producers and consumers (in client mode) to reuse the same Netty Channel for the lifecycle of processing the Exchange. This is useful if you need to call a server multiple times in a Camel route and want to use the same network connection. When using this, the channel is not returned to the connection pool until the Exchange is done; or disconnected if the disconnect option is set to true. The reused Channel is stored on the Exchange as an exchange property with the key NettyConstants#NETTY_CHANNEL which allows you to obtain the channel during routing and use it as well. | false | boolean
| *sync* (common) | Setting to set endpoint as one-way or request-response | true | boolean
| *tcpNoDelay* (common) | Setting to improve TCP protocol performance | true | 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
| *broadcast* (consumer) | Setting to choose Multicast over UDP | false | boolean
| *clientMode* (consumer) | If the clientMode is true, netty consumer will connect the address as a TCP client. | false | boolean
| *reconnect* (consumer) | Used only in clientMode in consumer, the consumer will attempt to reconnect on disconnection if this is enabled | true | boolean
| *reconnectInterval* (consumer) | Used if reconnect and clientMode is enabled. The interval in milli seconds to attempt reconnection | 10000 | int
| *backlog* (consumer) | Allows to configure a backlog for netty consumer (server). Note the backlog is just a best effort depending on the OS. Setting this option to a value such as 200, 500 or 1000, tells the TCP stack how long the accept queue can be If this option is not configured, then the backlog depends on OS setting. |  | int
| *bossCount* (consumer) | When netty works on nio mode, it uses default bossCount parameter from Netty, which is 1. User can use this option to override the default bossCount from Netty | 1 | int
| *bossGroup* (consumer) | Set the BossGroup which could be used for handling the new connection of the server side across the NettyEndpoint |  | EventLoopGroup
| *disconnectOnNoReply* (consumer) | If sync is enabled then this option dictates NettyConsumer if it should disconnect where there is no reply to send back. | true | boolean
| *executorService* (consumer) | To use the given EventExecutorGroup. |  | EventExecutorGroup
| *maximumPoolSize* (consumer) | Sets a maximum thread pool size for the netty consumer ordered thread pool. The default size is 2 x cpu_core plus 1. Setting this value to eg 10 will then use 10 threads unless 2 x cpu_core plus 1 is a higher value, which then will override and be used. For example if there are 8 cores, then the consumer thread pool will be 17. This thread pool is used to route messages received from Netty by Camel. We use a separate thread pool to ensure ordering of messages and also in case some messages will block, then nettys worker threads (event loop) wont be affected. |  | int
| *nettyServerBootstrapFactory* (consumer) | To use a custom NettyServerBootstrapFactory |  | NettyServerBootstrapFactory
| *networkInterface* (consumer) | When using UDP then this option can be used to specify a network interface by its name, such as eth0 to join a multicast group. |  | String
| *noReplyLogLevel* (consumer) | If sync is enabled this option dictates NettyConsumer which logging level to use when logging a there is no reply to send back. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverClosedChannelException{zwsp}CaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an java.nio.channels.ClosedChannelException then its logged using this logging level. This is used to avoid logging the closed channel exceptions, as clients can disconnect abruptly and then cause a flood of closed exceptions in the Netty server. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | DEBUG | LoggingLevel
| *serverExceptionCaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an exception then its logged using this logging level. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverInitializerFactory* (consumer) | To use a custom ServerInitializerFactory |  | ServerInitializerFactory
| *usingExecutorService* (consumer) | Whether to use ordered thread pool, to ensure events are processed orderly on the same channel. | true | boolean
| *connectTimeout* (producer) | Time to wait for a socket connection to be available. Value is in milliseconds. | 10000 | int
| *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
| *requestTimeout* (producer) | Allows to use a timeout for the Netty producer when calling a remote server. By default no timeout is in use. The value is in milli seconds, so eg 30000 is 30 seconds. The requestTimeout is using Netty's ReadTimeoutHandler to trigger the timeout. |  | long
| *clientInitializerFactory* (producer) | To use a custom ClientInitializerFactory |  | ClientInitializerFactory
| *correlationManager* (producer) | To use a custom correlation manager to manage how request and reply messages are mapped when using request/reply with the netty producer. This should only be used if you have a way to map requests together with replies such as if there is correlation ids in both the request and reply messages. This can be used if you want to multiplex concurrent messages on the same channel (aka connection) in netty. When doing this you must have a way to correlate the request and reply messages so you can store the right reply on the inflight Camel Exchange before its continued routed. We recommend extending the TimeoutCorrelationManagerSupport when you build custom correlation managers. This provides support for timeout and other complexities you otherwise would need to implement as well. See also the producerPoolEnabled option for more details. |  | NettyCamelStateCorrelationManager
| *lazyChannelCreation* (producer) | Channels can be lazily created to avoid exceptions, if the remote server is not up and running when the Camel producer is started. | true | boolean
| *producerPoolEnabled* (producer) | Whether producer pool is enabled or not. Important: If you turn this off then a single shared connection is used for the producer, also if you are doing request/reply. That means there is a potential issue with interleaved responses if replies comes back out-of-order. Therefore you need to have a correlation id in both the request and reply messages so you can properly correlate the replies to the Camel callback that is responsible for continue processing the message in Camel. To do this you need to implement NettyCamelStateCorrelationManager as correlation manager and configure it via the correlationManager option. See also the correlationManager option for more details. | true | boolean
| *producerPoolMaxActive* (producer) | Sets the cap on the number of objects that can be allocated by the pool (checked out to clients, or idle awaiting checkout) at a given time. Use a negative value for no limit. | -1 | int
| *producerPoolMaxIdle* (producer) | Sets the cap on the number of idle instances in the pool. | 100 | int
| *producerPoolMinEvictableIdle* (producer) | Sets the minimum amount of time (value in millis) an object may sit idle in the pool before it is eligible for eviction by the idle object evictor. | 300000 | long
| *producerPoolMinIdle* (producer) | Sets the minimum number of instances allowed in the producer pool before the evictor thread (if active) spawns new objects. |  | int
| *udpConnectionlessSending* (producer) | This option supports connection less udp sending which is a real fire and forget. A connected udp send receive the PortUnreachableException if no one is listen on the receiving port. | false | boolean
| *useByteBuf* (producer) | If the useByteBuf is true, netty producer will turn the message body into ByteBuf before sending it out. | false | boolean
| *allowSerializedHeaders* (advanced) | Only used for TCP when transferExchange is true. When set to true, serializable objects in headers and properties will be added to the exchange. Otherwise Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *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
| *channelGroup* (advanced) | To use a explicit ChannelGroup. |  | ChannelGroup
| *nativeTransport* (advanced) | Whether to use native transport instead of NIO. Native transport takes advantage of the host operating system and is only supported on some platforms. You need to add the netty JAR for the host operating system you are using. See more details at: \\http://netty.io/wiki/native-transports.html | false | boolean
| *options* (advanced) | Allows to configure additional netty options using option. as prefix. For example option.child.keepAlive=false to set the netty option child.keepAlive=false. See the Netty documentation for possible options that can be used. |  | Map
| *receiveBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during inbound communication. Size is bytes. | 65536 | int
| *receiveBufferSizePredictor* (advanced) | Configures the buffer size predictor. See details at Jetty documentation and this mail thread. |  | int
| *sendBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during outbound communication. Size is bytes. | 65536 | int
| *transferExchange* (advanced) | Only used for TCP. You can transfer the exchange over the wire instead of just the body. The following fields are transferred: In body, Out body, fault body, In headers, Out headers, fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *udpByteArrayCodec* (advanced) | For UDP only. If enabled the using byte array codec instead of Java serialization protocol. | false | boolean
| *workerCount* (advanced) | When netty works on nio mode, it uses default workerCount parameter from Netty (which is cpu_core_threads x 2). User can use this option to override the default workerCount from Netty. |  | int
| *workerGroup* (advanced) | To use a explicit EventLoopGroup as the boss thread pool. For example to share a thread pool with multiple consumers or producers. By default each consumer or producer has their own worker pool with 2 x cpu count core threads. |  | EventLoopGroup
| *allowDefaultCodec* (codec) | The netty component installs a default codec if both, encoder/decoder is null and textline is false. Setting allowDefaultCodec to false prevents the netty component from installing a default codec as the first element in the filter chain. | true | boolean
| *autoAppendDelimiter* (codec) | Whether or not to auto append missing end delimiter when sending using the textline codec. | true | boolean
| *decoderMaxLineLength* (codec) | The max line length to use for the textline codec. | 1024 | int
| *decoders* (codec) | A list of decoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *delimiter* (codec) | The delimiter to use for the textline codec. Possible values are LINE and NULL. There are 2 enums and the value can be one of: LINE, NULL | LINE | TextLineDelimiter
| *encoders* (codec) | A list of encoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *encoding* (codec) | The encoding (a charset name) to use for the textline codec. If not provided, Camel will use the JVM default Charset. |  | String
| *textline* (codec) | Only used for TCP. If no codec is specified, you can use this flag to indicate a text line based codec; if not specified or the value is false, then Object Serialization is assumed over TCP - however only Strings are allowed to be serialized by default. | false | boolean
| *enabledProtocols* (security) | Which protocols to enable when using SSL | TLSv1,TLSv1.1,TLSv1.2 | String
| *keyStoreFile* (security) | Client side certificate keystore to be used for encryption |  | File
| *keyStoreFormat* (security) | Keystore format to be used for payload encryption. Defaults to JKS if not set |  | String
| *keyStoreResource* (security) | Client side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
| *needClientAuth* (security) | Configures whether the server needs client authentication when using SSL. | false | boolean
| *passphrase* (security) | Password setting to use in order to encrypt/decrypt payloads sent using SSH |  | String
| *securityProvider* (security) | Security provider to be used for payload encryption. Defaults to SunX509 if not set. |  | String
| *ssl* (security) | Setting to specify whether SSL encryption is applied to this endpoint | false | boolean
| *sslClientCertHeaders* (security) | When enabled and in SSL mode, then the Netty consumer will enrich the Camel Message with headers having information about the client certificate such as subject name, issuer name, serial number, and the valid date range. | false | boolean
| *sslContextParameters* (security) | To configure security using SSLContextParameters |  | SSLContextParameters
| *sslHandler* (security) | Reference to a class that could be used to return an SSL Handler |  | SslHandler
| *trustStoreFile* (security) | Server side certificate keystore to be used for encryption |  | File
| *trustStoreResource* (security) | Server side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
| *useGlobalSslContextParameters* (security) | Enable usage of global SSL context parameters. | false | boolean
|===
// component options: END


// endpoint options: START
The Netty endpoint is configured using URI syntax:

----
netty:protocol://host:port
----

with the following path and query parameters:

=== Path Parameters (3 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *protocol* | *Required* The protocol to use which can be tcp or udp. There are 2 enums and the value can be one of: tcp, udp |  | String
| *host* | *Required* The hostname. For the consumer the hostname is localhost or 0.0.0.0. For the producer the hostname is the remote host to connect to |  | String
| *port* | *Required* The host port number |  | int
|===


=== Query Parameters (70 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *disconnect* (common) | Whether or not to disconnect(close) from Netty Channel right after use. Can be used for both consumer and producer. | false | boolean
| *keepAlive* (common) | Setting to ensure socket is not closed due to inactivity | true | boolean
| *reuseAddress* (common) | Setting to facilitate socket multiplexing | true | boolean
| *reuseChannel* (common) | This option allows producers and consumers (in client mode) to reuse the same Netty Channel for the lifecycle of processing the Exchange. This is useful if you need to call a server multiple times in a Camel route and want to use the same network connection. When using this, the channel is not returned to the connection pool until the Exchange is done; or disconnected if the disconnect option is set to true. The reused Channel is stored on the Exchange as an exchange property with the key NettyConstants#NETTY_CHANNEL which allows you to obtain the channel during routing and use it as well. | false | boolean
| *sync* (common) | Setting to set endpoint as one-way or request-response | true | boolean
| *tcpNoDelay* (common) | Setting to improve TCP protocol performance | true | 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
| *broadcast* (consumer) | Setting to choose Multicast over UDP | false | boolean
| *clientMode* (consumer) | If the clientMode is true, netty consumer will connect the address as a TCP client. | false | boolean
| *reconnect* (consumer) | Used only in clientMode in consumer, the consumer will attempt to reconnect on disconnection if this is enabled | true | boolean
| *reconnectInterval* (consumer) | Used if reconnect and clientMode is enabled. The interval in milli seconds to attempt reconnection | 10000 | int
| *backlog* (consumer) | Allows to configure a backlog for netty consumer (server). Note the backlog is just a best effort depending on the OS. Setting this option to a value such as 200, 500 or 1000, tells the TCP stack how long the accept queue can be If this option is not configured, then the backlog depends on OS setting. |  | int
| *bossCount* (consumer) | When netty works on nio mode, it uses default bossCount parameter from Netty, which is 1. User can use this option to override the default bossCount from Netty | 1 | int
| *bossGroup* (consumer) | Set the BossGroup which could be used for handling the new connection of the server side across the NettyEndpoint |  | EventLoopGroup
| *disconnectOnNoReply* (consumer) | If sync is enabled then this option dictates NettyConsumer if it should disconnect where there is no reply to send back. | true | 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. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut |  | ExchangePattern
| *nettyServerBootstrapFactory* (consumer) | To use a custom NettyServerBootstrapFactory |  | NettyServerBootstrapFactory
| *networkInterface* (consumer) | When using UDP then this option can be used to specify a network interface by its name, such as eth0 to join a multicast group. |  | String
| *noReplyLogLevel* (consumer) | If sync is enabled this option dictates NettyConsumer which logging level to use when logging a there is no reply to send back. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverClosedChannelException{zwsp}CaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an java.nio.channels.ClosedChannelException then its logged using this logging level. This is used to avoid logging the closed channel exceptions, as clients can disconnect abruptly and then cause a flood of closed exceptions in the Netty server. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | DEBUG | LoggingLevel
| *serverExceptionCaughtLogLevel* (consumer) | If the server (NettyConsumer) catches an exception then its logged using this logging level. There are 6 enums and the value can be one of: TRACE, DEBUG, INFO, WARN, ERROR, OFF | WARN | LoggingLevel
| *serverInitializerFactory* (consumer) | To use a custom ServerInitializerFactory |  | ServerInitializerFactory
| *usingExecutorService* (consumer) | Whether to use ordered thread pool, to ensure events are processed orderly on the same channel. | true | boolean
| *connectTimeout* (producer) | Time to wait for a socket connection to be available. Value is in milliseconds. | 10000 | int
| *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
| *requestTimeout* (producer) | Allows to use a timeout for the Netty producer when calling a remote server. By default no timeout is in use. The value is in milli seconds, so eg 30000 is 30 seconds. The requestTimeout is using Netty's ReadTimeoutHandler to trigger the timeout. |  | long
| *clientInitializerFactory* (producer) | To use a custom ClientInitializerFactory |  | ClientInitializerFactory
| *correlationManager* (producer) | To use a custom correlation manager to manage how request and reply messages are mapped when using request/reply with the netty producer. This should only be used if you have a way to map requests together with replies such as if there is correlation ids in both the request and reply messages. This can be used if you want to multiplex concurrent messages on the same channel (aka connection) in netty. When doing this you must have a way to correlate the request and reply messages so you can store the right reply on the inflight Camel Exchange before its continued routed. We recommend extending the TimeoutCorrelationManagerSupport when you build custom correlation managers. This provides support for timeout and other complexities you otherwise would need to implement as well. See also the producerPoolEnabled option for more details. |  | NettyCamelStateCorrelationManager
| *lazyChannelCreation* (producer) | Channels can be lazily created to avoid exceptions, if the remote server is not up and running when the Camel producer is started. | true | boolean
| *producerPoolEnabled* (producer) | Whether producer pool is enabled or not. Important: If you turn this off then a single shared connection is used for the producer, also if you are doing request/reply. That means there is a potential issue with interleaved responses if replies comes back out-of-order. Therefore you need to have a correlation id in both the request and reply messages so you can properly correlate the replies to the Camel callback that is responsible for continue processing the message in Camel. To do this you need to implement NettyCamelStateCorrelationManager as correlation manager and configure it via the correlationManager option. See also the correlationManager option for more details. | true | boolean
| *producerPoolMaxActive* (producer) | Sets the cap on the number of objects that can be allocated by the pool (checked out to clients, or idle awaiting checkout) at a given time. Use a negative value for no limit. | -1 | int
| *producerPoolMaxIdle* (producer) | Sets the cap on the number of idle instances in the pool. | 100 | int
| *producerPoolMinEvictableIdle* (producer) | Sets the minimum amount of time (value in millis) an object may sit idle in the pool before it is eligible for eviction by the idle object evictor. | 300000 | long
| *producerPoolMinIdle* (producer) | Sets the minimum number of instances allowed in the producer pool before the evictor thread (if active) spawns new objects. |  | int
| *udpConnectionlessSending* (producer) | This option supports connection less udp sending which is a real fire and forget. A connected udp send receive the PortUnreachableException if no one is listen on the receiving port. | false | boolean
| *useByteBuf* (producer) | If the useByteBuf is true, netty producer will turn the message body into ByteBuf before sending it out. | false | boolean
| *allowSerializedHeaders* (advanced) | Only used for TCP when transferExchange is true. When set to true, serializable objects in headers and properties will be added to the exchange. Otherwise Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *channelGroup* (advanced) | To use a explicit ChannelGroup. |  | ChannelGroup
| *nativeTransport* (advanced) | Whether to use native transport instead of NIO. Native transport takes advantage of the host operating system and is only supported on some platforms. You need to add the netty JAR for the host operating system you are using. See more details at: \\http://netty.io/wiki/native-transports.html | false | boolean
| *options* (advanced) | Allows to configure additional netty options using option. as prefix. For example option.child.keepAlive=false to set the netty option child.keepAlive=false. See the Netty documentation for possible options that can be used. |  | Map
| *receiveBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during inbound communication. Size is bytes. | 65536 | int
| *receiveBufferSizePredictor* (advanced) | Configures the buffer size predictor. See details at Jetty documentation and this mail thread. |  | int
| *sendBufferSize* (advanced) | The TCP/UDP buffer sizes to be used during outbound communication. Size is bytes. | 65536 | int
| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used | false | boolean
| *transferExchange* (advanced) | Only used for TCP. You can transfer the exchange over the wire instead of just the body. The following fields are transferred: In body, Out body, fault body, In headers, Out headers, fault headers, exchange properties, exchange exception. This requires that the objects are serializable. Camel will exclude any non-serializable objects and log it at WARN level. | false | boolean
| *udpByteArrayCodec* (advanced) | For UDP only. If enabled the using byte array codec instead of Java serialization protocol. | false | boolean
| *workerCount* (advanced) | When netty works on nio mode, it uses default workerCount parameter from Netty (which is cpu_core_threads x 2). User can use this option to override the default workerCount from Netty. |  | int
| *workerGroup* (advanced) | To use a explicit EventLoopGroup as the boss thread pool. For example to share a thread pool with multiple consumers or producers. By default each consumer or producer has their own worker pool with 2 x cpu count core threads. |  | EventLoopGroup
| *allowDefaultCodec* (codec) | The netty component installs a default codec if both, encoder/decoder is null and textline is false. Setting allowDefaultCodec to false prevents the netty component from installing a default codec as the first element in the filter chain. | true | boolean
| *autoAppendDelimiter* (codec) | Whether or not to auto append missing end delimiter when sending using the textline codec. | true | boolean
| *decoderMaxLineLength* (codec) | The max line length to use for the textline codec. | 1024 | int
| *decoders* (codec) | A list of decoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *delimiter* (codec) | The delimiter to use for the textline codec. Possible values are LINE and NULL. There are 2 enums and the value can be one of: LINE, NULL | LINE | TextLineDelimiter
| *encoders* (codec) | A list of encoders to be used. You can use a String which have values separated by comma, and have the values be looked up in the Registry. Just remember to prefix the value with # so Camel knows it should lookup. |  | List
| *encoding* (codec) | The encoding (a charset name) to use for the textline codec. If not provided, Camel will use the JVM default Charset. |  | String
| *textline* (codec) | Only used for TCP. If no codec is specified, you can use this flag to indicate a text line based codec; if not specified or the value is false, then Object Serialization is assumed over TCP - however only Strings are allowed to be serialized by default. | false | boolean
| *enabledProtocols* (security) | Which protocols to enable when using SSL | TLSv1,TLSv1.1,TLSv1.2 | String
| *keyStoreFile* (security) | Client side certificate keystore to be used for encryption |  | File
| *keyStoreFormat* (security) | Keystore format to be used for payload encryption. Defaults to JKS if not set |  | String
| *keyStoreResource* (security) | Client side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
| *needClientAuth* (security) | Configures whether the server needs client authentication when using SSL. | false | boolean
| *passphrase* (security) | Password setting to use in order to encrypt/decrypt payloads sent using SSH |  | String
| *securityProvider* (security) | Security provider to be used for payload encryption. Defaults to SunX509 if not set. |  | String
| *ssl* (security) | Setting to specify whether SSL encryption is applied to this endpoint | false | boolean
| *sslClientCertHeaders* (security) | When enabled and in SSL mode, then the Netty consumer will enrich the Camel Message with headers having information about the client certificate such as subject name, issuer name, serial number, and the valid date range. | false | boolean
| *sslContextParameters* (security) | To configure security using SSLContextParameters |  | SSLContextParameters
| *sslHandler* (security) | Reference to a class that could be used to return an SSL Handler |  | SslHandler
| *trustStoreFile* (security) | Server side certificate keystore to be used for encryption |  | File
| *trustStoreResource* (security) | Server side certificate keystore to be used for encryption. Is loaded by default from classpath, but you can prefix with classpath:, file:, or http: to load the resource from different systems. |  | String
|===
// endpoint options: END



== Registry based Options

Codec Handlers and SSL Keystores can be enlisted in the Registry, such as in the Spring XML file.
The values that could be passed in, are the following:

[width=""100%"",cols=""10%,90%"",options=""header"",]
|===
|Name |Description

|`passphrase` |password setting to use in order to encrypt/decrypt payloads sent using
SSH

|`keyStoreFormat` |keystore format to be used for payload encryption. Defaults to ""JKS"" if
not set

|`securityProvider` |Security provider to be used for payload encryption. Defaults to
""SunX509"" if not set.

|`keyStoreFile` |*deprecated:* Client side certificate keystore to be used for encryption

|`trustStoreFile` |*deprecated:* Server side certificate keystore to be used for encryption

|`keyStoreResource` |Client side certificate keystore to be used for
encryption. Is loaded by default from classpath, but you can prefix with
`""classpath:""`, `""file:""`, or `""http:""` to load the resource from
different systems.

|`trustStoreResource` |Server side certificate keystore to be used for
encryption. Is loaded by default from classpath, but you can prefix with
`""classpath:""`, `""file:""`, or `""http:""` to load the resource from
different systems.

|`sslHandler` |Reference to a class that could be used to return an SSL Handler

|`encoder` |A custom `ChannelHandler` class that can be used to perform special
marshalling of outbound payloads. Must override
io.netty.channel.ChannelInboundHandlerAdapter.

|`encoders` |A list of encoders to be used. You can use a String which have values
separated by comma, and have the values be looked up in the
Registry. Just remember to prefix the value with #
so Camel knows it should lookup.

|`decoder` |A custom `ChannelHandler` class that can be used to perform special
marshalling of inbound payloads. Must override
io.netty.channel.ChannelOutboundHandlerAdapter.

|`decoders` |A list of decoders to be used. You can use a String which have values
separated by comma, and have the values be looked up in the
Registry. Just remember to prefix the value with #
so Camel knows it should lookup.
|===

[NOTE]
====
Read below about using non shareable encoders/decoders.
====

=== Using non shareable encoders or decoders

If your encoders or decoders are not shareable (e.g. they don't have the
@Shareable class annotation), then your encoder/decoder must implement
the `org.apache.camel.component.netty.ChannelHandlerFactory` interface,
and return a new instance in the `newChannelHandler` method. This is to
ensure the encoder/decoder can safely be used. If this is not the case,
then the Netty component will log a WARN when an endpoint is created.

The Netty component offers a
`org.apache.camel.component.netty.ChannelHandlerFactories` factory
class, that has a number of commonly used methods.

== Sending Messages to/from a Netty endpoint

=== Netty Producer

In Producer mode, the component provides the ability to send payloads to
a socket endpoint using either TCP or UDP protocols (with optional SSL support).

The producer mode supports both one-way and request-response based operations.

=== Netty Consumer

In Consumer mode, the component provides the ability to:

* listen on a specified socket using either TCP or UDP protocols (with
optional SSL support),
* receive requests on the socket using text/xml, binary and serialized
object based payloads and
* send them along on a route as message exchanges.

The consumer mode supports both one-way and request-response based
operations.

== Examples

=== A UDP Netty endpoint using Request-Reply and serialized object payload

Note that Object serialization is not allowed by default, and so a decoder must be configured.

[source,java]
----
@BindToRegistry(""decoder"")
public ChannelHandler getDecoder() throws Exception {
    return new DefaultChannelHandlerFactory() {
        @Override
        public ChannelHandler newChannelHandler() {
            return new DatagramPacketObjectDecoder(ClassResolvers.weakCachingResolver(null));
        }
    };
}

RouteBuilder builder = new RouteBuilder() {
  public void configure() {
    from(""netty:udp://0.0.0.0:5155?sync=true&decoders=#decoder"")
      .process(new Processor() {
         public void process(Exchange exchange) throws Exception {
           Poetry poetry = (Poetry) exchange.getIn().getBody();
           // Process poetry in some way
           exchange.getOut().setBody(""Message received);
         }
       }
    }
};
----

=== A TCP based Netty consumer endpoint using One-way communication

[source,java]
----
RouteBuilder builder = new RouteBuilder() {
  public void configure() {
       from(""netty:tcp://0.0.0.0:5150"")
           .to(""mock:result"");
  }
};
----

=== An SSL/TCP based Netty consumer endpoint using Request-Reply communication

[[Netty-UsingtheJSSEConfigurationUtility]]
Using the JSSE Configuration Utility

The Netty component supports SSL/TLS configuration
through the xref:manual::camel-configuration-utilities.adoc[Camel JSSE
Configuration Utility].  This utility greatly decreases the amount of
component specific code you need to write and is configurable at the
endpoint and component levels.  The following examples demonstrate how
to use the utility with the Netty component.

[[Netty-Programmaticconfigurationofthecomponent]]
Programmatic configuration of the component

[source,java]
----
KeyStoreParameters ksp = new KeyStoreParameters();
ksp.setResource(""/users/home/server/keystore.jks"");
ksp.setPassword(""keystorePassword"");

KeyManagersParameters kmp = new KeyManagersParameters();
kmp.setKeyStore(ksp);
kmp.setKeyPassword(""keyPassword"");

SSLContextParameters scp = new SSLContextParameters();
scp.setKeyManagers(kmp);

NettyComponent nettyComponent = getContext().getComponent(""netty"", NettyComponent.class);
nettyComponent.setSslContextParameters(scp);
----

[[Netty-SpringDSLbasedconfigurationofendpoint]]
Spring DSL based configuration of endpoint

[source,xml]
----
...
  <camel:sslContextParameters
      id=""sslContextParameters"">
    <camel:keyManagers
        keyPassword=""keyPassword"">
      <camel:keyStore
          resource=""/users/home/server/keystore.jks""
          password=""keystorePassword""/>
    </camel:keyManagers>
  </camel:sslContextParameters>...
...
  <to uri=""netty:tcp://0.0.0.0:5150?sync=true&ssl=true&sslContextParameters=#sslContextParameters""/>
...
----

[[Netty-UsingBasicSSLTLSconfigurationontheJettyComponent]]
Using Basic SSL/TLS configuration on the Jetty Component

[source,java]
----
Registry registry = context.getRegistry();
registry.bind(""password"", ""changeit"");
registry.bind(""ksf"", new File(""src/test/resources/keystore.jks""));
registry.bind(""tsf"", new File(""src/test/resources/keystore.jks""));

context.addRoutes(new RouteBuilder() {
  public void configure() {
      String netty_ssl_endpoint =
         ""netty:tcp://0.0.0.0:5150?sync=true&ssl=true&passphrase=#password""
         + ""&keyStoreFile=#ksf&trustStoreFile=#tsf"";
      String return_string =
         ""When You Go Home, Tell Them Of Us And Say,""
         + ""For Your Tomorrow, We Gave Our Today."";

      from(netty_ssl_endpoint)
       .process(new Processor() {
          public void process(Exchange exchange) throws Exception {
            exchange.getOut().setBody(return_string);
          }
       }
  }
});
----

[[Netty-GettingaccesstoSSLSessionandtheclientcertificate]]
Getting access to SSLSession and the client certificate

You can get access to the `javax.net.ssl.SSLSession` if you eg need to
get details about the client certificate. When `ssl=true` then the
xref:netty-component.adoc[Netty] component will store the `SSLSession` as a
header on the Camel Message as shown below:

[source,java]
----
SSLSession session = exchange.getIn().getHeader(NettyConstants.NETTY_SSL_SESSION, SSLSession.class);
// get the first certificate which is client certificate
javax.security.cert.X509Certificate cert = session.getPeerCertificateChain()[0];
Principal principal = cert.getSubjectDN();
----

Remember to set `needClientAuth=true` to authenticate the client,
otherwise `SSLSession` cannot access information about the client
certificate, and you may get an exception
`javax.net.ssl.SSLPeerUnverifiedException: peer not authenticated`. You
may also get this exception if the client certificate is expired or not
valid etc.

[TIP]
====
The option `sslClientCertHeaders` can be set to `true` which then
enriches the Camel Message with headers having
details about the client certificate. For example the subject name is
readily available in the header `CamelNettySSLClientCertSubjectName`.
====

=== Using Multiple Codecs

In certain cases it may be necessary to add chains of encoders and
decoders to the netty pipeline. To add multpile codecs to a camel netty
endpoint the 'encoders' and 'decoders' uri parameters should be used.
Like the 'encoder' and 'decoder' parameters they are used to supply
references (lists of ChannelUpstreamHandlers and
ChannelDownstreamHandlers) that should be added to the pipeline. Note
that if encoders is specified then the encoder param will be ignored,
similarly for decoders and the decoder param.

[NOTE]
====
Read further above about using non shareable encoders/decoders.
====

The lists of codecs need to be added to the Camel's registry so they can
be resolved when the endpoint is created.

[source,java]
----
ChannelHandlerFactory lengthDecoder = ChannelHandlerFactories.newLengthFieldBasedFrameDecoder(1048576, 0, 4, 0, 4);

StringDecoder stringDecoder = new StringDecoder();
registry.bind(""length-decoder"", lengthDecoder);
registry.bind(""string-decoder"", stringDecoder);

LengthFieldPrepender lengthEncoder = new LengthFieldPrepender(4);
StringEncoder stringEncoder = new StringEncoder();
registry.bind(""length-encoder"", lengthEncoder);
registry.bind(""string-encoder"", stringEncoder);

List<ChannelHandler> decoders = new ArrayList<ChannelHandler>();
decoders.add(lengthDecoder);
decoders.add(stringDecoder);

List<ChannelHandler> encoders = new ArrayList<ChannelHandler>();
encoders.add(lengthEncoder);
encoders.add(stringEncoder);

registry.bind(""encoders"", encoders);
registry.bind(""decoders"", decoders);
----

Spring's native collections support can be used to specify the codec
lists in an application context

[source,xml]
----
<util:list id=""decoders"" list-class=""java.util.LinkedList"">
        <bean class=""org.apache.camel.component.netty.ChannelHandlerFactories"" factory-method=""newLengthFieldBasedFrameDecoder"">
            <constructor-arg value=""1048576""/>
            <constructor-arg value=""0""/>
            <constructor-arg value=""4""/>
            <constructor-arg value=""0""/>
            <constructor-arg value=""4""/>
        </bean>
        <bean class=""io.netty.handler.codec.string.StringDecoder""/>
    </util:list>

    <util:list id=""encoders"" list-class=""java.util.LinkedList"">
        <bean class=""io.netty.handler.codec.LengthFieldPrepender"">
            <constructor-arg value=""4""/>
        </bean>
        <bean class=""io.netty.handler.codec.string.StringEncoder""/>
    </util:list>

    <bean id=""length-encoder"" class=""io.netty.handler.codec.LengthFieldPrepender"">
        <constructor-arg value=""4""/>
    </bean>
    <bean id=""string-encoder"" class=""io.netty.handler.codec.string.StringEncoder""/>

    <bean id=""length-decoder"" class=""org.apache.camel.component.netty.ChannelHandlerFactories"" factory-method=""newLengthFieldBasedFrameDecoder"">
        <constructor-arg value=""1048576""/>
        <constructor-arg value=""0""/>
        <constructor-arg value=""4""/>
        <constructor-arg value=""0""/>
        <constructor-arg value=""4""/>
    </bean>
    <bean id=""string-decoder"" class=""io.netty.handler.codec.string.StringDecoder""/>
----

The bean names can then be used in netty endpoint definitions either as
a comma separated list or contained in a List e.g.

[source,java]
----
 from(""direct:multiple-codec"").to(""netty:tcp://0.0.0.0:{{port}}?encoders=#encoders&sync=false"");

 from(""netty:tcp://0.0.0.0:{{port}}?decoders=#length-decoder,#string-decoder&sync=false"").to(""mock:multiple-codec"");
----

or via XML.

[source,xml]
----
<camelContext id=""multiple-netty-codecs-context"" xmlns=""http://camel.apache.org/schema/spring"">
    <route>
        <from uri=""direct:multiple-codec""/>
        <to uri=""netty:tcp://0.0.0.0:5150?encoders=#encoders&amp;sync=false""/>
    </route>
    <route>
        <from uri=""netty:tcp://0.0.0.0:5150?decoders=#length-decoder,#string-decoder&amp;sync=false""/>
        <to uri=""mock:multiple-codec""/>
    </route>
</camelContext>
----

== Closing Channel When Complete

When acting as a server you sometimes want to close the channel when,
for example, a client conversion is finished. +
 You can do this by simply setting the endpoint option
`disconnect=true`.

However you can also instruct Camel on a per message basis as follows. +
 To instruct Camel to close the channel, you should add a header with
the key `CamelNettyCloseChannelWhenComplete` set to a boolean `true`
value. +
 For instance, the example below will close the channel after it has
written the bye message back to the client:

[source,java]
----
from(""netty:tcp://0.0.0.0:8080"").process(new Processor() {
    public void process(Exchange exchange) throws Exception {
        String body = exchange.getIn().getBody(String.class);
        exchange.getOut().setBody(""Bye "" + body);
        // some condition which determines if we should close
        if (close) {
            exchange.getOut().setHeader(NettyConstants.NETTY_CLOSE_CHANNEL_WHEN_COMPLETE, true);
        }
    }
});
----

[[Netty-Addingcustomchannelpipelinefactoriestogaincompletecontroloveracreatedpipeline]]
Adding custom channel pipeline factories to gain complete control over a created pipeline

== Custom pipeline

Custom channel pipelines provide complete control to the user over the
handler/interceptor chain by inserting custom handler(s), encoder(s) &
decoder(s) without having to specify them in the Netty Endpoint URL in a
very simple way.

In order to add a custom pipeline, a custom channel pipeline factory
must be created and registered with the context via the context registry
(Registry, or the camel-spring ApplicationContextRegistry etc).

A custom pipeline factory must be constructed as follows

* A Producer linked channel pipeline factory must extend the abstract
class `ClientPipelineFactory`.
* A Consumer linked channel pipeline factory must extend the abstract
class `ServerInitializerFactory`.
* The classes should override the initChannel() method in order to
insert custom handler(s), encoder(s) and decoder(s). Not overriding the
`initChannel()` method creates a pipeline with no handlers, encoders or
decoders wired to the pipeline.

The example below shows how ServerInitializerFactory factory may be
created

=== Using custom pipeline factory

[source,java]
----
public class SampleServerInitializerFactory extends ServerInitializerFactory {
    private int maxLineSize = 1024;

    protected void initChannel(Channel ch) throws Exception {
        ChannelPipeline channelPipeline = ch.pipeline();

        channelPipeline.addLast(""encoder-SD"", new StringEncoder(CharsetUtil.UTF_8));
        channelPipeline.addLast(""decoder-DELIM"", new DelimiterBasedFrameDecoder(maxLineSize, true, Delimiters.lineDelimiter()));
        channelPipeline.addLast(""decoder-SD"", new StringDecoder(CharsetUtil.UTF_8));
        // here we add the default Camel ServerChannelHandler for the consumer, to allow Camel to route the message etc.
        channelPipeline.addLast(""handler"", new ServerChannelHandler(consumer));
    }
}
----

The custom channel pipeline factory can then be added to the registry
and instantiated/utilized on a camel route in the following way

[source,java]
----
Registry registry = camelContext.getRegistry();
ServerInitializerFactory factory = new TestServerInitializerFactory();
registry.bind(""spf"", factory);
context.addRoutes(new RouteBuilder() {
  public void configure() {
      String netty_ssl_endpoint =
         ""netty:tcp://0.0.0.0:5150?serverInitializerFactory=#spf""
      String return_string =
         ""When You Go Home, Tell Them Of Us And Say,""
         + ""For Your Tomorrow, We Gave Our Today."";

      from(netty_ssl_endpoint)
       .process(new Processor() {
          public void process(Exchange exchange) throws Exception {
            exchange.getOut().setBody(return_string);
          }
       }
  }
});
----

== Reusing Netty boss and worker thread pools

Netty has two kind of thread pools: boss and worker. By default each
Netty consumer and producer has their private thread pools. If you want
to reuse these thread pools among multiple consumers or producers then
the thread pools must be created and enlisted in the
Registry.

For example using Spring XML we can create a shared worker thread pool
using the `NettyWorkerPoolBuilder` with 2 worker threads as shown below:

[source,xml]
----
<!-- use the worker pool builder to help create the shared thread pool -->
<bean id=""poolBuilder"" class=""org.apache.camel.component.netty.NettyWorkerPoolBuilder"">
  <property name=""workerCount"" value=""2""/>
</bean>

<!-- the shared worker thread pool -->
<bean id=""sharedPool"" class=""org.jboss.netty.channel.socket.nio.WorkerPool""
      factory-bean=""poolBuilder"" factory-method=""build"" destroy-method=""shutdown"">
</bean>
----

[TIP]
====
For boss thread pool there is a
`org.apache.camel.component.netty.NettyServerBossPoolBuilder` builder
for Netty consumers, and a
`org.apache.camel.component.netty.NettyClientBossPoolBuilder` for the
Netty producers.
====

Then in the Camel routes we can refer to this worker pools by
configuring the `workerPool` option in the URI as shown below:

[source,xml]
----
<route>
  <from uri=""netty:tcp://0.0.0.0:5021?textline=true&amp;sync=true&amp;workerPool=#sharedPool&amp;usingExecutorService=false""/>
  <to uri=""log:result""/>
  ...
</route>
----

And if we have another route we can refer to the shared worker pool:

[source,xml]
----
<route>
  <from uri=""netty:tcp://0.0.0.0:5022?textline=true&amp;sync=true&amp;workerPool=#sharedPool&amp;usingExecutorService=false""/>
  <to uri=""log:result""/>
  ...
</route>
----

and so forth.

== Multiplexing concurrent messages over a single connection with request/reply

When using Netty for request/reply messaging via the netty producer then by default each
message is sent via a non-shared connection (pooled). This ensures that replies are
automatic being able to map to the correct request thread for further routing in Camel.
In other words correlation between request/reply messages happens out-of-the-box because
the replies comes back on the same connection that was used for sending the request;
and this connection is not shared with others. When the response comes back, the connection
is returned back to the connection pool, where it can be reused by others.

However if you want to multiplex concurrent request/responses on a single shared connection,
then you need to turn off the connection pooling by setting `producerPoolEnabled=false`.
Now this means there is a potential issue with interleaved responses if replies comes back out-of-order.
Therefore you need to have a correlation id in both the request and reply messages so you can properly
correlate the replies to the Camel callback that is responsible for continue processing the message in Camel.
To do this you need to implement `NettyCamelStateCorrelationManager` as correlation manager and configure
it via the `correlationManager=#myManager` option.

[NOTE]
====
We recommend extending the `TimeoutCorrelationManagerSupport` when you build custom correlation managers.
This provides support for timeout and other complexities you otherwise would need to implement as well.
====

You can find an example with the Apache Camel source code in the examples directory
under the `camel-example-netty-custom-correlation` directory.


include::camel-spring-boot::page$netty-starter.adoc[]
",12462,False,2327.444818527107,median
"// Copyright (c) 2009-2019 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include <chain.h>
#include <core_io.h>
#include <interfaces/chain.h>
#include <key_io.h>
#include <merkleblock.h>
#include <rpc/util.h>
#include <script/descriptor.h>
#include <script/script.h>
#include <script/standard.h>
#include <sync.h>
#include <util/bip32.h>
#include <util/system.h>
#include <util/time.h>
#include <util/translation.h>
#include <wallet/rpcwallet.h>
#include <wallet/wallet.h>

#include <stdint.h>
#include <tuple>

#include <boost/algorithm/string.hpp>

#include <univalue.h>



std::string static EncodeDumpString(const std::string &str) {
    std::stringstream ret;
    for (const unsigned char c : str) {
        if (c <= 32 || c >= 128 || c == '%') {
            ret << '%' << HexStr(&c, &c + 1);
        } else {
            ret << c;
        }
    }
    return ret.str();
}

static std::string DecodeDumpString(const std::string &str) {
    std::stringstream ret;
    for (unsigned int pos = 0; pos < str.length(); pos++) {
        unsigned char c = str[pos];
        if (c == '%' && pos+2 < str.length()) {
            c = (((str[pos+1]>>6)*9+((str[pos+1]-'0')&15)) << 4) |
                ((str[pos+2]>>6)*9+((str[pos+2]-'0')&15));
            pos += 2;
        }
        ret << c;
    }
    return ret.str();
}

static bool GetWalletAddressesForKey(LegacyScriptPubKeyMan* spk_man, const CWallet* const pwallet, const CKeyID& keyid, std::string& strAddr, std::string& strLabel) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
{
    bool fLabelFound = false;
    CKey key;
    spk_man->GetKey(keyid, key);
    for (const auto& dest : GetAllDestinationsForKey(key.GetPubKey())) {
        const auto* address_book_entry = pwallet->FindAddressBookEntry(dest);
        if (address_book_entry) {
            if (!strAddr.empty()) {
                strAddr += "","";
            }
            strAddr += EncodeDestination(dest);
            strLabel = EncodeDumpString(address_book_entry->GetLabel());
            fLabelFound = true;
        }
    }
    if (!fLabelFound) {
        strAddr = EncodeDestination(GetDestinationForKey(key.GetPubKey(), pwallet->m_default_address_type));
    }
    return fLabelFound;
}

static const int64_t TIMESTAMP_MIN = 0;

static void RescanWallet(CWallet& wallet, const WalletRescanReserver& reserver, int64_t time_begin = TIMESTAMP_MIN, bool update = true)
{
    int64_t scanned_time = wallet.RescanFromTime(time_begin, reserver, update);
    if (wallet.IsAbortingRescan()) {
        throw JSONRPCError(RPC_MISC_ERROR, ""Rescan aborted by user."");
    } else if (scanned_time > time_begin) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Rescan was unable to fully rescan the blockchain. Some transactions may be missing."");
    }
}

UniValue importprivkey(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importprivkey"",
                ""\\nAdds a private key (as returned by dumpprivkey) to your wallet. Requires a new wallet backup.\\n""
                ""Hint: use importmulti to import more than one private key.\\n""
            ""\\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\\n""
            ""may report that the imported key exists but related transactions are still missing, leading to temporarily incorrect/bogus balances and unspent outputs until rescan completes.\\n""
            ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {
                    {""privkey"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The private key (see dumpprivkey)""},
                    {""label"", RPCArg::Type::STR, /* default */ ""current label if address exists, otherwise \\""\\"""", ""An optional label""},
                    {""rescan"", RPCArg::Type::BOOL, /* default */ ""true"", ""Rescan the wallet for transactions""},
                },
                RPCResult{RPCResult::Type::NONE, """", """"},
                RPCExamples{
            ""\\nDump a private key\\n""
            + HelpExampleCli(""dumpprivkey"", ""\\""myaddress\\"""") +
            ""\\nImport the private key with rescan\\n""
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"""") +
            ""\\nImport using a label and without rescan\\n""
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"" \\""testing\\"" false"") +
            ""\\nImport using default blank label and without rescan\\n""
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"" \\""\\"" false"") +
            ""\\nAs a JSON-RPC call\\n""
            + HelpExampleRpc(""importprivkey"", ""\\""mykey\\"", \\""testing\\"", false"")
                },
            }.Check(request);

    if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Cannot import private keys to a wallet with private keys disabled"");
    }

    EnsureLegacyScriptPubKeyMan(*wallet, true);

    WalletRescanReserver reserver(pwallet);
    bool fRescan = true;
    {
        auto locked_chain = pwallet->chain().lock();
        LOCK(pwallet->cs_wallet);

        EnsureWalletIsUnlocked(pwallet);

        std::string strSecret = request.params[0].get_str();
        std::string strLabel = """";
        if (!request.params[1].isNull())
            strLabel = request.params[1].get_str();

        // Whether to perform rescan after import
        if (!request.params[2].isNull())
            fRescan = request.params[2].get_bool();

        if (fRescan && pwallet->chain().havePruned()) {
            // Exit early and print an error.
            // If a block is pruned after this check, we will import the key(s),
            // but fail the rescan with a generic error.
            throw JSONRPCError(RPC_WALLET_ERROR, ""Rescan is disabled when blocks are pruned"");
        }

        if (fRescan && !reserver.reserve()) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Wallet is currently rescanning. Abort existing rescan or wait."");
        }

        CKey key = DecodeSecret(strSecret);
        if (!key.IsValid()) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid private key encoding"");

        CPubKey pubkey = key.GetPubKey();
        CHECK_NONFATAL(key.VerifyPubKey(pubkey));
        CKeyID vchAddress = pubkey.GetID();
        {
            pwallet->MarkDirty();

            // We don't know which corresponding address will be used;
            // label all new addresses, and label existing addresses if a
            // label was passed.
            for (const auto& dest : GetAllDestinationsForKey(pubkey)) {
                if (!request.params[1].isNull() || !pwallet->FindAddressBookEntry(dest)) {
                    pwallet->SetAddressBook(dest, strLabel, ""receive"");
                }
            }

            // Use timestamp of 1 to scan the whole chain
            if (!pwallet->ImportPrivKeys({{vchAddress, key}}, 1)) {
                throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding key to wallet"");
            }

            // Add the wpkh script for this key if possible
            if (pubkey.IsCompressed()) {
                pwallet->ImportScripts({GetScriptForDestination(WitnessV0KeyHash(vchAddress))}, 0 /* timestamp */);
            }
        }
    }
    if (fRescan) {
        RescanWallet(*pwallet, reserver);
    }

    return NullUniValue;
}

UniValue abortrescan(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""abortrescan"",
                ""\\nStops current wallet rescan triggered by an RPC call, e.g. by an importprivkey call.\\n""
                ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {},
                RPCResult{RPCResult::Type::BOOL, """", ""Whether the abort was successful""},
                RPCExamples{
            ""\\nImport a private key\\n""
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"""") +
            ""\\nAbort the running wallet rescan\\n""
            + HelpExampleCli(""abortrescan"", """") +
            ""\\nAs a JSON-RPC call\\n""
            + HelpExampleRpc(""abortrescan"", """")
                },
            }.Check(request);

    if (!pwallet->IsScanning() || pwallet->IsAbortingRescan()) return false;
    pwallet->AbortRescan();
    return true;
}

UniValue importaddress(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importaddress"",
                ""\\nAdds an address or script (in hex) that can be watched as if it were in your wallet but cannot be used to spend. Requires a new wallet backup.\\n""
            ""\\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\\n""
            ""may report that the imported address exists but related transactions are still missing, leading to temporarily incorrect/bogus balances and unspent outputs until rescan completes.\\n""
            ""If you have the full public key, you should call importpubkey instead of this.\\n""
            ""Hint: use importmulti to import more than one address.\\n""
            ""\\nNote: If you import a non-standard raw script in hex form, outputs sending to it will be treated\\n""
            ""as change, and not show up in many RPCs.\\n""
            ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {
                    {""address"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The Bitcoin address (or hex-encoded script)""},
                    {""label"", RPCArg::Type::STR, /* default */ ""\\""\\"""", ""An optional label""},
                    {""rescan"", RPCArg::Type::BOOL, /* default */ ""true"", ""Rescan the wallet for transactions""},
                    {""p2sh"", RPCArg::Type::BOOL, /* default */ ""false"", ""Add the P2SH version of the script as well""},
                },
                RPCResult{RPCResult::Type::NONE, """", """"},
                RPCExamples{
            ""\\nImport an address with rescan\\n""
            + HelpExampleCli(""importaddress"", ""\\""myaddress\\"""") +
            ""\\nImport using a label without rescan\\n""
            + HelpExampleCli(""importaddress"", ""\\""myaddress\\"" \\""testing\\"" false"") +
            ""\\nAs a JSON-RPC call\\n""
            + HelpExampleRpc(""importaddress"", ""\\""myaddress\\"", \\""testing\\"", false"")
                },
            }.Check(request);

    EnsureLegacyScriptPubKeyMan(*pwallet, true);

    std::string strLabel;
    if (!request.params[1].isNull())
        strLabel = request.params[1].get_str();

    // Whether to perform rescan after import
    bool fRescan = true;
    if (!request.params[2].isNull())
        fRescan = request.params[2].get_bool();

    if (fRescan && pwallet->chain().havePruned()) {
        // Exit early and print an error.
        // If a block is pruned after this check, we will import the key(s),
        // but fail the rescan with a generic error.
        throw JSONRPCError(RPC_WALLET_ERROR, ""Rescan is disabled when blocks are pruned"");
    }

    WalletRescanReserver reserver(pwallet);
    if (fRescan && !reserver.reserve()) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Wallet is currently rescanning. Abort existing rescan or wait."");
    }

    // Whether to import a p2sh version, too
    bool fP2SH = false;
    if (!request.params[3].isNull())
        fP2SH = request.params[3].get_bool();

    {
        auto locked_chain = pwallet->chain().lock();
        LOCK(pwallet->cs_wallet);

        CTxDestination dest = DecodeDestination(request.params[0].get_str());
        if (IsValidDestination(dest)) {
            if (fP2SH) {
                throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Cannot use the p2sh flag with an address - use a script instead"");
            }

            pwallet->MarkDirty();

            pwallet->ImportScriptPubKeys(strLabel, {GetScriptForDestination(dest)}, false /* have_solving_data */, true /* apply_label */, 1 /* timestamp */);
        } else if (IsHex(request.params[0].get_str())) {
            std::vector<unsigned char> data(ParseHex(request.params[0].get_str()));
            CScript redeem_script(data.begin(), data.end());

            std::set<CScript> scripts = {redeem_script};
            pwallet->ImportScripts(scripts, 0 /* timestamp */);

            if (fP2SH) {
                scripts.insert(GetScriptForDestination(ScriptHash(CScriptID(redeem_script))));
            }

            pwallet->ImportScriptPubKeys(strLabel, scripts, false /* have_solving_data */, true /* apply_label */, 1 /* timestamp */);
        } else {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid Bitcoin address or script"");
        }
    }
    if (fRescan)
    {
        RescanWallet(*pwallet, reserver);
        {
            auto locked_chain = pwallet->chain().lock();
            LOCK(pwallet->cs_wallet);
            pwallet->ReacceptWalletTransactions();
        }
    }

    return NullUniValue;
}

UniValue importprunedfunds(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importprunedfunds"",
                ""\\nImports funds without rescan. Corresponding address or script must previously be included in wallet. Aimed towards pruned wallets. The end-user is responsible to import additional transactions that subsequently spend the imported outputs or rescan after the point in the blockchain the transaction is included.\\n"",
                {
                    {""rawtransaction"", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, ""A raw transaction in hex funding an already-existing address in wallet""},
                    {""txoutproof"", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, ""The hex output from gettxoutproof that contains the transaction""},
                },
                RPCResult{RPCResult::Type::NONE, """", """"},
                RPCExamples{""""},
            }.Check(request);

    CMutableTransaction tx;
    if (!DecodeHexTx(tx, request.params[0].get_str())) {
        throw JSONRPCError(RPC_DESERIALIZATION_ERROR, ""TX decode failed. Make sure the tx has at least one input."");
    }
    uint256 hashTx = tx.GetHash();
    CWalletTx wtx(pwallet, MakeTransactionRef(std::move(tx)));

    CDataStream ssMB(ParseHexV(request.params[1], ""proof""), SER_NETWORK, PROTOCOL_VERSION);
    CMerkleBlock merkleBlock;
    ssMB >> merkleBlock;

    //Search partial merkle tree in proof for our transaction and index in valid block
    std::vector<uint256> vMatch;
    std::vector<unsigned int> vIndex;
    if (merkleBlock.txn.ExtractMatches(vMatch, vIndex) != merkleBlock.header.hashMerkleRoot) {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Something wrong with merkleblock"");
    }

    auto locked_chain = pwallet->chain().lock();
    Optional<int> height = locked_chain->getBlockHeight(merkleBlock.header.GetHash());
    if (height == nullopt) {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Block not found in chain"");
    }

    std::vector<uint256>::const_iterator it;
    if ((it = std::find(vMatch.begin(), vMatch.end(), hashTx)) == vMatch.end()) {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Transaction given doesn't exist in proof"");
    }

    unsigned int txnIndex = vIndex[it - vMatch.begin()];

    CWalletTx::Confirmation confirm(CWalletTx::Status::CONFIRMED, *height, merkleBlock.header.GetHash(), txnIndex);
    wtx.m_confirm = confirm;

    LOCK(pwallet->cs_wallet);

    if (pwallet->IsMine(*wtx.tx)) {
        pwallet->AddToWallet(wtx, false);
        return NullUniValue;
    }

    throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""No addresses in wallet correspond to included transaction"");
}

UniValue removeprunedfunds(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""removeprunedfunds"",
                ""\\nDeletes the specified transaction from the wallet. Meant for use with pruned wallets and as a companion to importprunedfunds. This will affect wallet balances.\\n"",
                {
                    {""txid"", RPCArg::Type::STR_HEX, RPCArg::Optional::NO, ""The hex-encoded id of the transaction you are deleting""},
                },
                RPCResult{RPCResult::Type::NONE, """", """"},
                RPCExamples{
                    HelpExampleCli(""removeprunedfunds"", ""\\""a8d0c0184dde994a09ec054286f1ce581bebf46446a512166eae7628734ea0a5\\"""") +
            ""\\nAs a JSON-RPC call\\n""
            + HelpExampleRpc(""removeprunedfunds"", ""\\""a8d0c0184dde994a09ec054286f1ce581bebf46446a512166eae7628734ea0a5\\"""")
                },
            }.Check(request);

    auto locked_chain = pwallet->chain().lock();
    LOCK(pwallet->cs_wallet);

    uint256 hash(ParseHashV(request.params[0], ""txid""));
    std::vector<uint256> vHash;
    vHash.push_back(hash);
    std::vector<uint256> vHashOut;

    if (pwallet->ZapSelectTx(vHash, vHashOut) != DBErrors::LOAD_OK) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Could not properly delete the transaction."");
    }

    if(vHashOut.empty()) {
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""Transaction does not exist in wallet."");
    }

    return NullUniValue;
}

UniValue importpubkey(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importpubkey"",
                ""\\nAdds a public key (in hex) that can be watched as if it were in your wallet but cannot be used to spend. Requires a new wallet backup.\\n""
                ""Hint: use importmulti to import more than one public key.\\n""
            ""\\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\\n""
            ""may report that the imported pubkey exists but related transactions are still missing, leading to temporarily incorrect/bogus balances and unspent outputs until rescan completes.\\n""
            ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {
                    {""pubkey"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The hex-encoded public key""},
                    {""label"", RPCArg::Type::STR, /* default */ ""\\""\\"""", ""An optional label""},
                    {""rescan"", RPCArg::Type::BOOL, /* default */ ""true"", ""Rescan the wallet for transactions""},
                },
                RPCResult{RPCResult::Type::NONE, """", """"},
                RPCExamples{
            ""\\nImport a public key with rescan\\n""
            + HelpExampleCli(""importpubkey"", ""\\""mypubkey\\"""") +
            ""\\nImport using a label without rescan\\n""
            + HelpExampleCli(""importpubkey"", ""\\""mypubkey\\"" \\""testing\\"" false"") +
            ""\\nAs a JSON-RPC call\\n""
            + HelpExampleRpc(""importpubkey"", ""\\""mypubkey\\"", \\""testing\\"", false"")
                },
            }.Check(request);

    EnsureLegacyScriptPubKeyMan(*wallet, true);

    std::string strLabel;
    if (!request.params[1].isNull())
        strLabel = request.params[1].get_str();

    // Whether to perform rescan after import
    bool fRescan = true;
    if (!request.params[2].isNull())
        fRescan = request.params[2].get_bool();

    if (fRescan && pwallet->chain().havePruned()) {
        // Exit early and print an error.
        // If a block is pruned after this check, we will import the key(s),
        // but fail the rescan with a generic error.
        throw JSONRPCError(RPC_WALLET_ERROR, ""Rescan is disabled when blocks are pruned"");
    }

    WalletRescanReserver reserver(pwallet);
    if (fRescan && !reserver.reserve()) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Wallet is currently rescanning. Abort existing rescan or wait."");
    }

    if (!IsHex(request.params[0].get_str()))
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Pubkey must be a hex string"");
    std::vector<unsigned char> data(ParseHex(request.params[0].get_str()));
    CPubKey pubKey(data.begin(), data.end());
    if (!pubKey.IsFullyValid())
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Pubkey is not a valid public key"");

    {
        auto locked_chain = pwallet->chain().lock();
        LOCK(pwallet->cs_wallet);

        std::set<CScript> script_pub_keys;
        for (const auto& dest : GetAllDestinationsForKey(pubKey)) {
            script_pub_keys.insert(GetScriptForDestination(dest));
        }

        pwallet->MarkDirty();

        pwallet->ImportScriptPubKeys(strLabel, script_pub_keys, true /* have_solving_data */, true /* apply_label */, 1 /* timestamp */);

        pwallet->ImportPubKeys({pubKey.GetID()}, {{pubKey.GetID(), pubKey}} , {} /* key_origins */, false /* add_keypool */, false /* internal */, 1 /* timestamp */);
    }
    if (fRescan)
    {
        RescanWallet(*pwallet, reserver);
        {
            auto locked_chain = pwallet->chain().lock();
            LOCK(pwallet->cs_wallet);
            pwallet->ReacceptWalletTransactions();
        }
    }

    return NullUniValue;
}


UniValue importwallet(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importwallet"",
                ""\\nImports keys from a wallet dump file (see dumpwallet). Requires a new wallet backup to include imported keys.\\n""
                ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {
                    {""filename"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The wallet file""},
                },
                RPCResult{RPCResult::Type::NONE, """", """"},
                RPCExamples{
            ""\\nDump the wallet\\n""
            + HelpExampleCli(""dumpwallet"", ""\\""test\\"""") +
            ""\\nImport the wallet\\n""
            + HelpExampleCli(""importwallet"", ""\\""test\\"""") +
            ""\\nImport using the json rpc call\\n""
            + HelpExampleRpc(""importwallet"", ""\\""test\\"""")
                },
            }.Check(request);

    EnsureLegacyScriptPubKeyMan(*wallet, true);

    if (pwallet->chain().havePruned()) {
        // Exit early and print an error.
        // If a block is pruned after this check, we will import the key(s),
        // but fail the rescan with a generic error.
        throw JSONRPCError(RPC_WALLET_ERROR, ""Importing wallets is disabled when blocks are pruned"");
    }

    WalletRescanReserver reserver(pwallet);
    if (!reserver.reserve()) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Wallet is currently rescanning. Abort existing rescan or wait."");
    }

    int64_t nTimeBegin = 0;
    bool fGood = true;
    {
        auto locked_chain = pwallet->chain().lock();
        LOCK(pwallet->cs_wallet);

        EnsureWalletIsUnlocked(pwallet);

        fsbridge::ifstream file;
        file.open(request.params[0].get_str(), std::ios::in | std::ios::ate);
        if (!file.is_open()) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Cannot open wallet dump file"");
        }
        Optional<int> tip_height = locked_chain->getHeight();
        nTimeBegin = tip_height ? locked_chain->getBlockTime(*tip_height) : 0;

        int64_t nFilesize = std::max((int64_t)1, (int64_t)file.tellg());
        file.seekg(0, file.beg);

        // Use uiInterface.ShowProgress instead of pwallet.ShowProgress because pwallet.ShowProgress has a cancel button tied to AbortRescan which
        // we don't want for this progress bar showing the import progress. uiInterface.ShowProgress does not have a cancel button.
        pwallet->chain().showProgress(strprintf(""%s "" + _(""Importing..."").translated, pwallet->GetDisplayName()), 0, false); // show progress dialog in GUI
        std::vector<std::tuple<CKey, int64_t, bool, std::string>> keys;
        std::vector<std::pair<CScript, int64_t>> scripts;
        while (file.good()) {
            pwallet->chain().showProgress("""", std::max(1, std::min(50, (int)(((double)file.tellg() / (double)nFilesize) * 100))), false);
            std::string line;
            std::getline(file, line);
            if (line.empty() || line[0] == '#')
                continue;

            std::vector<std::string> vstr;
            boost::split(vstr, line, boost::is_any_of("" ""));
            if (vstr.size() < 2)
                continue;
            CKey key = DecodeSecret(vstr[0]);
            if (key.IsValid()) {
                int64_t nTime = ParseISO8601DateTime(vstr[1]);
                std::string strLabel;
                bool fLabel = true;
                for (unsigned int nStr = 2; nStr < vstr.size(); nStr++) {
                    if (vstr[nStr].front() == '#')
                        break;
                    if (vstr[nStr] == ""change=1"")
                        fLabel = false;
                    if (vstr[nStr] == ""reserve=1"")
                        fLabel = false;
                    if (vstr[nStr].substr(0,6) == ""label="") {
                        strLabel = DecodeDumpString(vstr[nStr].substr(6));
                        fLabel = true;
                    }
                }
                keys.push_back(std::make_tuple(key, nTime, fLabel, strLabel));
            } else if(IsHex(vstr[0])) {
                std::vector<unsigned char> vData(ParseHex(vstr[0]));
                CScript script = CScript(vData.begin(), vData.end());
                int64_t birth_time = ParseISO8601DateTime(vstr[1]);
                scripts.push_back(std::pair<CScript, int64_t>(script, birth_time));
            }
        }
        file.close();
        // We now know whether we are importing private keys, so we can error if private keys are disabled
        if (keys.size() > 0 && pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
            pwallet->chain().showProgress("""", 100, false); // hide progress dialog in GUI
            throw JSONRPCError(RPC_WALLET_ERROR, ""Importing wallets is disabled when private keys are disabled"");
        }
        double total = (double)(keys.size() + scripts.size());
        double progress = 0;
        for (const auto& key_tuple : keys) {
            pwallet->chain().showProgress("""", std::max(50, std::min(75, (int)((progress / total) * 100) + 50)), false);
            const CKey& key = std::get<0>(key_tuple);
            int64_t time = std::get<1>(key_tuple);
            bool has_label = std::get<2>(key_tuple);
            std::string label = std::get<3>(key_tuple);

            CPubKey pubkey = key.GetPubKey();
            CHECK_NONFATAL(key.VerifyPubKey(pubkey));
            CKeyID keyid = pubkey.GetID();

            pwallet->WalletLogPrintf(""Importing %s...\\n"", EncodeDestination(PKHash(keyid)));

            if (!pwallet->ImportPrivKeys({{keyid, key}}, time)) {
                pwallet->WalletLogPrintf(""Error importing key for %s\\n"", EncodeDestination(PKHash(keyid)));
                fGood = false;
                continue;
            }

            if (has_label)
                pwallet->SetAddressBook(PKHash(keyid), label, ""receive"");

            nTimeBegin = std::min(nTimeBegin, time);
            progress++;
        }
        for (const auto& script_pair : scripts) {
            pwallet->chain().showProgress("""", std::max(50, std::min(75, (int)((progress / total) * 100) + 50)), false);
            const CScript& script = script_pair.first;
            int64_t time = script_pair.second;

            if (!pwallet->ImportScripts({script}, time)) {
                pwallet->WalletLogPrintf(""Error importing script %s\\n"", HexStr(script));
                fGood = false;
                continue;
            }
            if (time > 0) {
                nTimeBegin = std::min(nTimeBegin, time);
            }

            progress++;
        }
        pwallet->chain().showProgress("""", 100, false); // hide progress dialog in GUI
    }
    pwallet->chain().showProgress("""", 100, false); // hide progress dialog in GUI
    RescanWallet(*pwallet, reserver, nTimeBegin, false /* update */);
    pwallet->MarkDirty();

    if (!fGood)
        throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding some keys/scripts to wallet"");

    return NullUniValue;
}

UniValue dumpprivkey(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    const CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""dumpprivkey"",
                ""\\nReveals the private key corresponding to 'address'.\\n""
                ""Then the importprivkey can be used with this output\\n"",
                {
                    {""address"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The bitcoin address for the private key""},
                },
                RPCResult{
                    RPCResult::Type::STR, ""key"", ""The private key""
                },
                RPCExamples{
                    HelpExampleCli(""dumpprivkey"", ""\\""myaddress\\"""")
            + HelpExampleCli(""importprivkey"", ""\\""mykey\\"""")
            + HelpExampleRpc(""dumpprivkey"", ""\\""myaddress\\"""")
                },
            }.Check(request);

    LegacyScriptPubKeyMan& spk_man = EnsureLegacyScriptPubKeyMan(*wallet);

    auto locked_chain = pwallet->chain().lock();
    LOCK2(pwallet->cs_wallet, spk_man.cs_KeyStore);

    EnsureWalletIsUnlocked(pwallet);

    std::string strAddress = request.params[0].get_str();
    CTxDestination dest = DecodeDestination(strAddress);
    if (!IsValidDestination(dest)) {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid Bitcoin address"");
    }
    auto keyid = GetKeyForDestination(spk_man, dest);
    if (keyid.IsNull()) {
        throw JSONRPCError(RPC_TYPE_ERROR, ""Address does not refer to a key"");
    }
    CKey vchSecret;
    if (!spk_man.GetKey(keyid, vchSecret)) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Private key for address "" + strAddress + "" is not known"");
    }
    return EncodeSecret(vchSecret);
}


UniValue dumpwallet(const JSONRPCRequest& request)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(request);
    const CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, request.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""dumpwallet"",
                ""\\nDumps all wallet keys in a human-readable format to a server-side file. This does not allow overwriting existing files.\\n""
                ""Imported scripts are included in the dumpfile, but corresponding BIP173 addresses, etc. may not be added automatically by importwallet.\\n""
                ""Note that if your wallet contains keys which are not derived from your HD seed (e.g. imported keys), these are not covered by\\n""
                ""only backing up the seed itself, and must be backed up too (e.g. ensure you back up the whole dumpfile).\\n"",
                {
                    {""filename"", RPCArg::Type::STR, RPCArg::Optional::NO, ""The filename with path (either absolute or relative to bitcoind)""},
                },
                RPCResult{
                    RPCResult::Type::OBJ, """", """",
                    {
                        {RPCResult::Type::STR, ""filename"", ""The filename with full absolute path""},
                    }
                },
                RPCExamples{
                    HelpExampleCli(""dumpwallet"", ""\\""test\\"""")
            + HelpExampleRpc(""dumpwallet"", ""\\""test\\"""")
                },
            }.Check(request);

    LegacyScriptPubKeyMan& spk_man = EnsureLegacyScriptPubKeyMan(*wallet);

    auto locked_chain = pwallet->chain().lock();
    LOCK2(pwallet->cs_wallet, spk_man.cs_KeyStore);

    EnsureWalletIsUnlocked(pwallet);

    fs::path filepath = request.params[0].get_str();
    filepath = fs::absolute(filepath);

    /* Prevent arbitrary files from being overwritten. There have been reports
     * that users have overwritten wallet files this way:
     * https://github.com/bitcoin/bitcoin/issues/9934
     * It may also avoid other security issues.
     */
    if (fs::exists(filepath)) {
        throw JSONRPCError(RPC_INVALID_PARAMETER, filepath.string() + "" already exists. If you are sure this is what you want, move it out of the way first"");
    }

    fsbridge::ofstream file;
    file.open(filepath);
    if (!file.is_open())
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""Cannot open wallet dump file"");

    std::map<CKeyID, int64_t> mapKeyBirth;
    const std::map<CKeyID, int64_t>& mapKeyPool = spk_man.GetAllReserveKeys();
    pwallet->GetKeyBirthTimes(*locked_chain, mapKeyBirth);

    std::set<CScriptID> scripts = spk_man.GetCScripts();

    // sort time/key pairs
    std::vector<std::pair<int64_t, CKeyID> > vKeyBirth;
    for (const auto& entry : mapKeyBirth) {
        vKeyBirth.push_back(std::make_pair(entry.second, entry.first));
    }
    mapKeyBirth.clear();
    std::sort(vKeyBirth.begin(), vKeyBirth.end());

    // produce output
    file << strprintf(""# Wallet dump created by Bitcoin %s\\n"", CLIENT_BUILD);
    file << strprintf(""# * Created on %s\\n"", FormatISO8601DateTime(GetTime()));
    const Optional<int> tip_height = locked_chain->getHeight();
    file << strprintf(""# * Best block at time of backup was %i (%s),\\n"", tip_height.get_value_or(-1), tip_height ? locked_chain->getBlockHash(*tip_height).ToString() : ""(missing block hash)"");
    file << strprintf(""#   mined on %s\\n"", tip_height ? FormatISO8601DateTime(locked_chain->getBlockTime(*tip_height)) : ""(missing block time)"");
    file << ""\\n"";

    // add the base58check encoded extended master if the wallet uses HD
    CKeyID seed_id = spk_man.GetHDChain().seed_id;
    if (!seed_id.IsNull())
    {
        CKey seed;
        if (spk_man.GetKey(seed_id, seed)) {
            CExtKey masterKey;
            masterKey.SetSeed(seed.begin(), seed.size());

            file << ""# extended private masterkey: "" << EncodeExtKey(masterKey) << ""\\n\\n"";
        }
    }
    for (std::vector<std::pair<int64_t, CKeyID> >::const_iterator it = vKeyBirth.begin(); it != vKeyBirth.end(); it++) {
        const CKeyID &keyid = it->second;
        std::string strTime = FormatISO8601DateTime(it->first);
        std::string strAddr;
        std::string strLabel;
        CKey key;
        if (spk_man.GetKey(keyid, key)) {
            file << strprintf(""%s %s "", EncodeSecret(key), strTime);
            if (GetWalletAddressesForKey(&spk_man, pwallet, keyid, strAddr, strLabel)) {
               file << strprintf(""label=%s"", strLabel);
            } else if (keyid == seed_id) {
                file << ""hdseed=1"";
            } else if (mapKeyPool.count(keyid)) {
                file << ""reserve=1"";
            } else if (spk_man.mapKeyMetadata[keyid].hdKeypath == ""s"") {
                file << ""inactivehdseed=1"";
            } else {
                file << ""change=1"";
            }
            file << strprintf("" # addr=%s%s\\n"", strAddr, (spk_man.mapKeyMetadata[keyid].has_key_origin ? "" hdkeypath=""+WriteHDKeypath(spk_man.mapKeyMetadata[keyid].key_origin.path) : """"));
        }
    }
    file << ""\\n"";
    for (const CScriptID &scriptid : scripts) {
        CScript script;
        std::string create_time = ""0"";
        std::string address = EncodeDestination(ScriptHash(scriptid));
        // get birth times for scripts with metadata
        auto it = spk_man.m_script_metadata.find(scriptid);
        if (it != spk_man.m_script_metadata.end()) {
            create_time = FormatISO8601DateTime(it->second.nCreateTime);
        }
        if(spk_man.GetCScript(scriptid, script)) {
            file << strprintf(""%s %s script=1"", HexStr(script.begin(), script.end()), create_time);
            file << strprintf("" # addr=%s\\n"", address);
        }
    }
    file << ""\\n"";
    file << ""# End of dump\\n"";
    file.close();

    UniValue reply(UniValue::VOBJ);
    reply.pushKV(""filename"", filepath.string());

    return reply;
}

struct ImportData
{
    // Input data
    std::unique_ptr<CScript> redeemscript; //!< Provided redeemScript; will be moved to `import_scripts` if relevant.
    std::unique_ptr<CScript> witnessscript; //!< Provided witnessScript; will be moved to `import_scripts` if relevant.

    // Output data
    std::set<CScript> import_scripts;
    std::map<CKeyID, bool> used_keys; //!< Import these private keys if available (the value indicates whether if the key is required for solvability)
    std::map<CKeyID, std::pair<CPubKey, KeyOriginInfo>> key_origins;
};

enum class ScriptContext
{
    TOP, //!< Top-level scriptPubKey
    P2SH, //!< P2SH redeemScript
    WITNESS_V0, //!< P2WSH witnessScript
};

// Analyse the provided scriptPubKey, determining which keys and which redeem scripts from the ImportData struct are needed to spend it, and mark them as used.
// Returns an error string, or the empty string for success.
static std::string RecurseImportData(const CScript& script, ImportData& import_data, const ScriptContext script_ctx)
{
    // Use Solver to obtain script type and parsed pubkeys or hashes:
    std::vector<std::vector<unsigned char>> solverdata;
    txnouttype script_type = Solver(script, solverdata);

    switch (script_type) {
    case TX_PUBKEY: {
        CPubKey pubkey(solverdata[0].begin(), solverdata[0].end());
        import_data.used_keys.emplace(pubkey.GetID(), false);
        return """";
    }
    case TX_PUBKEYHASH: {
        CKeyID id = CKeyID(uint160(solverdata[0]));
        import_data.used_keys[id] = true;
        return """";
    }
    case TX_SCRIPTHASH: {
        if (script_ctx == ScriptContext::P2SH) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Trying to nest P2SH inside another P2SH"");
        if (script_ctx == ScriptContext::WITNESS_V0) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Trying to nest P2SH inside a P2WSH"");
        CHECK_NONFATAL(script_ctx == ScriptContext::TOP);
        CScriptID id = CScriptID(uint160(solverdata[0]));
        auto subscript = std::move(import_data.redeemscript); // Remove redeemscript from import_data to check for superfluous script later.
        if (!subscript) return ""missing redeemscript"";
        if (CScriptID(*subscript) != id) return ""redeemScript does not match the scriptPubKey"";
        import_data.import_scripts.emplace(*subscript);
        return RecurseImportData(*subscript, import_data, ScriptContext::P2SH);
    }
    case TX_MULTISIG: {
        for (size_t i = 1; i + 1< solverdata.size(); ++i) {
            CPubKey pubkey(solverdata[i].begin(), solverdata[i].end());
            import_data.used_keys.emplace(pubkey.GetID(), false);
        }
        return """";
    }
    case TX_WITNESS_V0_SCRIPTHASH: {
        if (script_ctx == ScriptContext::WITNESS_V0) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Trying to nest P2WSH inside another P2WSH"");
        uint256 fullid(solverdata[0]);
        CScriptID id;
        CRIPEMD160().Write(fullid.begin(), fullid.size()).Finalize(id.begin());
        auto subscript = std::move(import_data.witnessscript); // Remove redeemscript from import_data to check for superfluous script later.
        if (!subscript) return ""missing witnessscript"";
        if (CScriptID(*subscript) != id) return ""witnessScript does not match the scriptPubKey or redeemScript"";
        if (script_ctx == ScriptContext::TOP) {
            import_data.import_scripts.emplace(script); // Special rule for IsMine: native P2WSH requires the TOP script imported (see script/ismine.cpp)
        }
        import_data.import_scripts.emplace(*subscript);
        return RecurseImportData(*subscript, import_data, ScriptContext::WITNESS_V0);
    }
    case TX_WITNESS_V0_KEYHASH: {
        if (script_ctx == ScriptContext::WITNESS_V0) throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Trying to nest P2WPKH inside P2WSH"");
        CKeyID id = CKeyID(uint160(solverdata[0]));
        import_data.used_keys[id] = true;
        if (script_ctx == ScriptContext::TOP) {
            import_data.import_scripts.emplace(script); // Special rule for IsMine: native P2WPKH requires the TOP script imported (see script/ismine.cpp)
        }
        return """";
    }
    case TX_NULL_DATA:
        return ""unspendable script"";
    case TX_NONSTANDARD:
    case TX_WITNESS_UNKNOWN:
    default:
        return ""unrecognized script"";
    }
}

static UniValue ProcessImportLegacy(ImportData& import_data, std::map<CKeyID, CPubKey>& pubkey_map, std::map<CKeyID, CKey>& privkey_map, std::set<CScript>& script_pub_keys, bool& have_solving_data, const UniValue& data, std::vector<CKeyID>& ordered_pubkeys)
{
    UniValue warnings(UniValue::VARR);

    // First ensure scriptPubKey has either a script or JSON with ""address"" string
    const UniValue& scriptPubKey = data[""scriptPubKey""];
    bool isScript = scriptPubKey.getType() == UniValue::VSTR;
    if (!isScript && !(scriptPubKey.getType() == UniValue::VOBJ && scriptPubKey.exists(""address""))) {
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""scriptPubKey must be string with script or JSON with address string"");
    }
    const std::string& output = isScript ? scriptPubKey.get_str() : scriptPubKey[""address""].get_str();

    // Optional fields.
    const std::string& strRedeemScript = data.exists(""redeemscript"") ? data[""redeemscript""].get_str() : """";
    const std::string& witness_script_hex = data.exists(""witnessscript"") ? data[""witnessscript""].get_str() : """";
    const UniValue& pubKeys = data.exists(""pubkeys"") ? data[""pubkeys""].get_array() : UniValue();
    const UniValue& keys = data.exists(""keys"") ? data[""keys""].get_array() : UniValue();
    const bool internal = data.exists(""internal"") ? data[""internal""].get_bool() : false;
    const bool watchOnly = data.exists(""watchonly"") ? data[""watchonly""].get_bool() : false;

    if (data.exists(""range"")) {
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""Range should not be specified for a non-descriptor import"");
    }

    // Generate the script and destination for the scriptPubKey provided
    CScript script;
    if (!isScript) {
        CTxDestination dest = DecodeDestination(output);
        if (!IsValidDestination(dest)) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid address \\"""" + output + ""\\"""");
        }
        script = GetScriptForDestination(dest);
    } else {
        if (!IsHex(output)) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid scriptPubKey \\"""" + output + ""\\"""");
        }
        std::vector<unsigned char> vData(ParseHex(output));
        script = CScript(vData.begin(), vData.end());
        CTxDestination dest;
        if (!ExtractDestination(script, dest) && !internal) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Internal must be set to true for nonstandard scriptPubKey imports."");
        }
    }
    script_pub_keys.emplace(script);

    // Parse all arguments
    if (strRedeemScript.size()) {
        if (!IsHex(strRedeemScript)) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid redeem script \\"""" + strRedeemScript + ""\\"": must be hex string"");
        }
        auto parsed_redeemscript = ParseHex(strRedeemScript);
        import_data.redeemscript = MakeUnique<CScript>(parsed_redeemscript.begin(), parsed_redeemscript.end());
    }
    if (witness_script_hex.size()) {
        if (!IsHex(witness_script_hex)) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid witness script \\"""" + witness_script_hex + ""\\"": must be hex string"");
        }
        auto parsed_witnessscript = ParseHex(witness_script_hex);
        import_data.witnessscript = MakeUnique<CScript>(parsed_witnessscript.begin(), parsed_witnessscript.end());
    }
    for (size_t i = 0; i < pubKeys.size(); ++i) {
        const auto& str = pubKeys[i].get_str();
        if (!IsHex(str)) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Pubkey \\"""" + str + ""\\"" must be a hex string"");
        }
        auto parsed_pubkey = ParseHex(str);
        CPubKey pubkey(parsed_pubkey.begin(), parsed_pubkey.end());
        if (!pubkey.IsFullyValid()) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Pubkey \\"""" + str + ""\\"" is not a valid public key"");
        }
        pubkey_map.emplace(pubkey.GetID(), pubkey);
        ordered_pubkeys.push_back(pubkey.GetID());
    }
    for (size_t i = 0; i < keys.size(); ++i) {
        const auto& str = keys[i].get_str();
        CKey key = DecodeSecret(str);
        if (!key.IsValid()) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid private key encoding"");
        }
        CPubKey pubkey = key.GetPubKey();
        CKeyID id = pubkey.GetID();
        if (pubkey_map.count(id)) {
            pubkey_map.erase(id);
        }
        privkey_map.emplace(id, key);
    }


    // Verify and process input data
    have_solving_data = import_data.redeemscript || import_data.witnessscript || pubkey_map.size() || privkey_map.size();
    if (have_solving_data) {
        // Match up data in import_data with the scriptPubKey in script.
        auto error = RecurseImportData(script, import_data, ScriptContext::TOP);

        // Verify whether the watchonly option corresponds to the availability of private keys.
        bool spendable = std::all_of(import_data.used_keys.begin(), import_data.used_keys.end(), [&](const std::pair<CKeyID, bool>& used_key){ return privkey_map.count(used_key.first) > 0; });
        if (!watchOnly && !spendable) {
            warnings.push_back(""Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."");
        }
        if (watchOnly && spendable) {
            warnings.push_back(""All private keys are provided, outputs will be considered spendable. If this is intentional, do not specify the watchonly flag."");
        }

        // Check that all required keys for solvability are provided.
        if (error.empty()) {
            for (const auto& require_key : import_data.used_keys) {
                if (!require_key.second) continue; // Not a required key
                if (pubkey_map.count(require_key.first) == 0 && privkey_map.count(require_key.first) == 0) {
                    error = ""some required keys are missing"";
                }
            }
        }

        if (!error.empty()) {
            warnings.push_back(""Importing as non-solvable: "" + error + "". If this is intentional, don't provide any keys, pubkeys, witnessscript, or redeemscript."");
            import_data = ImportData();
            pubkey_map.clear();
            privkey_map.clear();
            have_solving_data = false;
        } else {
            // RecurseImportData() removes any relevant redeemscript/witnessscript from import_data, so we can use that to discover if a superfluous one was provided.
            if (import_data.redeemscript) warnings.push_back(""Ignoring redeemscript as this is not a P2SH script."");
            if (import_data.witnessscript) warnings.push_back(""Ignoring witnessscript as this is not a (P2SH-)P2WSH script."");
            for (auto it = privkey_map.begin(); it != privkey_map.end(); ) {
                auto oldit = it++;
                if (import_data.used_keys.count(oldit->first) == 0) {
                    warnings.push_back(""Ignoring irrelevant private key."");
                    privkey_map.erase(oldit);
                }
            }
            for (auto it = pubkey_map.begin(); it != pubkey_map.end(); ) {
                auto oldit = it++;
                auto key_data_it = import_data.used_keys.find(oldit->first);
                if (key_data_it == import_data.used_keys.end() || !key_data_it->second) {
                    warnings.push_back(""Ignoring public key \\"""" + HexStr(oldit->first) + ""\\"" as it doesn't appear inside P2PKH or P2WPKH."");
                    pubkey_map.erase(oldit);
                }
            }
        }
    }

    return warnings;
}

static UniValue ProcessImportDescriptor(ImportData& import_data, std::map<CKeyID, CPubKey>& pubkey_map, std::map<CKeyID, CKey>& privkey_map, std::set<CScript>& script_pub_keys, bool& have_solving_data, const UniValue& data, std::vector<CKeyID>& ordered_pubkeys)
{
    UniValue warnings(UniValue::VARR);

    const std::string& descriptor = data[""desc""].get_str();
    FlatSigningProvider keys;
    std::string error;
    auto parsed_desc = Parse(descriptor, keys, error, /* require_checksum = */ true);
    if (!parsed_desc) {
        throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, error);
    }

    have_solving_data = parsed_desc->IsSolvable();
    const bool watch_only = data.exists(""watchonly"") ? data[""watchonly""].get_bool() : false;

    int64_t range_start = 0, range_end = 0;
    if (!parsed_desc->IsRange() && data.exists(""range"")) {
        throw JSONRPCError(RPC_INVALID_PARAMETER, ""Range should not be specified for an un-ranged descriptor"");
    } else if (parsed_desc->IsRange()) {
        if (!data.exists(""range"")) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Descriptor is ranged, please specify the range"");
        }
        std::tie(range_start, range_end) = ParseDescriptorRange(data[""range""]);
    }

    const UniValue& priv_keys = data.exists(""keys"") ? data[""keys""].get_array() : UniValue();

    // Expand all descriptors to get public keys and scripts, and private keys if available.
    for (int i = range_start; i <= range_end; ++i) {
        FlatSigningProvider out_keys;
        std::vector<CScript> scripts_temp;
        parsed_desc->Expand(i, keys, scripts_temp, out_keys);
        std::copy(scripts_temp.begin(), scripts_temp.end(), std::inserter(script_pub_keys, script_pub_keys.end()));
        for (const auto& key_pair : out_keys.pubkeys) {
            ordered_pubkeys.push_back(key_pair.first);
        }

        for (const auto& x : out_keys.scripts) {
            import_data.import_scripts.emplace(x.second);
        }

        parsed_desc->ExpandPrivate(i, keys, out_keys);

        std::copy(out_keys.pubkeys.begin(), out_keys.pubkeys.end(), std::inserter(pubkey_map, pubkey_map.end()));
        std::copy(out_keys.keys.begin(), out_keys.keys.end(), std::inserter(privkey_map, privkey_map.end()));
        import_data.key_origins.insert(out_keys.origins.begin(), out_keys.origins.end());
    }

    for (size_t i = 0; i < priv_keys.size(); ++i) {
        const auto& str = priv_keys[i].get_str();
        CKey key = DecodeSecret(str);
        if (!key.IsValid()) {
            throw JSONRPCError(RPC_INVALID_ADDRESS_OR_KEY, ""Invalid private key encoding"");
        }
        CPubKey pubkey = key.GetPubKey();
        CKeyID id = pubkey.GetID();

        // Check if this private key corresponds to a public key from the descriptor
        if (!pubkey_map.count(id)) {
            warnings.push_back(""Ignoring irrelevant private key."");
        } else {
            privkey_map.emplace(id, key);
        }
    }

    // Check if all the public keys have corresponding private keys in the import for spendability.
    // This does not take into account threshold multisigs which could be spendable without all keys.
    // Thus, threshold multisigs without all keys will be considered not spendable here, even if they are,
    // perhaps triggering a false warning message. This is consistent with the current wallet IsMine check.
    bool spendable = std::all_of(pubkey_map.begin(), pubkey_map.end(),
        [&](const std::pair<CKeyID, CPubKey>& used_key) {
            return privkey_map.count(used_key.first) > 0;
        }) && std::all_of(import_data.key_origins.begin(), import_data.key_origins.end(),
        [&](const std::pair<CKeyID, std::pair<CPubKey, KeyOriginInfo>>& entry) {
            return privkey_map.count(entry.first) > 0;
        });
    if (!watch_only && !spendable) {
        warnings.push_back(""Some private keys are missing, outputs will be considered watchonly. If this is intentional, specify the watchonly flag."");
    }
    if (watch_only && spendable) {
        warnings.push_back(""All private keys are provided, outputs will be considered spendable. If this is intentional, do not specify the watchonly flag."");
    }

    return warnings;
}

static UniValue ProcessImport(CWallet * const pwallet, const UniValue& data, const int64_t timestamp) EXCLUSIVE_LOCKS_REQUIRED(pwallet->cs_wallet)
{
    UniValue warnings(UniValue::VARR);
    UniValue result(UniValue::VOBJ);

    try {
        const bool internal = data.exists(""internal"") ? data[""internal""].get_bool() : false;
        // Internal addresses should not have a label
        if (internal && data.exists(""label"")) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Internal addresses should not have a label"");
        }
        const std::string& label = data.exists(""label"") ? data[""label""].get_str() : """";
        const bool add_keypool = data.exists(""keypool"") ? data[""keypool""].get_bool() : false;

        // Add to keypool only works with privkeys disabled
        if (add_keypool && !pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS)) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Keys can only be imported to the keypool when private keys are disabled"");
        }

        ImportData import_data;
        std::map<CKeyID, CPubKey> pubkey_map;
        std::map<CKeyID, CKey> privkey_map;
        std::set<CScript> script_pub_keys;
        std::vector<CKeyID> ordered_pubkeys;
        bool have_solving_data;

        if (data.exists(""scriptPubKey"") && data.exists(""desc"")) {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Both a descriptor and a scriptPubKey should not be provided."");
        } else if (data.exists(""scriptPubKey"")) {
            warnings = ProcessImportLegacy(import_data, pubkey_map, privkey_map, script_pub_keys, have_solving_data, data, ordered_pubkeys);
        } else if (data.exists(""desc"")) {
            warnings = ProcessImportDescriptor(import_data, pubkey_map, privkey_map, script_pub_keys, have_solving_data, data, ordered_pubkeys);
        } else {
            throw JSONRPCError(RPC_INVALID_PARAMETER, ""Either a descriptor or scriptPubKey must be provided."");
        }

        // If private keys are disabled, abort if private keys are being imported
        if (pwallet->IsWalletFlagSet(WALLET_FLAG_DISABLE_PRIVATE_KEYS) && !privkey_map.empty()) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Cannot import private keys to a wallet with private keys disabled"");
        }

        // Check whether we have any work to do
        for (const CScript& script : script_pub_keys) {
            if (pwallet->IsMine(script) & ISMINE_SPENDABLE) {
                throw JSONRPCError(RPC_WALLET_ERROR, ""The wallet already contains the private key for this address or script (\\"""" + HexStr(script.begin(), script.end()) + ""\\"")"");
            }
        }

        // All good, time to import
        pwallet->MarkDirty();
        if (!pwallet->ImportScripts(import_data.import_scripts, timestamp)) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding script to wallet"");
        }
        if (!pwallet->ImportPrivKeys(privkey_map, timestamp)) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding key to wallet"");
        }
        if (!pwallet->ImportPubKeys(ordered_pubkeys, pubkey_map, import_data.key_origins, add_keypool, internal, timestamp)) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding address to wallet"");
        }
        if (!pwallet->ImportScriptPubKeys(label, script_pub_keys, have_solving_data, !internal, timestamp)) {
            throw JSONRPCError(RPC_WALLET_ERROR, ""Error adding address to wallet"");
        }

        result.pushKV(""success"", UniValue(true));
    } catch (const UniValue& e) {
        result.pushKV(""success"", UniValue(false));
        result.pushKV(""error"", e);
    } catch (...) {
        result.pushKV(""success"", UniValue(false));

        result.pushKV(""error"", JSONRPCError(RPC_MISC_ERROR, ""Missing required fields""));
    }
    if (warnings.size()) result.pushKV(""warnings"", warnings);
    return result;
}

static int64_t GetImportTimestamp(const UniValue& data, int64_t now)
{
    if (data.exists(""timestamp"")) {
        const UniValue& timestamp = data[""timestamp""];
        if (timestamp.isNum()) {
            return timestamp.get_int64();
        } else if (timestamp.isStr() && timestamp.get_str() == ""now"") {
            return now;
        }
        throw JSONRPCError(RPC_TYPE_ERROR, strprintf(""Expected number or \\""now\\"" timestamp value for key. got type %s"", uvTypeName(timestamp.type())));
    }
    throw JSONRPCError(RPC_TYPE_ERROR, ""Missing required timestamp field for key"");
}

UniValue importmulti(const JSONRPCRequest& mainRequest)
{
    std::shared_ptr<CWallet> const wallet = GetWalletForJSONRPCRequest(mainRequest);
    CWallet* const pwallet = wallet.get();
    if (!EnsureWalletIsAvailable(pwallet, mainRequest.fHelp)) {
        return NullUniValue;
    }

            RPCHelpMan{""importmulti"",
                ""\\nImport addresses/scripts (with private or public keys, redeem script (P2SH)), optionally rescanning the blockchain from the earliest creation time of the imported scripts. Requires a new wallet backup.\\n""
                ""If an address/script is imported without all of the private keys required to spend from that address, it will be watchonly. The 'watchonly' option must be set to true in this case or a warning will be returned.\\n""
                ""Conversely, if all the private keys are provided and the address/script is spendable, the watchonly option must be set to false, or a warning will be returned.\\n""
            ""\\nNote: This call can take over an hour to complete if rescan is true, during that time, other rpc calls\\n""
            ""may report that the imported keys, addresses or scripts exist but related transactions are still missing.\\n""
            ""Note: Use \\""getwalletinfo\\"" to query the scanning progress.\\n"",
                {
                    {""requests"", RPCArg::Type::ARR, RPCArg::Optional::NO, ""Data to be imported"",
                        {
                            {"""", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED, """",
                                {
                                    {""desc"", RPCArg::Type::STR, RPCArg::Optional::OMITTED, ""Descriptor to import. If using descriptor, do not also provide address/scriptPubKey, scripts, or pubkeys""},
                                    {""scriptPubKey"", RPCArg::Type::STR, RPCArg::Optional::NO, ""Type of scriptPubKey (string for script, json for address). Should not be provided if using a descriptor"",
                                        /* oneline_description */ """", {""\\""<script>\\"" | { \\""address\\"":\\""<address>\\"" }"", ""string / json""}
                                    },
                                    {""timestamp"", RPCArg::Type::NUM, RPCArg::Optional::NO, ""Creation time of the key expressed in "" + UNIX_EPOCH_TIME + "",\\n""
        ""                                                              or the string \\""now\\"" to substitute the current synced blockchain time. The timestamp of the oldest\\n""
        ""                                                              key will determine how far back blockchain rescans need to begin for missing wallet transactions.\\n""
        ""                                                              \\""now\\"" can be specified to bypass scanning, for keys which are known to never have been used, and\\n""
        ""                                                              0 can be specified to scan the entire blockchain. Blocks up to 2 hours before the earliest key\\n""
        ""                                                              creation time of all keys being imported by the importmulti call will be scanned."",
                                        /* oneline_description */ """", {""timestamp | \\""now\\"""", ""integer / string""}
                                    },
                                    {""redeemscript"", RPCArg::Type::STR, RPCArg::Optional::OMITTED, ""Allowed only if the scriptPubKey is a P2SH or P2SH-P2WSH address/scriptPubKey""},
                                    {""witnessscript"", RPCArg::Type::STR, RPCArg::Optional::OMITTED, ""Allowed only if the scriptPubKey is a P2SH-P2WSH or P2WSH address/scriptPubKey""},
                                    {""pubkeys"", RPCArg::Type::ARR, /* default */ ""empty array"", ""Array of strings giving pubkeys to import. They must occur in P2PKH or P2WPKH scripts. They are not required when the private key is also provided (see the \\""keys\\"" argument)."",
                                        {
                                            {""pubKey"", RPCArg::Type::STR, RPCArg::Optional::OMITTED, """"},
                                        }
                                    },
                                    {""keys"", RPCArg::Type::ARR, /* default */ ""empty array"", ""Array of strings giving private keys to import. The corresponding public keys must occur in the output or redeemscript."",
                                        {
                                            {""key"", RPCArg::Type::STR, RPCArg::Optional::OMITTED, """"},
                                        }
                                    },
                                    {""range"", RPCArg::Type::RANGE, RPCArg::Optional::OMITTED, ""If a ranged descriptor is used, this specifies the end or the range (in the form [begin,end]) to import""},
                                    {""internal"", RPCArg::Type::BOOL, /* default */ ""false"", ""Stating whether matching outputs should be treated as not incoming payments (also known as change)""},
                                    {""watchonly"", RPCArg::Type::BOOL, /* default */ ""false"", ""Stating whether matching outputs should be considered watchonly.""},
                                    {""label"", RPCArg::Type::STR, /* default */ ""''"", ""Label to assign to the address, only allowed with internal=false""},
                                    {""keypool"", RPCArg::Type::BOOL, /* default */ ""false"", ""Stating whether imported public keys should be added to the keypool for when users request new addresses. Only allowed when wallet private keys are disabled""},
                                },
                            },
                        },
                        ""\\""requests\\""""},
                    {""options"", RPCArg::Type::OBJ, RPCArg::Optional::OMITTED_NAMED_ARG, """",
                        {
                            {""rescan"", RPCArg::Type::BOOL, /* default */ ""true"", ""Stating if should rescan the blockchain after all imports""},
                        },
                        ""\\""options\\""""},
                },
                RPCResult{
                    RPCResult::Type::ARR, """", ""Response is an array with the same size as the input that has the execution result"",
                    {
                        {RPCResult::Type::OBJ, """", """",
                        {
                            {RPCResult::Type::BOOL, ""success"", """"},
                            {RPCResult::Type::ARR, ""warnings"", /* optional */ true, """",
                            {
                                {RPCResult::Type::STR, """", """"},
                            }},
                            {RPCResult::Type::OBJ, ""error"", /* optional */ true, """",
                            {
                                {RPCResult::Type::ELISION, """", ""JSONRPC error""},
                            }},
                        }},
                    }
                },
                RPCExamples{
                    HelpExampleCli(""importmulti"", ""'[{ \\""scriptPubKey\\"": { \\""address\\"": \\""<my address>\\"" }, \\""timestamp\\"":1455191478 }, ""
                                          ""{ \\""scriptPubKey\\"": { \\""address\\"": \\""<my 2nd address>\\"" }, \\""label\\"": \\""example 2\\"", \\""timestamp\\"": 1455191480 }]'"") +
                    HelpExampleCli(""importmulti"", ""'[{ \\""scriptPubKey\\"": { \\""address\\"": \\""<my address>\\"" }, \\""timestamp\\"":1455191478 }]' '{ \\""rescan\\"": false}'"")
                },
            }.Check(mainRequest);


    RPCTypeCheck(mainRequest.params, {UniValue::VARR, UniValue::VOBJ});

    EnsureLegacyScriptPubKeyMan(*wallet, true);

    const UniValue& requests = mainRequest.params[0];

    //Default options
    bool fRescan = true;

    if (!mainRequest.params[1].isNull()) {
        const UniValue& options = mainRequest.params[1];

        if (options.exists(""rescan"")) {
            fRescan = options[""rescan""].get_bool();
        }
    }

    WalletRescanReserver reserver(pwallet);
    if (fRescan && !reserver.reserve()) {
        throw JSONRPCError(RPC_WALLET_ERROR, ""Wallet is currently rescanning. Abort existing rescan or wait."");
    }

    int64_t now = 0;
    bool fRunScan = false;
    int64_t nLowestTimestamp = 0;
    UniValue response(UniValue::VARR);
    {
        auto locked_chain = pwallet->chain().lock();
        LOCK(pwallet->cs_wallet);
        EnsureWalletIsUnlocked(pwallet);

        // Verify all timestamps are present before importing any keys.
        const Optional<int> tip_height = locked_chain->getHeight();
        now = tip_height ? locked_chain->getBlockMedianTimePast(*tip_height) : 0;
        for (const UniValue& data : requests.getValues()) {
            GetImportTimestamp(data, now);
        }

        const int64_t minimumTimestamp = 1;

        if (fRescan && tip_height) {
            nLowestTimestamp = locked_chain->getBlockTime(*tip_height);
        } else {
            fRescan = false;
        }

        for (const UniValue& data : requests.getValues()) {
            const int64_t timestamp = std::max(GetImportTimestamp(data, now), minimumTimestamp);
            const UniValue result = ProcessImport(pwallet, data, timestamp);
            response.push_back(result);

            if (!fRescan) {
                continue;
            }

            // If at least one request was successful then allow rescan.
            if (result[""success""].get_bool()) {
                fRunScan = true;
            }

            // Get the lowest timestamp.
            if (timestamp < nLowestTimestamp) {
                nLowestTimestamp = timestamp;
            }
        }
    }
    if (fRescan && fRunScan && requests.size()) {
        int64_t scannedTime = pwallet->RescanFromTime(nLowestTimestamp, reserver, true /* update */);
        {
            auto locked_chain = pwallet->chain().lock();
            LOCK(pwallet->cs_wallet);
            pwallet->ReacceptWalletTransactions();
        }

        if (pwallet->IsAbortingRescan()) {
            throw JSONRPCError(RPC_MISC_ERROR, ""Rescan aborted by user."");
        }
        if (scannedTime > nLowestTimestamp) {
            std::vector<UniValue> results = response.getValues();
            response.clear();
            response.setArray();
            size_t i = 0;
            for (const UniValue& request : requests.getValues()) {
                // If key creation date is within the successfully scanned
                // range, or if the import result already has an error set, let
                // the result stand unmodified. Otherwise replace the result
                // with an error message.
                if (scannedTime <= GetImportTimestamp(request, now) || results.at(i).exists(""error"")) {
                    response.push_back(results.at(i));
                } else {
                    UniValue result = UniValue(UniValue::VOBJ);
                    result.pushKV(""success"", UniValue(false));
                    result.pushKV(
                        ""error"",
                        JSONRPCError(
                            RPC_MISC_ERROR,
                            strprintf(""Rescan failed for key with creation timestamp %d. There was an error reading a ""
                                      ""block from time %d, which is after or within %d seconds of key creation, and ""
                                      ""could contain transactions pertaining to the key. As a result, transactions ""
                                      ""and coins using this key may not appear in the wallet. This error could be ""
                                      ""caused by pruning or data corruption (see bitcoind log for details) and could ""
                                      ""be dealt with by downloading and rescanning the relevant blocks (see -reindex ""
                                      ""and -rescan options)."",
                                GetImportTimestamp(request, now), scannedTime - TIMESTAMP_WINDOW - 1, TIMESTAMP_WINDOW)));
                    response.push_back(std::move(result));
                }
                ++i;
            }
        }
    }

    return response;
}
",16265,True,3156.210923976267,median
"/************************************************************************************

Filename    :   Util_Render_Stereo.cpp
Content     :   Stereo rendering configuration implementation
Created     :   October 22, 2012
Authors     :   Michael Antonov, Andrew Reisse, Tom Forsyth

Copyright   :   Copyright 2014 Oculus VR, Inc. All Rights reserved.

Licensed under the Oculus VR Rift SDK License Version 3.1 (the ""License""); 
you may not use the Oculus VR Rift SDK except in compliance with the License, 
which is provided at the time of installation or download, or which 
otherwise accompanies this software in either electronic or hard copy form.

You may obtain a copy of the License at

http://www.oculusvr.com/licenses/LICENSE-3.1 

Unless required by applicable law or agreed to in writing, the Oculus VR SDK 
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 ""Util_Render_Stereo.h""
#include ""../OVR_SensorFusion.h""

namespace OVR { namespace Util { namespace Render {


//-----------------------------------------------------------------------------------
// **** Useful debug functions.

char const* GetDebugNameEyeCupType ( EyeCupType eyeCupType )
{
    switch ( eyeCupType )
    {
    case EyeCup_DK1A:           return ""DK1 A"";             break;
    case EyeCup_DK1B:           return ""DK1 B"";             break;
    case EyeCup_DK1C:           return ""DK1 C"";             break;
    case EyeCup_DKHD2A:         return ""DKHD2 A"";           break;
    case EyeCup_OrangeA:        return ""Orange A"";          break;
    case EyeCup_RedA:           return ""Red A"";             break;
    case EyeCup_PinkA:          return ""Pink A"";            break;
    case EyeCup_BlueA:          return ""Blue A"";            break;
    case EyeCup_Delilah1A:      return ""Delilah 1 A"";       break;
    case EyeCup_Delilah2A:      return ""Delilah 2 A"";       break;
    case EyeCup_JamesA:         return ""James A"";           break;
    case EyeCup_SunMandalaA:    return ""Sun Mandala A"";     break;
    case EyeCup_DK2A:           return ""DK2 A"";             break;
    case EyeCup_LAST:           return ""LAST"";              break;
    default: OVR_ASSERT ( false ); return ""Error""; break;
    }
}

char const* GetDebugNameHmdType ( HmdTypeEnum hmdType )
{
    switch ( hmdType )
    {
    case HmdType_None:              return ""None"";                   break;
    case HmdType_DK1:               return ""DK1"";                    break;
    case HmdType_DKProto:           return ""DK1 prototype"";          break;
    case HmdType_DKHDProto:         return ""DK HD prototype 1"";      break;
    case HmdType_DKHDProto566Mi:    return ""DK HD prototype 566 Mi""; break;
    case HmdType_DKHD2Proto:        return ""DK HD prototype 585"";    break;
    case HmdType_CrystalCoveProto:  return ""Crystal Cove"";           break;
    case HmdType_DK2:               return ""DK2"";                    break;
    case HmdType_Unknown:           return ""Unknown"";                break;
    case HmdType_LAST:              return ""LAST"";                   break;
    default: OVR_ASSERT ( false ); return ""Error""; break;
    }
}


//-----------------------------------------------------------------------------------
// **** Internal pipeline functions.

struct DistortionAndFov
{
    DistortionRenderDesc    Distortion;
    FovPort                 Fov; 
};

static DistortionAndFov CalculateDistortionAndFovInternal ( StereoEye eyeType, HmdRenderInfo const &hmd,
                                                            LensConfig const *pLensOverride = NULL,
                                                            FovPort const *pTanHalfFovOverride = NULL,
                                                            float extraEyeRotationInRadians = OVR_DEFAULT_EXTRA_EYE_ROTATION )
{
    // pLensOverride can be NULL, which means no override.

    DistortionRenderDesc localDistortion  = CalculateDistortionRenderDesc ( eyeType, hmd, pLensOverride );
    FovPort              fov              = CalculateFovFromHmdInfo ( eyeType, localDistortion, hmd, extraEyeRotationInRadians );
    // Here the app or the user would optionally clamp this visible fov to a smaller number if
    // they want more perf or resolution and are willing to give up FOV.
    // They may also choose to clamp UDLR differently e.g. to get cinemascope-style views.
    if ( pTanHalfFovOverride != NULL )
    {
        fov = *pTanHalfFovOverride;
    }

    // Here we could call ClampToPhysicalScreenFov(), but we do want people
    // to be able to play with larger-than-screen views.
    // The calling app can always do the clamping itself.
    DistortionAndFov result;
    result.Distortion = localDistortion;
    result.Fov        = fov;

    return result;
}


static Recti CalculateViewportInternal ( StereoEye eyeType,
                                            Sizei const actualRendertargetSurfaceSize,
                                            Sizei const requestedRenderedPixelSize,
                                            bool bRendertargetSharedByBothEyes,
                                            bool bMonoRenderingMode = false )
{
    Recti renderedViewport;
    if ( bMonoRenderingMode || !bRendertargetSharedByBothEyes || (eyeType == StereoEye_Center) )
    {
        // One eye per RT.
        renderedViewport.x = 0;
        renderedViewport.y = 0;
        renderedViewport.w = Alg::Min ( actualRendertargetSurfaceSize.w, requestedRenderedPixelSize.w );
        renderedViewport.h = Alg::Min ( actualRendertargetSurfaceSize.h, requestedRenderedPixelSize.h );
    }
    else
    {
        // Both eyes share the RT.
        renderedViewport.x = 0;
        renderedViewport.y = 0;
        renderedViewport.w = Alg::Min ( actualRendertargetSurfaceSize.w/2, requestedRenderedPixelSize.w );
        renderedViewport.h = Alg::Min ( actualRendertargetSurfaceSize.h,  requestedRenderedPixelSize.h );
        if ( eyeType == StereoEye_Right )
        {
            renderedViewport.x = (actualRendertargetSurfaceSize.w+1)/2;      // Round up, not down.
        }
    }
    return renderedViewport;
}

static Recti CalculateViewportDensityInternal ( StereoEye eyeType,
                                                   DistortionRenderDesc const &distortion,
                                                   FovPort const &fov,
                                                   Sizei const &actualRendertargetSurfaceSize,
                                                   bool bRendertargetSharedByBothEyes,
                                                   float desiredPixelDensity = 1.0f,
                                                   bool bMonoRenderingMode = false )
{
    OVR_ASSERT ( actualRendertargetSurfaceSize.w > 0 );
    OVR_ASSERT ( actualRendertargetSurfaceSize.h > 0 );

    // What size RT do we need to get 1:1 mapping?
    Sizei idealPixelSize = CalculateIdealPixelSize ( eyeType, distortion, fov, desiredPixelDensity );
    // ...but we might not actually get that size.
    return CalculateViewportInternal ( eyeType,
                                       actualRendertargetSurfaceSize,
                                       idealPixelSize,
                                       bRendertargetSharedByBothEyes, bMonoRenderingMode );
}

static ViewportScaleAndOffset CalculateViewportScaleAndOffsetInternal (
                                                          ScaleAndOffset2D const &eyeToSourceNDC,
                                                          Recti const &renderedViewport,
                                                          Sizei const &actualRendertargetSurfaceSize )
{
    ViewportScaleAndOffset result;
    result.RenderedViewport = renderedViewport;
    result.EyeToSourceUV = CreateUVScaleAndOffsetfromNDCScaleandOffset(
                                            eyeToSourceNDC, renderedViewport, actualRendertargetSurfaceSize );
    return result;
}


static StereoEyeParams CalculateStereoEyeParamsInternal ( StereoEye eyeType, HmdRenderInfo const &hmd,
                                                          DistortionRenderDesc const &distortion,
                                                          FovPort const &fov,
                                                          Sizei const &actualRendertargetSurfaceSize,
                                                          Recti const &renderedViewport,
                                                          bool bRightHanded = true, float zNear = 0.01f, float zFar = 10000.0f,
                                                          bool bMonoRenderingMode = false,
                                                          float zoomFactor = 1.0f )
{
    // Generate the projection matrix for intermediate rendertarget.
    // Z range can also be inserted later by the app (though not in this particular case)
    float fovScale = 1.0f / zoomFactor;
    FovPort zoomedFov = fov;
    zoomedFov.LeftTan  *= fovScale;
    zoomedFov.RightTan *= fovScale;
    zoomedFov.UpTan    *= fovScale;
    zoomedFov.DownTan  *= fovScale;
    Matrix4f projection = CreateProjection ( bRightHanded, zoomedFov, zNear, zFar );

    // Find the mapping from TanAngle space to target NDC space.
    // Note this does NOT take the zoom factor into account because
    // this is the mapping of actual physical eye FOV (and our eyes do not zoom!)
    // to screen space.
    ScaleAndOffset2D eyeToSourceNDC = CreateNDCScaleAndOffsetFromFov ( fov );
    
    // The size of the final FB, which is fixed and determined by the physical size of the device display.
    Recti distortedViewport   = GetFramebufferViewport ( eyeType, hmd );
    Vector3f virtualCameraOffset = CalculateEyeVirtualCameraOffset(hmd, eyeType, bMonoRenderingMode);

    StereoEyeParams result;
    result.Eye                  = eyeType;
    result.ViewAdjust           = Matrix4f::Translation(virtualCameraOffset);
    result.Distortion           = distortion;
    result.DistortionViewport   = distortedViewport;
    result.Fov                  = fov;
    result.RenderedProjection   = projection;
    result.EyeToSourceNDC       = eyeToSourceNDC;
    ViewportScaleAndOffset vsao = CalculateViewportScaleAndOffsetInternal ( eyeToSourceNDC, renderedViewport, actualRendertargetSurfaceSize );
    result.RenderedViewport     = vsao.RenderedViewport;
    result.EyeToSourceUV        = vsao.EyeToSourceUV;

    return result;
}


Vector3f CalculateEyeVirtualCameraOffset(HmdRenderInfo const &hmd,
                                         StereoEye eyeType, bool bmonoRenderingMode)
{
    Vector3f virtualCameraOffset(0);

    if (!bmonoRenderingMode)
    {
        float eyeCenterRelief = hmd.GetEyeCenter().ReliefInMeters;

        if (eyeType == StereoEye_Left)
        {
            virtualCameraOffset.x = hmd.EyeLeft.NoseToPupilInMeters;
            virtualCameraOffset.z = eyeCenterRelief - hmd.EyeLeft.ReliefInMeters;
        }
        else if (eyeType == StereoEye_Right)
        {
            virtualCameraOffset.x = -hmd.EyeRight.NoseToPupilInMeters;
            virtualCameraOffset.z = eyeCenterRelief - hmd.EyeRight.ReliefInMeters;
        }
    }

    return virtualCameraOffset;
}


//-----------------------------------------------------------------------------------
// **** Higher-level utility functions.

Sizei CalculateRecommendedTextureSize ( HmdRenderInfo const &hmd,
                                        bool bRendertargetSharedByBothEyes,
                                        float pixelDensityInCenter /*= 1.0f*/ )
{
    Sizei idealPixelSize[2];
    for ( int eyeNum = 0; eyeNum < 2; eyeNum++ )
    {
        StereoEye eyeType = ( eyeNum == 0 ) ? StereoEye_Left : StereoEye_Right;

        DistortionAndFov distortionAndFov = CalculateDistortionAndFovInternal ( eyeType, hmd, NULL, NULL, OVR_DEFAULT_EXTRA_EYE_ROTATION );

        idealPixelSize[eyeNum] = CalculateIdealPixelSize ( eyeType,
                                        distortionAndFov.Distortion,
                                        distortionAndFov.Fov,
                                        pixelDensityInCenter );
    }

    Sizei result;
    result.w = Alg::Max ( idealPixelSize[0].w, idealPixelSize[1].w );
    result.h = Alg::Max ( idealPixelSize[0].h, idealPixelSize[1].h );
    if ( bRendertargetSharedByBothEyes )
    {
        result.w *= 2;
    }
    return result;
}

StereoEyeParams CalculateStereoEyeParams ( HmdRenderInfo const &hmd,
                                           StereoEye eyeType,
                                           Sizei const &actualRendertargetSurfaceSize,
                                           bool bRendertargetSharedByBothEyes,
                                           bool bRightHanded /*= true*/,
                                           float zNear /*= 0.01f*/, float zFar /*= 10000.0f*/,
										   Sizei const *pOverrideRenderedPixelSize /* = NULL*/,
                                           FovPort const *pOverrideFovport /*= NULL*/,
                                           float zoomFactor /*= 1.0f*/ )
{
    DistortionAndFov distortionAndFov = CalculateDistortionAndFovInternal ( eyeType, hmd, NULL, NULL, OVR_DEFAULT_EXTRA_EYE_ROTATION );
    if ( pOverrideFovport != NULL )
    {
        distortionAndFov.Fov = *pOverrideFovport;
    }

    Recti viewport;
    if ( pOverrideRenderedPixelSize != NULL )
    {
        viewport = CalculateViewportInternal ( eyeType, actualRendertargetSurfaceSize, *pOverrideRenderedPixelSize, bRendertargetSharedByBothEyes, false );
    }
    else
    {
        viewport = CalculateViewportDensityInternal ( eyeType,
                                                      distortionAndFov.Distortion,
                                                      distortionAndFov.Fov,
                                                      actualRendertargetSurfaceSize, bRendertargetSharedByBothEyes, 1.0f, false );
    }

    return CalculateStereoEyeParamsInternal (
                                eyeType, hmd,
                                distortionAndFov.Distortion,
                                distortionAndFov.Fov,
                                actualRendertargetSurfaceSize, viewport,
                                bRightHanded, zNear, zFar, false, zoomFactor );
}


FovPort CalculateRecommendedFov ( HmdRenderInfo const &hmd,
                                  StereoEye eyeType,
                                  bool bMakeFovSymmetrical /* = false */ )
{
    DistortionAndFov distortionAndFov = CalculateDistortionAndFovInternal ( eyeType, hmd, NULL, NULL, OVR_DEFAULT_EXTRA_EYE_ROTATION );
    FovPort fov = distortionAndFov.Fov;
    if ( bMakeFovSymmetrical )
    {
        // Deal with engines that cannot support an off-center projection.
        // Unfortunately this means they will be rendering pixels that the user can't actually see.
        float fovTanH = Alg::Max ( fov.LeftTan, fov.RightTan );
        float fovTanV = Alg::Max ( fov.UpTan, fov.DownTan );
        fov.LeftTan = fovTanH;
        fov.RightTan = fovTanH;
        fov.UpTan = fovTanV;
        fov.DownTan = fovTanV;
    }
    return fov;
}

ViewportScaleAndOffset ModifyRenderViewport ( StereoEyeParams const &params,
                                              Sizei const &actualRendertargetSurfaceSize,
                                              Recti const &renderViewport )
{
    return CalculateViewportScaleAndOffsetInternal ( params.EyeToSourceNDC, renderViewport, actualRendertargetSurfaceSize );
}

ViewportScaleAndOffset ModifyRenderSize ( StereoEyeParams const &params,
                                          Sizei const &actualRendertargetSurfaceSize,
                                          Sizei const &requestedRenderSize,
                                          bool bRendertargetSharedByBothEyes /*= false*/ )
{
    Recti renderViewport = CalculateViewportInternal ( params.Eye, actualRendertargetSurfaceSize, requestedRenderSize, bRendertargetSharedByBothEyes, false );
    return CalculateViewportScaleAndOffsetInternal ( params.EyeToSourceNDC, renderViewport, actualRendertargetSurfaceSize );
}

ViewportScaleAndOffset ModifyRenderDensity ( StereoEyeParams const &params,
                                             Sizei const &actualRendertargetSurfaceSize,
                                             float pixelDensity /*= 1.0f*/,
                                             bool bRendertargetSharedByBothEyes /*= false*/ )
{
    Recti renderViewport = CalculateViewportDensityInternal ( params.Eye, params.Distortion, params.Fov, actualRendertargetSurfaceSize, bRendertargetSharedByBothEyes, pixelDensity, false );
    return CalculateViewportScaleAndOffsetInternal ( params.EyeToSourceNDC, renderViewport, actualRendertargetSurfaceSize );
}


//-----------------------------------------------------------------------------------
// **** StereoConfig Implementation

StereoConfig::StereoConfig(StereoMode mode)
    : Mode(mode),
      DirtyFlag(true)
{
    // Initialize ""fake"" default HMD values for testing without HMD plugged in.
    // These default values match those returned by DK1
    // (at least they did at time of writing - certainly good enough for debugging)
    Hmd.HmdType                                         = HmdType_None;
    Hmd.ResolutionInPixels                              = Sizei(1280, 800);
    Hmd.ScreenSizeInMeters                              = Sizef(0.1498f, 0.0936f);
    Hmd.ScreenGapSizeInMeters                           = 0.0f;
    Hmd.CenterFromTopInMeters                           = 0.0468f;
    Hmd.LensSeparationInMeters                          = 0.0635f;
    Hmd.LensDiameterInMeters                            = 0.035f;
    Hmd.LensSurfaceToMidplateInMeters                   = 0.025f;
    Hmd.EyeCups                                         = EyeCup_DK1A;
    Hmd.Shutter.Type                                    = HmdShutter_RollingTopToBottom;
    Hmd.Shutter.VsyncToNextVsync                        = ( 1.0f / 60.0f );
    Hmd.Shutter.VsyncToFirstScanline                    = 0.000052f;
    Hmd.Shutter.FirstScanlineToLastScanline             = 0.016580f;
    Hmd.Shutter.PixelSettleTime                         = 0.015f;
    Hmd.Shutter.PixelPersistence                        = ( 1.0f / 60.0f );
    Hmd.EyeLeft.Distortion.SetToIdentity();
    Hmd.EyeLeft.Distortion.MetersPerTanAngleAtCenter    = 0.043875f;
    Hmd.EyeLeft.Distortion.Eqn                          = Distortion_RecipPoly4;
    Hmd.EyeLeft.Distortion.K[0]                         = 1.0f;
    Hmd.EyeLeft.Distortion.K[1]                         = -0.3999f;
    Hmd.EyeLeft.Distortion.K[2]                         = 0.2408f;
    Hmd.EyeLeft.Distortion.K[3]                         = -0.4589f;
    Hmd.EyeLeft.Distortion.MaxR                         = 1.0f;
	Hmd.EyeLeft.Distortion.ChromaticAberration[0]		= 0.006f;
	Hmd.EyeLeft.Distortion.ChromaticAberration[1]		= 0.0f;
	Hmd.EyeLeft.Distortion.ChromaticAberration[2]		= -0.014f;
	Hmd.EyeLeft.Distortion.ChromaticAberration[3]		= 0.0f;
    Hmd.EyeLeft.NoseToPupilInMeters                     = 0.62f;
    Hmd.EyeLeft.ReliefInMeters                          = 0.013f;
    Hmd.EyeRight = Hmd.EyeLeft;

    SetViewportMode = SVPM_Density;
    SetViewportPixelsPerDisplayPixel = 1.0f;
    // Not used in this mode, but init them anyway.
    SetViewportSize[0] = Sizei(0,0);
    SetViewportSize[1] = Sizei(0,0);
    SetViewport[0] = Recti(0,0,0,0);
    SetViewport[1] = Recti(0,0,0,0);

    OverrideLens = false;
    OverrideTanHalfFov = false;
    OverrideZeroIpd = false;
    ExtraEyeRotationInRadians = OVR_DEFAULT_EXTRA_EYE_ROTATION;
    IsRendertargetSharedByBothEyes = true;
    RightHandedProjection = true;

    // This should cause an assert if the app does not call SetRendertargetSize()
    RendertargetSize = Sizei ( 0, 0 );

    ZNear = 0.01f;
    ZFar = 10000.0f;

    Set2DAreaFov(DegreeToRad(85.0f));
}

void StereoConfig::SetHmdRenderInfo(const HmdRenderInfo& hmd)
{
    Hmd = hmd;
    DirtyFlag = true;
}

void StereoConfig::Set2DAreaFov(float fovRadians)
{
    Area2DFov = fovRadians;
    DirtyFlag = true;
}

const StereoEyeParamsWithOrtho& StereoConfig::GetEyeRenderParams(StereoEye eye)
{
    if ( DirtyFlag )
    {
        UpdateComputedState();
    }

    static const UByte eyeParamIndices[3] = { 0, 0, 1 };

    OVR_ASSERT(eye < sizeof(eyeParamIndices));
    return EyeRenderParams[eyeParamIndices[eye]];
}

void StereoConfig::SetLensOverride ( LensConfig const *pLensOverrideLeft  /*= NULL*/,
                                     LensConfig const *pLensOverrideRight /*= NULL*/ )
{
    if ( pLensOverrideLeft == NULL )
    {
        OverrideLens = false;
    }
    else
    {
        OverrideLens = true;
        LensOverrideLeft = *pLensOverrideLeft;
        LensOverrideRight = *pLensOverrideLeft;
        if ( pLensOverrideRight != NULL )
        {
            LensOverrideRight = *pLensOverrideRight;
        }
    }
    DirtyFlag = true;
}

void StereoConfig::SetRendertargetSize (Size<int> const rendertargetSize,
                                        bool rendertargetIsSharedByBothEyes )
{
    RendertargetSize = rendertargetSize;
    IsRendertargetSharedByBothEyes = rendertargetIsSharedByBothEyes;
    DirtyFlag = true;
}

void StereoConfig::SetFov ( FovPort const *pfovLeft  /*= NULL*/,
                            FovPort const *pfovRight /*= NULL*/ )
{
    DirtyFlag = true;
    if ( pfovLeft == NULL )
    {
        OverrideTanHalfFov = false;
    }
    else
    {
        OverrideTanHalfFov = true;
        FovOverrideLeft  = *pfovLeft;
        FovOverrideRight = *pfovLeft;
        if ( pfovRight != NULL )
        {
            FovOverrideRight = *pfovRight;
        }
    }
}


void StereoConfig::SetZeroVirtualIpdOverride ( bool enableOverride )
{
    DirtyFlag = true;
    OverrideZeroIpd = enableOverride;
}


void StereoConfig::SetZClipPlanesAndHandedness ( float zNear /*= 0.01f*/, float zFar /*= 10000.0f*/, bool rightHandedProjection /*= true*/ )
{
    DirtyFlag = true;
    ZNear = zNear;
    ZFar = zFar;
    RightHandedProjection = rightHandedProjection;
}

void StereoConfig::SetExtraEyeRotation ( float extraEyeRotationInRadians )
{
    DirtyFlag = true;
    ExtraEyeRotationInRadians = extraEyeRotationInRadians;
}

Sizei StereoConfig::CalculateRecommendedTextureSize ( bool rendertargetSharedByBothEyes,
                                                      float pixelDensityInCenter /*= 1.0f*/ )
{
    return Render::CalculateRecommendedTextureSize ( Hmd, rendertargetSharedByBothEyes, pixelDensityInCenter );
}



void StereoConfig::UpdateComputedState()
{
    int numEyes = 2;
    StereoEye eyeTypes[2];

    switch ( Mode )
    {
    case Stereo_None:
        numEyes         = 1;
        eyeTypes[0]     = StereoEye_Center;
        break;

    case Stereo_LeftRight_Multipass:
        numEyes         = 2;
        eyeTypes[0]     = StereoEye_Left;
        eyeTypes[1]     = StereoEye_Right;
        break;

    default:        
        OVR_ASSERT( false ); break;
    }

    // If either of these fire, you've probably forgotten to call SetRendertargetSize()
    OVR_ASSERT ( RendertargetSize.w > 0 );
    OVR_ASSERT ( RendertargetSize.h > 0 );

    for ( int eyeNum = 0; eyeNum < numEyes; eyeNum++ )
    {
        StereoEye eyeType = eyeTypes[eyeNum];
        LensConfig *pLensOverride = NULL;
        if ( OverrideLens )
        {
            if ( eyeType == StereoEye_Right )
            {
                pLensOverride = &LensOverrideRight;
            }
            else
            {
                pLensOverride = &LensOverrideLeft;
            }
        }

        FovPort *pTanHalfFovOverride = NULL;
        if ( OverrideTanHalfFov )
        {
            if ( eyeType == StereoEye_Right )
            {
                pTanHalfFovOverride = &FovOverrideRight;
            }
            else
            {
                pTanHalfFovOverride = &FovOverrideLeft;
            }
        }

        DistortionAndFov distortionAndFov =
            CalculateDistortionAndFovInternal ( eyeType, Hmd,
                                                pLensOverride, pTanHalfFovOverride,
                                                ExtraEyeRotationInRadians );

        EyeRenderParams[eyeNum].StereoEye.Distortion = distortionAndFov.Distortion;
        EyeRenderParams[eyeNum].StereoEye.Fov        = distortionAndFov.Fov;
    }

    if ( OverrideZeroIpd )
    {
        // Take the union of the calculated eye FOVs.
        FovPort fov;
        fov.UpTan    = Alg::Max ( EyeRenderParams[0].StereoEye.Fov.UpTan   , EyeRenderParams[1].StereoEye.Fov.UpTan    );
        fov.DownTan  = Alg::Max ( EyeRenderParams[0].StereoEye.Fov.DownTan , EyeRenderParams[1].StereoEye.Fov.DownTan  );
        fov.LeftTan  = Alg::Max ( EyeRenderParams[0].StereoEye.Fov.LeftTan , EyeRenderParams[1].StereoEye.Fov.LeftTan  );
        fov.RightTan = Alg::Max ( EyeRenderParams[0].StereoEye.Fov.RightTan, EyeRenderParams[1].StereoEye.Fov.RightTan );
        EyeRenderParams[0].StereoEye.Fov = fov;
        EyeRenderParams[1].StereoEye.Fov = fov;
    }

    for ( int eyeNum = 0; eyeNum < numEyes; eyeNum++ )
    {
        StereoEye eyeType = eyeTypes[eyeNum];

        DistortionRenderDesc localDistortion = EyeRenderParams[eyeNum].StereoEye.Distortion;
        FovPort              fov             = EyeRenderParams[eyeNum].StereoEye.Fov;

        // Use a placeholder - will be overridden later.
        Recti tempViewport = Recti ( 0, 0, 1, 1 );

        EyeRenderParams[eyeNum].StereoEye = CalculateStereoEyeParamsInternal (
                                        eyeType, Hmd, localDistortion, fov,
                                        RendertargetSize, tempViewport,
                                        RightHandedProjection, ZNear, ZFar,
                                        OverrideZeroIpd );

        // We want to create a virtual 2D surface we can draw debug text messages to.
        // We'd like it to be a fixed distance (OrthoDistance) away,
        // and to cover a specific FOV (Area2DFov). We need to find the projection matrix for this,
        // and also to know how large it is in pixels to achieve a 1:1 mapping at the center of the screen.
        float orthoDistance = 0.8f;
        float orthoHalfFov = tanf ( Area2DFov * 0.5f );
        Vector2f unityOrthoPixelSize = localDistortion.PixelsPerTanAngleAtCenter * ( orthoHalfFov * 2.0f );
        float localInterpupillaryDistance = Hmd.EyeLeft.NoseToPupilInMeters + Hmd.EyeRight.NoseToPupilInMeters;
        if ( OverrideZeroIpd )
        {
            localInterpupillaryDistance = 0.0f;
        }
        Matrix4f ortho = CreateOrthoSubProjection ( true, eyeType,
                                                    orthoHalfFov, orthoHalfFov,
                                                    unityOrthoPixelSize.x, unityOrthoPixelSize.y,
                                                    orthoDistance, localInterpupillaryDistance,
                                                    EyeRenderParams[eyeNum].StereoEye.RenderedProjection );
        EyeRenderParams[eyeNum].OrthoProjection = ortho;
    }

    // ...and now set up the viewport, scale & offset the way the app wanted.
    setupViewportScaleAndOffsets();

    if ( OverrideZeroIpd )
    {
        // Monocular rendering has some fragile parts... don't break any by accident.
        OVR_ASSERT ( EyeRenderParams[0].StereoEye.Fov.UpTan                   == EyeRenderParams[1].StereoEye.Fov.UpTan    );
        OVR_ASSERT ( EyeRenderParams[0].StereoEye.Fov.DownTan                 == EyeRenderParams[1].StereoEye.Fov.DownTan  );
        OVR_ASSERT ( EyeRenderParams[0].StereoEye.Fov.LeftTan                 == EyeRenderParams[1].StereoEye.Fov.LeftTan  );
        OVR_ASSERT ( EyeRenderParams[0].StereoEye.Fov.RightTan                == EyeRenderParams[1].StereoEye.Fov.RightTan );
        OVR_ASSERT ( EyeRenderParams[0].StereoEye.RenderedProjection.M[0][0]  == EyeRenderParams[1].StereoEye.RenderedProjection.M[0][0] );
        OVR_ASSERT ( EyeRenderParams[0].StereoEye.RenderedProjection.M[1][1]  == EyeRenderParams[1].StereoEye.RenderedProjection.M[1][1] );
        OVR_ASSERT ( EyeRenderParams[0].StereoEye.RenderedProjection.M[0][2]  == EyeRenderParams[1].StereoEye.RenderedProjection.M[0][2] );
        OVR_ASSERT ( EyeRenderParams[0].StereoEye.RenderedProjection.M[1][2]  == EyeRenderParams[1].StereoEye.RenderedProjection.M[1][2] );
        OVR_ASSERT ( EyeRenderParams[0].StereoEye.RenderedViewport            == EyeRenderParams[1].StereoEye.RenderedViewport      );
        OVR_ASSERT ( EyeRenderParams[0].StereoEye.EyeToSourceUV.Offset        == EyeRenderParams[1].StereoEye.EyeToSourceUV.Offset  );
        OVR_ASSERT ( EyeRenderParams[0].StereoEye.EyeToSourceUV.Scale         == EyeRenderParams[1].StereoEye.EyeToSourceUV.Scale   );
        OVR_ASSERT ( EyeRenderParams[0].StereoEye.EyeToSourceNDC.Offset       == EyeRenderParams[1].StereoEye.EyeToSourceNDC.Offset );
        OVR_ASSERT ( EyeRenderParams[0].StereoEye.EyeToSourceNDC.Scale        == EyeRenderParams[1].StereoEye.EyeToSourceNDC.Scale  );
        OVR_ASSERT ( EyeRenderParams[0].OrthoProjection.M[0][0]               == EyeRenderParams[1].OrthoProjection.M[0][0] );
        OVR_ASSERT ( EyeRenderParams[0].OrthoProjection.M[1][1]               == EyeRenderParams[1].OrthoProjection.M[1][1] );
        OVR_ASSERT ( EyeRenderParams[0].OrthoProjection.M[0][2]               == EyeRenderParams[1].OrthoProjection.M[0][2] );
        OVR_ASSERT ( EyeRenderParams[0].OrthoProjection.M[1][2]               == EyeRenderParams[1].OrthoProjection.M[1][2] );
    }

    DirtyFlag = false;
}



ViewportScaleAndOffsetBothEyes StereoConfig::setupViewportScaleAndOffsets()
{
    for ( int eyeNum = 0; eyeNum < 2; eyeNum++ )
    {
        StereoEye eyeType = ( eyeNum == 0 ) ? StereoEye_Left : StereoEye_Right;

        DistortionRenderDesc localDistortion = EyeRenderParams[eyeNum].StereoEye.Distortion;
        FovPort              fov             = EyeRenderParams[eyeNum].StereoEye.Fov;

        Recti renderedViewport;
        switch ( SetViewportMode )
        {
        case SVPM_Density:
            renderedViewport = CalculateViewportDensityInternal (
                                    eyeType, localDistortion, fov,
                                    RendertargetSize, IsRendertargetSharedByBothEyes,
                                    SetViewportPixelsPerDisplayPixel, OverrideZeroIpd );
            break;
        case SVPM_Size:
            if ( ( eyeType == StereoEye_Right ) && !OverrideZeroIpd )
            {
                renderedViewport = CalculateViewportInternal (
                                        eyeType, RendertargetSize,
                                        SetViewportSize[1],
                                        IsRendertargetSharedByBothEyes, OverrideZeroIpd );
            }
            else
            {
                renderedViewport = CalculateViewportInternal (
                                        eyeType, RendertargetSize,
                                        SetViewportSize[0],
                                        IsRendertargetSharedByBothEyes, OverrideZeroIpd );
            }
            break;
        case SVPM_Viewport:
            if ( ( eyeType == StereoEye_Right ) && !OverrideZeroIpd )
            {
                renderedViewport = SetViewport[1];
            }
            else
            {
                renderedViewport = SetViewport[0];
            }
            break;
        default: OVR_ASSERT ( false ); break;
        }

        ViewportScaleAndOffset vpsao = CalculateViewportScaleAndOffsetInternal (
                                                EyeRenderParams[eyeNum].StereoEye.EyeToSourceNDC,
                                                renderedViewport,
                                                RendertargetSize );
        EyeRenderParams[eyeNum].StereoEye.RenderedViewport = vpsao.RenderedViewport;
        EyeRenderParams[eyeNum].StereoEye.EyeToSourceUV    = vpsao.EyeToSourceUV;
    }

    ViewportScaleAndOffsetBothEyes result;
    result.Left.EyeToSourceUV     = EyeRenderParams[0].StereoEye.EyeToSourceUV;
    result.Left.RenderedViewport  = EyeRenderParams[0].StereoEye.RenderedViewport;
    result.Right.EyeToSourceUV    = EyeRenderParams[1].StereoEye.EyeToSourceUV;
    result.Right.RenderedViewport = EyeRenderParams[1].StereoEye.RenderedViewport;
    return result;
}

// Specify a pixel density - how many rendered pixels per pixel in the physical display.
ViewportScaleAndOffsetBothEyes StereoConfig::SetRenderDensity ( float pixelsPerDisplayPixel )
{
    SetViewportMode  = SVPM_Density;
    SetViewportPixelsPerDisplayPixel = pixelsPerDisplayPixel;
    return setupViewportScaleAndOffsets();
}

// Supply the size directly. Will be clamped to the physical rendertarget size.
ViewportScaleAndOffsetBothEyes StereoConfig::SetRenderSize ( Sizei const &renderSizeLeft, Sizei const &renderSizeRight )
{
    SetViewportMode  = SVPM_Size;
    SetViewportSize[0] = renderSizeLeft;
    SetViewportSize[1] = renderSizeRight;
    return setupViewportScaleAndOffsets();
}

// Supply the viewport directly. This is not clamped to the physical rendertarget - careful now!
ViewportScaleAndOffsetBothEyes StereoConfig::SetRenderViewport ( Recti const &renderViewportLeft, Recti const &renderViewportRight )
{
    SetViewportMode  = SVPM_Viewport;
    SetViewport[0] = renderViewportLeft;
    SetViewport[1] = renderViewportRight;
    return setupViewportScaleAndOffsets();
}

Matrix4f StereoConfig::GetProjectionWithZoom ( StereoEye eye, float fovZoom ) const
{
    int eyeNum = ( eye == StereoEye_Right ) ? 1 : 0;
    float fovScale = 1.0f / fovZoom;
    FovPort fovPort = EyeRenderParams[eyeNum].StereoEye.Fov;
    fovPort.LeftTan  *= fovScale;
    fovPort.RightTan *= fovScale;
    fovPort.UpTan    *= fovScale;
    fovPort.DownTan  *= fovScale;
    return CreateProjection ( RightHandedProjection, fovPort, ZNear, ZFar );
}




//-----------------------------------------------------------------------------------
// *****  Distortion Mesh Rendering


// Pow2 for the Morton order to work!
// 4 is too low - it is easy to see the ""wobbles"" in the HMD.
// 5 is realllly close but you can see pixel differences with even/odd frame checking.
// 6 is indistinguishable on a monitor on even/odd frames.
static const int DMA_GridSizeLog2   = 6;
static const int DMA_GridSize       = 1<<DMA_GridSizeLog2;
static const int DMA_NumVertsPerEye = (DMA_GridSize+1)*(DMA_GridSize+1);
static const int DMA_NumTrisPerEye  = (DMA_GridSize)*(DMA_GridSize)*2;



void DistortionMeshDestroy ( DistortionMeshVertexData *pVertices, UInt16 *pTriangleMeshIndices )
{
    OVR_FREE ( pVertices );
    OVR_FREE ( pTriangleMeshIndices );
}

void DistortionMeshCreate ( DistortionMeshVertexData **ppVertices, UInt16 **ppTriangleListIndices,
                            int *pNumVertices, int *pNumTriangles,
                            const StereoEyeParams &stereoParams, const HmdRenderInfo &hmdRenderInfo )
{
    bool    rightEye      = ( stereoParams.Eye == StereoEye_Right );
    int     vertexCount   = 0;
    int     triangleCount = 0;

    // Generate mesh into allocated data and return result.
    DistortionMeshCreate(ppVertices, ppTriangleListIndices, &vertexCount, &triangleCount,
                         rightEye, hmdRenderInfo, stereoParams.Distortion, stereoParams.EyeToSourceNDC);
    
    *pNumVertices  = vertexCount;
    *pNumTriangles = triangleCount;
}


// Generate distortion mesh for a eye.
void DistortionMeshCreate( DistortionMeshVertexData **ppVertices, UInt16 **ppTriangleListIndices,
                           int *pNumVertices, int *pNumTriangles,
                           bool rightEye,
                           const HmdRenderInfo &hmdRenderInfo, 
                           const DistortionRenderDesc &distortion, const ScaleAndOffset2D &eyeToSourceNDC )
{
    *pNumVertices  = DMA_NumVertsPerEye;
    *pNumTriangles = DMA_NumTrisPerEye;

    *ppVertices = (DistortionMeshVertexData*)
                      OVR_ALLOC( sizeof(DistortionMeshVertexData) * (*pNumVertices) );
    *ppTriangleListIndices  = (UInt16*) OVR_ALLOC( sizeof(UInt16) * (*pNumTriangles) * 3 );

    if (!*ppVertices || !*ppTriangleListIndices)
    {
        if (*ppVertices)
        {
            OVR_FREE(*ppVertices);
        }
        if (*ppTriangleListIndices)
        {
            OVR_FREE(*ppTriangleListIndices);
        }
        *ppVertices             = NULL;
        *ppTriangleListIndices  = NULL;
        *pNumTriangles          = 0;
        *pNumVertices           = 0;
        return;
    }

    // When does the fade-to-black edge start? Chosen heuristically.
    const float fadeOutBorderFraction = 0.075f;
      
    
    // Populate vertex buffer info
    float xOffset = 0.0f;
    float uOffset = 0.0f;
    OVR_UNUSED(uOffset);

    if (rightEye)
    {
        xOffset = 1.0f;
        uOffset = 0.5f;
    }

    // First pass - build up raw vertex data.
    DistortionMeshVertexData* pcurVert = *ppVertices;

    for ( int y = 0; y <= DMA_GridSize; y++ )
    {
        for ( int x = 0; x <= DMA_GridSize; x++ )
        {

            Vector2f sourceCoordNDC;
            // NDC texture coords [-1,+1]
            sourceCoordNDC.x = 2.0f * ( (float)x / (float)DMA_GridSize ) - 1.0f;
            sourceCoordNDC.y = 2.0f * ( (float)y / (float)DMA_GridSize ) - 1.0f;
            Vector2f tanEyeAngle = TransformRendertargetNDCToTanFovSpace ( eyeToSourceNDC, sourceCoordNDC );

            // This is the function that does the really heavy lifting.
            Vector2f screenNDC = TransformTanFovSpaceToScreenNDC ( distortion, tanEyeAngle, false );

            // We then need RGB UVs. Since chromatic aberration is generated from screen coords, not
            // directly from texture NDCs, we can't just use tanEyeAngle, we need to go the long way round.
            Vector2f tanEyeAnglesR, tanEyeAnglesG, tanEyeAnglesB;
            TransformScreenNDCToTanFovSpaceChroma ( &tanEyeAnglesR, &tanEyeAnglesG, &tanEyeAnglesB,
                                                    distortion, screenNDC );
			
			pcurVert->TanEyeAnglesR = tanEyeAnglesR;
			pcurVert->TanEyeAnglesG = tanEyeAnglesG;
			pcurVert->TanEyeAnglesB = tanEyeAnglesB;
			

            HmdShutterTypeEnum shutterType = hmdRenderInfo.Shutter.Type;
            switch ( shutterType )
            {
            case HmdShutter_Global:
                pcurVert->TimewarpLerp = 0.0f;
                break;
            case HmdShutter_RollingLeftToRight:
                // Retrace is left to right - left eye goes 0.0 -> 0.5, then right goes 0.5 -> 1.0
                pcurVert->TimewarpLerp = screenNDC.x * 0.25f + 0.25f;
                if (rightEye)
                {
                    pcurVert->TimewarpLerp += 0.5f;
                }
                break;
            case HmdShutter_RollingRightToLeft:
                // Retrace is right to left - right eye goes 0.0 -> 0.5, then left goes 0.5 -> 1.0
                pcurVert->TimewarpLerp = 0.75f - screenNDC.x * 0.25f;
                if (rightEye)
                {
                    pcurVert->TimewarpLerp -= 0.5f;
                }
                break;
            case HmdShutter_RollingTopToBottom:
                // Retrace is top to bottom on both eyes at the same time.
                pcurVert->TimewarpLerp = screenNDC.y * 0.5f + 0.5f;
                break;
            default: OVR_ASSERT ( false ); break;
            }

            // Fade out at texture edges.
            float edgeFadeIn       = ( 1.0f / fadeOutBorderFraction ) *
                                     ( 1.0f - Alg::Max ( Alg::Abs ( sourceCoordNDC.x ), Alg::Abs ( sourceCoordNDC.y ) ) );
            // Also fade out at screen edges.
            float edgeFadeInScreen = ( 2.0f / fadeOutBorderFraction ) *
                                     ( 1.0f - Alg::Max ( Alg::Abs ( screenNDC.x ), Alg::Abs ( screenNDC.y ) ) );
            edgeFadeIn = Alg::Min ( edgeFadeInScreen, edgeFadeIn );

            // Don't let verts overlap to the other eye.
            screenNDC.x = Alg::Max ( -1.0f, Alg::Min ( screenNDC.x, 1.0f ) );
            screenNDC.y = Alg::Max ( -1.0f, Alg::Min ( screenNDC.y, 1.0f ) );

            pcurVert->Shade = Alg::Max ( 0.0f, Alg::Min ( edgeFadeIn, 1.0f ) );
            pcurVert->ScreenPosNDC.x = 0.5f * screenNDC.x - 0.5f + xOffset;
            pcurVert->ScreenPosNDC.y = -screenNDC.y;

            pcurVert++;
        }
    }


    // Populate index buffer info  
    UInt16 *pcurIndex = *ppTriangleListIndices;

    for ( int triNum = 0; triNum < DMA_GridSize * DMA_GridSize; triNum++ )
    {
        // Use a Morton order to help locality of FB, texture and vertex cache.
        // (0.325ms raster order -> 0.257ms Morton order)
        OVR_ASSERT ( DMA_GridSize <= 256 );
        int x = ( ( triNum & 0x0001 ) >> 0 ) |
                ( ( triNum & 0x0004 ) >> 1 ) |
                ( ( triNum & 0x0010 ) >> 2 ) |
                ( ( triNum & 0x0040 ) >> 3 ) |
                ( ( triNum & 0x0100 ) >> 4 ) |
                ( ( triNum & 0x0400 ) >> 5 ) |
                ( ( triNum & 0x1000 ) >> 6 ) |
                ( ( triNum & 0x4000 ) >> 7 );
        int y = ( ( triNum & 0x0002 ) >> 1 ) |
                ( ( triNum & 0x0008 ) >> 2 ) |
                ( ( triNum & 0x0020 ) >> 3 ) |
                ( ( triNum & 0x0080 ) >> 4 ) |
                ( ( triNum & 0x0200 ) >> 5 ) |
                ( ( triNum & 0x0800 ) >> 6 ) |
                ( ( triNum & 0x2000 ) >> 7 ) |
                ( ( triNum & 0x8000 ) >> 8 );
        int FirstVertex = x * (DMA_GridSize+1) + y;
        // Another twist - we want the top-left and bottom-right quadrants to
        // have the triangles split one way, the other two split the other.
        // +---+---+---+---+
        // |  /|  /|\\  |\\  |
        // | / | / | \\ | \\ |
        // |/  |/  |  \\|  \\|
        // +---+---+---+---+
        // |  /|  /|\\  |\\  |
        // | / | / | \\ | \\ |
        // |/  |/  |  \\|  \\|
        // +---+---+---+---+
        // |\\  |\\  |  /|  /|
        // | \\ | \\ | / | / |
        // |  \\|  \\|/  |/  |
        // +---+---+---+---+
        // |\\  |\\  |  /|  /|
        // | \\ | \\ | / | / |
        // |  \\|  \\|/  |/  |
        // +---+---+---+---+
        // This way triangle edges don't span long distances over the distortion function,
        // so linear interpolation works better & we can use fewer tris.
        if ( ( x < DMA_GridSize/2 ) != ( y < DMA_GridSize/2 ) )       // != is logical XOR
        {
            *pcurIndex++ = (UInt16)FirstVertex;
            *pcurIndex++ = (UInt16)FirstVertex+1;
            *pcurIndex++ = (UInt16)FirstVertex+(DMA_GridSize+1)+1;

            *pcurIndex++ = (UInt16)FirstVertex+(DMA_GridSize+1)+1;
            *pcurIndex++ = (UInt16)FirstVertex+(DMA_GridSize+1);
            *pcurIndex++ = (UInt16)FirstVertex;
        }
        else
        {
            *pcurIndex++ = (UInt16)FirstVertex;
            *pcurIndex++ = (UInt16)FirstVertex+1;
            *pcurIndex++ = (UInt16)FirstVertex+(DMA_GridSize+1);

            *pcurIndex++ = (UInt16)FirstVertex+1;
            *pcurIndex++ = (UInt16)FirstVertex+(DMA_GridSize+1)+1;
            *pcurIndex++ = (UInt16)FirstVertex+(DMA_GridSize+1);
        }
    }
}

//-----------------------------------------------------------------------------------
// *****  Heightmap Mesh Rendering


static const int HMA_GridSizeLog2   = 7;
static const int HMA_GridSize       = 1<<HMA_GridSizeLog2;
static const int HMA_NumVertsPerEye = (HMA_GridSize+1)*(HMA_GridSize+1);
static const int HMA_NumTrisPerEye  = (HMA_GridSize)*(HMA_GridSize)*2;


void HeightmapMeshDestroy ( HeightmapMeshVertexData *pVertices, UInt16 *pTriangleMeshIndices )
{
    OVR_FREE ( pVertices );
    OVR_FREE ( pTriangleMeshIndices );
}

void HeightmapMeshCreate ( HeightmapMeshVertexData **ppVertices, UInt16 **ppTriangleListIndices,
    int *pNumVertices, int *pNumTriangles,
    const StereoEyeParams &stereoParams, const HmdRenderInfo &hmdRenderInfo )
{
    bool    rightEye      = ( stereoParams.Eye == StereoEye_Right );
    int     vertexCount   = 0;
    int     triangleCount = 0;

    // Generate mesh into allocated data and return result.
    HeightmapMeshCreate(ppVertices, ppTriangleListIndices, &vertexCount, &triangleCount,
        rightEye, hmdRenderInfo, stereoParams.EyeToSourceNDC);

    *pNumVertices  = vertexCount;
    *pNumTriangles = triangleCount;
}


// Generate heightmap mesh for one eye.
void HeightmapMeshCreate( HeightmapMeshVertexData **ppVertices, UInt16 **ppTriangleListIndices,
    int *pNumVertices, int *pNumTriangles, bool rightEye,
    const HmdRenderInfo &hmdRenderInfo,
    const ScaleAndOffset2D &eyeToSourceNDC )
{
    *pNumVertices  = HMA_NumVertsPerEye;
    *pNumTriangles = HMA_NumTrisPerEye;

    *ppVertices = (HeightmapMeshVertexData*) OVR_ALLOC( sizeof(HeightmapMeshVertexData) * (*pNumVertices) );
    *ppTriangleListIndices  = (UInt16*) OVR_ALLOC( sizeof(UInt16) * (*pNumTriangles) * 3 );

    if (!*ppVertices || !*ppTriangleListIndices)
    {
        if (*ppVertices)
        {
            OVR_FREE(*ppVertices);
        }
        if (*ppTriangleListIndices)
        {
            OVR_FREE(*ppTriangleListIndices);
        }
        *ppVertices             = NULL;
        *ppTriangleListIndices  = NULL;
        *pNumTriangles          = 0;
        *pNumVertices           = 0;
        return;
    }

    // Populate vertex buffer info
    float xOffset = 0.0f;
    float uOffset = 0.0f;

    if (rightEye)
    {
        xOffset = 1.0f;
        uOffset = 0.5f;
    }

    // First pass - build up raw vertex data.
    HeightmapMeshVertexData* pcurVert = *ppVertices;

    for ( int y = 0; y <= HMA_GridSize; y++ )
    {
        for ( int x = 0; x <= HMA_GridSize; x++ )
        {
            Vector2f sourceCoordNDC;
            // NDC texture coords [-1,+1]
            sourceCoordNDC.x = 2.0f * ( (float)x / (float)HMA_GridSize ) - 1.0f;
            sourceCoordNDC.y = 2.0f * ( (float)y / (float)HMA_GridSize ) - 1.0f;
            Vector2f tanEyeAngle = TransformRendertargetNDCToTanFovSpace ( eyeToSourceNDC, sourceCoordNDC );
            
            pcurVert->TanEyeAngles = tanEyeAngle;

            HmdShutterTypeEnum shutterType = hmdRenderInfo.Shutter.Type;
            switch ( shutterType )
            {
            case HmdShutter_Global:
                pcurVert->TimewarpLerp = 0.0f;
                break;
            case HmdShutter_RollingLeftToRight:
                // Retrace is left to right - left eye goes 0.0 -> 0.5, then right goes 0.5 -> 1.0
                pcurVert->TimewarpLerp = sourceCoordNDC.x * 0.25f + 0.25f;
                if (rightEye)
                {
                    pcurVert->TimewarpLerp += 0.5f;
                }
                break;
            case HmdShutter_RollingRightToLeft:
                // Retrace is right to left - right eye goes 0.0 -> 0.5, then left goes 0.5 -> 1.0
                pcurVert->TimewarpLerp = 0.75f - sourceCoordNDC.x * 0.25f;
                if (rightEye)
                {
                    pcurVert->TimewarpLerp -= 0.5f;
                }
                break;
            case HmdShutter_RollingTopToBottom:
                // Retrace is top to bottom on both eyes at the same time.
                pcurVert->TimewarpLerp = sourceCoordNDC.y * 0.5f + 0.5f;
                break;
            default: OVR_ASSERT ( false ); break;
            }

            // Don't let verts overlap to the other eye.
            //sourceCoordNDC.x = Alg::Max ( -1.0f, Alg::Min ( sourceCoordNDC.x, 1.0f ) );
            //sourceCoordNDC.y = Alg::Max ( -1.0f, Alg::Min ( sourceCoordNDC.y, 1.0f ) );

            //pcurVert->ScreenPosNDC.x = 0.5f * sourceCoordNDC.x - 0.5f + xOffset;
            pcurVert->ScreenPosNDC.x = sourceCoordNDC.x;
            pcurVert->ScreenPosNDC.y = -sourceCoordNDC.y;

            pcurVert++;
        }
    }


    // Populate index buffer info  
    UInt16 *pcurIndex = *ppTriangleListIndices;

    for ( int triNum = 0; triNum < HMA_GridSize * HMA_GridSize; triNum++ )
    {
        // Use a Morton order to help locality of FB, texture and vertex cache.
        // (0.325ms raster order -> 0.257ms Morton order)
        OVR_ASSERT ( HMA_GridSize < 256 );
        int x = ( ( triNum & 0x0001 ) >> 0 ) |
                ( ( triNum & 0x0004 ) >> 1 ) |
                ( ( triNum & 0x0010 ) >> 2 ) |
                ( ( triNum & 0x0040 ) >> 3 ) |
                ( ( triNum & 0x0100 ) >> 4 ) |
                ( ( triNum & 0x0400 ) >> 5 ) |
                ( ( triNum & 0x1000 ) >> 6 ) |
                ( ( triNum & 0x4000 ) >> 7 );
        int y = ( ( triNum & 0x0002 ) >> 1 ) |
                ( ( triNum & 0x0008 ) >> 2 ) |
                ( ( triNum & 0x0020 ) >> 3 ) |
                ( ( triNum & 0x0080 ) >> 4 ) |
                ( ( triNum & 0x0200 ) >> 5 ) |
                ( ( triNum & 0x0800 ) >> 6 ) |
                ( ( triNum & 0x2000 ) >> 7 ) |
                ( ( triNum & 0x8000 ) >> 8 );
        int FirstVertex = x * (HMA_GridSize+1) + y;
        // Another twist - we want the top-left and bottom-right quadrants to
        // have the triangles split one way, the other two split the other.
        // +---+---+---+---+
        // |  /|  /|\\  |\\  |
        // | / | / | \\ | \\ |
        // |/  |/  |  \\|  \\|
        // +---+---+---+---+
        // |  /|  /|\\  |\\  |
        // | / | / | \\ | \\ |
        // |/  |/  |  \\|  \\|
        // +---+---+---+---+
        // |\\  |\\  |  /|  /|
        // | \\ | \\ | / | / |
        // |  \\|  \\|/  |/  |
        // +---+---+---+---+
        // |\\  |\\  |  /|  /|
        // | \\ | \\ | / | / |
        // |  \\|  \\|/  |/  |
        // +---+---+---+---+
        // This way triangle edges don't span long distances over the distortion function,
        // so linear interpolation works better & we can use fewer tris.
        if ( ( x < HMA_GridSize/2 ) != ( y < HMA_GridSize/2 ) )       // != is logical XOR
        {
            *pcurIndex++ = (UInt16)FirstVertex;
            *pcurIndex++ = (UInt16)FirstVertex+1;
            *pcurIndex++ = (UInt16)FirstVertex+(HMA_GridSize+1)+1;

            *pcurIndex++ = (UInt16)FirstVertex+(HMA_GridSize+1)+1;
            *pcurIndex++ = (UInt16)FirstVertex+(HMA_GridSize+1);
            *pcurIndex++ = (UInt16)FirstVertex;
        }
        else
        {
            *pcurIndex++ = (UInt16)FirstVertex;
            *pcurIndex++ = (UInt16)FirstVertex+1;
            *pcurIndex++ = (UInt16)FirstVertex+(HMA_GridSize+1);

            *pcurIndex++ = (UInt16)FirstVertex+1;
            *pcurIndex++ = (UInt16)FirstVertex+(HMA_GridSize+1)+1;
            *pcurIndex++ = (UInt16)FirstVertex+(HMA_GridSize+1);
        }
    }
}

//-----------------------------------------------------------------------------------
// ***** Prediction and timewarp.
//

// Calculates the values from the HMD info.
PredictionValues PredictionGetDeviceValues ( const HmdRenderInfo &hmdRenderInfo,
                                             bool withTimewarp /*= true*/,
                                             bool withVsync /*= true*/ )
{
    PredictionValues result;

    result.WithTimewarp = withTimewarp;
    result.WithVsync = withVsync;

    // For unclear reasons, most graphics systems add an extra frame of latency
    // somewhere along the way. In time we'll debug this and figure it out, but
    // for now this gets prediction a little bit better.
    const float extraFramesOfBufferingKludge = 1.0f;

    if ( withVsync )
    {
        // These are the times from the Present+Flush to when the middle of the scene is ""averagely visible"" (without timewarp)
        // So if you had no timewarp, this, plus the time until the next vsync, is how much to predict by.
        result.PresentFlushToRenderedScene  = extraFramesOfBufferingKludge * hmdRenderInfo.Shutter.FirstScanlineToLastScanline;
        // Predict to the middle of the screen being scanned out.
        result.PresentFlushToRenderedScene += hmdRenderInfo.Shutter.VsyncToFirstScanline + 0.5f * hmdRenderInfo.Shutter.FirstScanlineToLastScanline;
        // Time for pixels to get half-way to settling.
        result.PresentFlushToRenderedScene += hmdRenderInfo.Shutter.PixelSettleTime * 0.5f;
        // Predict to half-way through persistence
        result.PresentFlushToRenderedScene += hmdRenderInfo.Shutter.PixelPersistence * 0.5f;

        // The time from the Present+Flush to when the first scanline is ""averagely visible"".
        result.PresentFlushToTimewarpStart  = extraFramesOfBufferingKludge * hmdRenderInfo.Shutter.FirstScanlineToLastScanline;
        // Predict to the first line being scanned out.
        result.PresentFlushToTimewarpStart += hmdRenderInfo.Shutter.VsyncToFirstScanline;
        // Time for pixels to get half-way to settling.
        result.PresentFlushToTimewarpStart += hmdRenderInfo.Shutter.PixelSettleTime * 0.5f;
        // Predict to half-way through persistence
        result.PresentFlushToTimewarpStart += hmdRenderInfo.Shutter.PixelPersistence * 0.5f;

        // Time to the the last scanline.
        result.PresentFlushToTimewarpEnd    = result.PresentFlushToTimewarpStart + hmdRenderInfo.Shutter.FirstScanlineToLastScanline;

        // Ideal framerate.
        result.PresentFlushToPresentFlush   = hmdRenderInfo.Shutter.VsyncToNextVsync;
    }
    else
    {
        // Timewarp without vsync is a little odd.
        // Currently, we assume that without vsync, we have no idea which scanline
        // is currently being sent to the display. So we can't do lerping timewarp,
        // we can just do a full-screen late-stage fixup.

        // ""PresentFlushToRenderedScene"" means the time from the Present+Flush to when the middle of the scene is ""averagely visible"" (without timewarp)
        // So if you had no timewarp, this, plus the time until the next flush (which is usually the time to render the frame), is how much to predict by.
        // Time for pixels to get half-way to settling.
        result.PresentFlushToRenderedScene  = hmdRenderInfo.Shutter.PixelSettleTime * 0.5f;
        // Predict to half-way through persistence
        result.PresentFlushToRenderedScene += hmdRenderInfo.Shutter.PixelPersistence * 0.5f;

        // Without vsync, you don't know timings, and so can't do anything useful with lerped warping.
        result.PresentFlushToTimewarpStart  = result.PresentFlushToRenderedScene;
        result.PresentFlushToTimewarpEnd    = result.PresentFlushToRenderedScene;

        // There's no concept of ""ideal"" when vsync is off.
        result.PresentFlushToPresentFlush   = 0.0f;
    }

    return result;
}

Matrix4f TimewarpComputePoseDelta ( Matrix4f const &renderedViewFromWorld, Matrix4f const &predictedViewFromWorld, Matrix4f const&eyeViewAdjust )
{
    Matrix4f worldFromPredictedView = (eyeViewAdjust * predictedViewFromWorld).InvertedHomogeneousTransform();
    Matrix4f matRenderFromNowStart = (eyeViewAdjust * renderedViewFromWorld) * worldFromPredictedView;

    // The sensor-predicted orientations have:                           X=right, Y=up,   Z=backwards.
    // The vectors inside the mesh are in NDC to keep the shader simple: X=right, Y=down, Z=forwards.
    // So we need to perform a similarity transform on this delta matrix.
    // The verbose code would look like this:
    /*
    Matrix4f matBasisChange;
    matBasisChange.SetIdentity();
    matBasisChange.M[0][0] =  1.0f;
    matBasisChange.M[1][1] = -1.0f;
    matBasisChange.M[2][2] = -1.0f;
    Matrix4f matBasisChangeInv = matBasisChange.Inverted();
    matRenderFromNow = matBasisChangeInv * matRenderFromNow * matBasisChange;
    */
    // ...but of course all the above is a constant transform and much more easily done.
    // We flip the signs of the Y&Z row, then flip the signs of the Y&Z column,
    // and of course most of the flips cancel:
    // +++                        +--                     +--
    // +++ -> flip Y&Z columns -> +-- -> flip Y&Z rows -> -++
    // +++                        +--                     -++
    matRenderFromNowStart.M[0][1] = -matRenderFromNowStart.M[0][1];
    matRenderFromNowStart.M[0][2] = -matRenderFromNowStart.M[0][2];
    matRenderFromNowStart.M[1][0] = -matRenderFromNowStart.M[1][0];
    matRenderFromNowStart.M[2][0] = -matRenderFromNowStart.M[2][0];
    matRenderFromNowStart.M[1][3] = -matRenderFromNowStart.M[1][3];
    matRenderFromNowStart.M[2][3] = -matRenderFromNowStart.M[2][3];

    return matRenderFromNowStart;
}

Matrix4f TimewarpComputePoseDeltaPosition ( Matrix4f const &renderedViewFromWorld, Matrix4f const &predictedViewFromWorld, Matrix4f const&eyeViewAdjust )
{
    Matrix4f worldFromPredictedView = (eyeViewAdjust * predictedViewFromWorld).InvertedHomogeneousTransform();
    Matrix4f matRenderXform = (eyeViewAdjust * renderedViewFromWorld) * worldFromPredictedView;

    return matRenderXform.Inverted();
}

TimewarpMachine::TimewarpMachine()
{    
    for ( int i = 0; i < 2; i++ )
    {
        EyeRenderPoses[i] = Transformf();
    }
    DistortionTimeCount = 0;
    VsyncEnabled = false;
}

void TimewarpMachine::Reset(HmdRenderInfo& renderInfo, bool vsyncEnabled, double timeNow)
{
    RenderInfo = renderInfo;
    VsyncEnabled = vsyncEnabled;
    CurrentPredictionValues = PredictionGetDeviceValues ( renderInfo, true, VsyncEnabled );
    PresentFlushToPresentFlushSeconds = 0.0f;
    DistortionTimeCount = 0;
    DistortionTimeAverage = 0.0f;
    LastFramePresentFlushTime = timeNow;
    AfterPresentAndFlush(timeNow);
}

void TimewarpMachine::AfterPresentAndFlush(double timeNow)
{
    PresentFlushToPresentFlushSeconds = (float)(timeNow - LastFramePresentFlushTime);
    LastFramePresentFlushTime = timeNow;
    NextFramePresentFlushTime = timeNow + (double)PresentFlushToPresentFlushSeconds;
}

double TimewarpMachine::GetViewRenderPredictionTime()
{
    // Note that PredictionGetDeviceValues() did all the vsync-dependent thinking for us.
    return NextFramePresentFlushTime + CurrentPredictionValues.PresentFlushToRenderedScene;
}

Transformf TimewarpMachine::GetViewRenderPredictionPose(SensorFusion &sfusion)
{
    double predictionTime = GetViewRenderPredictionTime();
    return sfusion.GetPoseAtTime(predictionTime);
}

double TimewarpMachine::GetVisiblePixelTimeStart()
{
    // Note that PredictionGetDeviceValues() did all the vsync-dependent thinking for us.
    return NextFramePresentFlushTime + CurrentPredictionValues.PresentFlushToTimewarpStart;
}
double TimewarpMachine::GetVisiblePixelTimeEnd()
{
    // Note that PredictionGetDeviceValues() did all the vsync-dependent thinking for us.
    return NextFramePresentFlushTime + CurrentPredictionValues.PresentFlushToTimewarpEnd;
}
Transformf TimewarpMachine::GetPredictedVisiblePixelPoseStart(SensorFusion &sfusion)
{
    double predictionTime = GetVisiblePixelTimeStart();
    return sfusion.GetPoseAtTime(predictionTime);
}
Transformf TimewarpMachine::GetPredictedVisiblePixelPoseEnd  (SensorFusion &sfusion)
{
    double predictionTime = GetVisiblePixelTimeEnd();
    return sfusion.GetPoseAtTime(predictionTime);
}
Matrix4f TimewarpMachine::GetTimewarpDeltaStart(SensorFusion &sfusion, Transformf const &renderedPose)
{
    Transformf visiblePose = GetPredictedVisiblePixelPoseStart ( sfusion );
    Matrix4f visibleMatrix(visiblePose);
    Matrix4f renderedMatrix(renderedPose);
    Matrix4f identity;  // doesn't matter for orientation-only timewarp
    return TimewarpComputePoseDelta ( renderedMatrix, visibleMatrix, identity );
}
Matrix4f TimewarpMachine::GetTimewarpDeltaEnd  (SensorFusion &sfusion, Transformf const &renderedPose)
{
    Transformf visiblePose = GetPredictedVisiblePixelPoseEnd ( sfusion );
    Matrix4f visibleMatrix(visiblePose);
    Matrix4f renderedMatrix(renderedPose);
    Matrix4f identity;  // doesn't matter for orientation-only timewarp
    return TimewarpComputePoseDelta ( renderedMatrix, visibleMatrix, identity );
}


// What time should the app wait until before starting distortion?
double  TimewarpMachine::JustInTime_GetDistortionWaitUntilTime()
{
    if ( !VsyncEnabled || ( DistortionTimeCount < NumDistortionTimes ) )
    {
        // Don't wait.
        return LastFramePresentFlushTime;
    }

    const float fudgeFactor = 0.002f;      // Found heuristically - 1ms is too short because of timing granularity - may need further tweaking!
    float howLongBeforePresent = DistortionTimeAverage + fudgeFactor;
    // Subtlety here. Technically, the correct time is NextFramePresentFlushTime - howLongBeforePresent.
    // However, if the app drops a frame, this then perpetuates it,
    // i.e. if the display is running at 60fps, but the last frame was slow,
    // (e.g. because of swapping or whatever), then NextFramePresentFlushTime is
    // 33ms in the future, not 16ms. Since this function supplies the 
    // time to wait until, the app will indeed wait until 32ms, so the framerate
    // drops to 30fps and never comes back up!
    // So we return the *ideal* framerate, not the *actual* framerate.
    return LastFramePresentFlushTime + (float)( CurrentPredictionValues.PresentFlushToPresentFlush - howLongBeforePresent );
}


bool    TimewarpMachine::JustInTime_NeedDistortionTimeMeasurement() const
{
    if (!VsyncEnabled)
    {
        return false;
    }
    return ( DistortionTimeCount < NumDistortionTimes );
}

void    TimewarpMachine::JustInTime_BeforeDistortionTimeMeasurement(double timeNow)
{
    DistortionTimeCurrentStart = timeNow;
}

void    TimewarpMachine::JustInTime_AfterDistortionTimeMeasurement(double timeNow)
{
    float timeDelta = (float)( timeNow - DistortionTimeCurrentStart );
    if ( DistortionTimeCount < NumDistortionTimes )
    {
        DistortionTimes[DistortionTimeCount] = timeDelta;
        DistortionTimeCount++;
        if ( DistortionTimeCount == NumDistortionTimes )
        {
            // Median.
            float distortionTimeMedian = 0.0f;
            for ( int i = 0; i < NumDistortionTimes/2; i++ )
            {
                // Find the maximum time of those remaining.
                float maxTime = DistortionTimes[0];
                int maxIndex = 0;
                for ( int j = 1; j < NumDistortionTimes; j++ )
                {
                    if ( maxTime < DistortionTimes[j] )
                    {
                        maxTime = DistortionTimes[j];
                        maxIndex = j;
                    }
                }
                // Zero that max time, so we'll find the next-highest time.
                DistortionTimes[maxIndex] = 0.0f;
                distortionTimeMedian = maxTime;
            }
            DistortionTimeAverage = distortionTimeMedian;
        }
    }
    else
    {
        OVR_ASSERT ( !""Really didn't need more measurements, thanks"" );
    }
}


}}}  // OVR::Util::Render

",16269,False,2442.0697499666835,median
"#ifdef MATLAB_MEX_FILE
#include <mex.h>
#endif
#include ""gco-v3.0/GCoptimization.h""
#include ""gco-v3.0/LinkedBlockList.h""
#include <stdio.h>
#include <stdlib.h>
#include <vector>
#include <algorithm>

// will leave this one just for the laughs :)
//#define olga_assert(expr) assert(!(expr))

// Choose reasonably high-precision timer (sub-millisec resolution if possible).
#ifdef _WIN32
#define WIN32_LEAN_AND_MEAN
#define VC_EXTRALEAN
#define NOMINMAX
#include <windows.h>

extern ""C"" gcoclock_t GCO_CLOCKS_PER_SEC = 0;

extern ""C"" inline gcoclock_t gcoclock() // TODO: not thread safe; separate begin/end so that end doesn't have to check for query frequency
{
	gcoclock_t result = 0;
	if (GCO_CLOCKS_PER_SEC == 0)
		QueryPerformanceFrequency((LARGE_INTEGER*)&GCO_CLOCKS_PER_SEC);
	QueryPerformanceCounter((LARGE_INTEGER*)&result);
	return result;
}

#else
extern ""C"" {
gcoclock_t GCO_CLOCKS_PER_SEC = CLOCKS_PER_SEC;
}
extern ""C"" gcoclock_t gcoclock() { return clock(); }
#endif

#ifdef MATLAB_MEX_FILE
extern ""C"" bool utIsInterruptPending();
static void flushnow()
{
	// Don't flush to frequently, for overall speed.
	static gcoclock_t prevclock = 0;
	gcoclock_t now = gcoclock();
	if (now - prevclock > GCO_CLOCKS_PER_SEC/5) {
		prevclock = now;
		mexEvalString(""drawnow;"");
	}
}
#define INDEX0 1  // print 1-based label and site indices for MATLAB
#else
inline static bool utIsInterruptPending() { return false; }
static void flushnow() { }
#define INDEX0 0  // print 0-based label and site indices
#endif

// Singly-linked list helper functions; works on any struct with a 'next' member.
template <typename T>
void slist_clear(T*& head)
{
	while (head) {
		T* temp = head;
		head = head->next;
		delete temp;
	}
}

template <typename T>
void slist_prepend(T*& head, T* val)
{
	val->next = head;
	head = val;
}


void GCException::Report() 
{
	printf(""\\n%s\\n"",message);
	exit(0);
}



/////////////////////////////////////////////////////////////////////////////////////////////////
//   First we have functions for the base class
/////////////////////////////////////////////////////////////////////////////////////////////////
// Constructor for base class                                                       
GCoptimization::GCoptimization(SiteID nSites, LabelID nLabels) 
: m_num_labels(nLabels)
, m_num_sites(nSites)
, m_datacostIndividual(0)
, m_smoothcostIndividual(0)
, m_labelcostsAll(0)
, m_labelcostsByLabel(0)
, m_labelcostCount(0)
, m_smoothcostFn(0)
, m_datacostFn(0)
, m_numNeighborsTotal(0)
, m_queryActiveSitesExpansion(&GCoptimization::queryActiveSitesExpansion<DataCostFnFromArray>)
, m_setupDataCostsSwap(0)
, m_setupDataCostsExpansion(0)
, m_setupSmoothCostsSwap(0)
, m_setupSmoothCostsExpansion(0)
, m_applyNewLabeling(0)
, m_updateLabelingDataCosts(0)
, m_giveSmoothEnergyInternal(0)
, m_solveSpecialCases(&GCoptimization::solveSpecialCases<DataCostFnFromArray>)
, m_datacostFnDelete(0)
, m_smoothcostFnDelete(0)
, m_random_label_order(false)
, m_verbosity(0)
, m_labelingInfoDirty(true)
, m_lookupSiteVar(new SiteID[nSites])
, m_labeling(new LabelID[nSites])
, m_labelTable(new LabelID[nLabels])
, m_labelingDataCosts(new EnergyTermType[nSites])
, m_labelCounts(new SiteID[nLabels])
, m_activeLabelCounts(new SiteID[m_num_labels])
, m_stepsThisCycle(0)
, m_stepsThisCycleTotal(0)
{
	if ( nLabels <= 1 ) handleError(""Number of labels must be >= 2"");
	if ( nSites <= 0 )  handleError(""Number of sites must be >= 1"");
	
	if ( !m_lookupSiteVar || !m_labelTable || !m_labeling ){
		if (m_lookupSiteVar) delete [] m_lookupSiteVar;
		if (m_labelTable) delete [] m_labelTable;
		if (m_labeling) delete [] m_labeling;
		if (m_labelingDataCosts) delete [] m_labelingDataCosts;
		if (m_labelCounts) delete [] m_labelCounts;
		handleError(""Not enough memory."");
	}
	
	memset(m_labeling, 0, m_num_sites*sizeof(LabelID));
	memset(m_lookupSiteVar,-1,m_num_sites*sizeof(SiteID));
	setLabelOrder(false);
	specializeSmoothCostFunctor(SmoothCostFnPotts());
}

//-------------------------------------------------------------------

GCoptimization::~GCoptimization()
{
	delete [] m_labelTable;
	delete [] m_lookupSiteVar;
	delete [] m_labeling;
	delete [] m_labelingDataCosts;
	delete [] m_labelCounts;
	delete [] m_activeLabelCounts;

	if (m_datacostFnDelete) m_datacostFnDelete(m_datacostFn);
	if (m_smoothcostFnDelete) m_smoothcostFnDelete(m_smoothcostFn);

	if (m_datacostIndividual) delete [] m_datacostIndividual;
	if (m_smoothcostIndividual) delete [] m_smoothcostIndividual;

	// Delete label cost bookkeeping structures
	//
	slist_clear(m_labelcostsAll);
	if (m_labelcostsByLabel) {
		for ( LabelID i = 0; i < m_num_labels; ++i )
			slist_clear(m_labelcostsByLabel[i]);
		delete [] m_labelcostsByLabel;
	}
}

//-------------------------------------------------------------------

template <>
GCoptimization::SiteID GCoptimization::queryActiveSitesExpansion<GCoptimization::DataCostFnSparse>(LabelID alpha_label,SiteID *activeSites)
{
	return ((DataCostFnSparse*)m_datacostFn)->queryActiveSitesExpansion(alpha_label,m_labeling,activeSites);
}

//-------------------------------------------------------------------

template <>
void GCoptimization::setupDataCostsExpansion<GCoptimization::DataCostFnSparse>(SiteID size,LabelID alpha_label,EnergyT *e,SiteID *activeSites)
{
	DataCostFnSparse* dc = (DataCostFnSparse*)m_datacostFn;
	DataCostFnSparse::iterator dciter = dc->begin(alpha_label);
	for ( SiteID i = 0; i < size; ++i )
	{
		SiteID site = activeSites[i];
		while ( dciter.site() != site )
			++dciter;
		addterm1_checked(e,i,dciter.cost(),m_labelingDataCosts[site]);
	}
}

//-------------------------------------------------------------------

template <>
void GCoptimization::applyNewLabeling<GCoptimization::DataCostFnSparse>(EnergyT *e,SiteID *activeSites,SiteID size,LabelID alpha_label)
{
	DataCostFnSparse* dc = (DataCostFnSparse*)m_datacostFn;
	DataCostFnSparse::iterator dciter = dc->begin(alpha_label);
	for ( SiteID i = 0; i < size; i++ )
	{
		if ( e->get_var(i) == 0 )
		{
			SiteID site = activeSites[i];
			LabelID prev = m_labeling[site];
			m_labeling[site] = alpha_label;
			m_labelCounts[alpha_label]++;
			m_labelCounts[prev]--;
			while ( dciter.site() != site )
				++dciter;
			m_labelingDataCosts[site] = dciter.cost();
		}
	}
	m_labelingInfoDirty = true;
	updateLabelingInfo(false,true,false); // labels have changed, so update necessary labeling info
}

//-------------------------------------------------------------------

template <typename UserFunctor>
void GCoptimization::specializeDataCostFunctor(const UserFunctor f) {
	if ( m_datacostFnDelete )
		m_datacostFnDelete(m_datacostFn);
	if ( m_datacostIndividual )
	{
		delete [] m_datacostIndividual;
		m_datacostIndividual = 0;
	}
	m_datacostFn = new UserFunctor(f);
	m_datacostFnDelete          = &GCoptimization::deleteFunctor<UserFunctor>;
	m_queryActiveSitesExpansion = &GCoptimization::queryActiveSitesExpansion<UserFunctor>;
	m_setupDataCostsExpansion   = &GCoptimization::setupDataCostsExpansion<UserFunctor>;
	m_setupDataCostsSwap        = &GCoptimization::setupDataCostsSwap<UserFunctor>;
	m_applyNewLabeling          = &GCoptimization::applyNewLabeling<UserFunctor>;
	m_updateLabelingDataCosts   = &GCoptimization::updateLabelingDataCosts<UserFunctor>;
	m_solveSpecialCases         = &GCoptimization::solveSpecialCases<UserFunctor>;
}

template <typename UserFunctor>
void GCoptimization::specializeSmoothCostFunctor(const UserFunctor f) {
	if ( m_smoothcostFnDelete )
		m_smoothcostFnDelete(m_smoothcostFn);
	if ( m_smoothcostIndividual )
	{
		delete [] m_smoothcostIndividual;
		m_smoothcostIndividual = 0;
	}
	m_smoothcostFn = new UserFunctor(f);
	m_smoothcostFnDelete        = &GCoptimization::deleteFunctor<UserFunctor>;
	m_giveSmoothEnergyInternal  = &GCoptimization::giveSmoothEnergyInternal<UserFunctor>;
	m_setupSmoothCostsExpansion = &GCoptimization::setupSmoothCostsExpansion<UserFunctor>;
	m_setupSmoothCostsSwap      = &GCoptimization::setupSmoothCostsSwap<UserFunctor>;
}

//-------------------------------------------------------------------

template <typename SmoothCostT>
GCoptimization::EnergyType GCoptimization::giveSmoothEnergyInternal()
{
	EnergyType eng = (EnergyType) 0;
	SiteID i,numN,*nPointer,nSite,n;
	EnergyTermType *weights;
	SmoothCostT* sc = (SmoothCostT*) m_smoothcostFn;
	for ( i = 0; i < m_num_sites; i++ )
	{
		giveNeighborInfo(i,&numN,&nPointer,&weights);
		for ( n = 0; n < numN; n++ )
		{
			nSite = nPointer[n];
			if ( nSite < i ) 
				eng += weights[n]*(sc->compute(i,nSite,m_labeling[i],m_labeling[nSite]));
		}
	}

	return eng;
}

//-------------------------------------------------------------------

OLGA_INLINE void GCoptimization::addterm1_checked(EnergyT* e, VarID i, EnergyTermType e0, EnergyTermType e1)
{
	if ( e0 > GCO_MAX_ENERGYTERM || e1 > GCO_MAX_ENERGYTERM )
		handleError(""Data cost term was larger than GCO_MAX_ENERGYTERM; danger of integer overflow."");
	m_beforeExpansionEnergy += e1;
	e->add_term1(i,e0,e1);
}

OLGA_INLINE void GCoptimization::addterm1_checked(EnergyT* e, VarID i, EnergyTermType e0, EnergyTermType e1, EnergyTermType w)
{
	if ( e0 > GCO_MAX_ENERGYTERM || e1 > GCO_MAX_ENERGYTERM )
		handleError(""Smooth cost term was larger than GCO_MAX_ENERGYTERM; danger of integer overflow."");
	if ( w > GCO_MAX_ENERGYTERM )
		handleError(""Smoothness weight was larger than GCO_MAX_ENERGYTERM; danger of integer overflow."");
	m_beforeExpansionEnergy += e1*w;
	e->add_term1(i,e0*w,e1*w);
}

OLGA_INLINE void GCoptimization::addterm2_checked(EnergyT* e, VarID i, VarID j, EnergyTermType e00, EnergyTermType e01, EnergyTermType e10, EnergyTermType e11, EnergyTermType w)
{
	if ( e00 > GCO_MAX_ENERGYTERM || e11 > GCO_MAX_ENERGYTERM || e01 > GCO_MAX_ENERGYTERM || e10 > GCO_MAX_ENERGYTERM )
		handleError(""Smooth cost term was larger than GCO_MAX_ENERGYTERM; danger of integer overflow."");
	if ( w > GCO_MAX_ENERGYTERM )
		handleError(""Smoothness weight was larger than GCO_MAX_ENERGYTERM; danger of integer overflow."");
	// Inside energy/maxflow code the submodularity check is performed as an assertion,
	// but is optimized out. We check it in release builds as well.
	if ( e00+e11 > e01+e10 )
		handleError(""Non-submodular expansion term detected; smooth costs must be a metric for expansion"");
	m_beforeExpansionEnergy += e11*w;
	e->add_term2(i,j,e00*w,e01*w,e10*w,e11*w);
}

//------------------------------------------------------------------

template <typename DataCostT>
GCoptimization::SiteID GCoptimization::queryActiveSitesExpansion(LabelID alpha_label,SiteID *activeSites)
{
	SiteID size = 0;
	for ( SiteID i = 0; i < m_num_sites; i++ )
		if ( m_labeling[i] != alpha_label )
			activeSites[size++] = i;
	return size;
}

//-------------------------------------------------------------------

template <typename DataCostT>
void GCoptimization::setupDataCostsExpansion(SiteID size,LabelID alpha_label,EnergyT *e,SiteID *activeSites)
{
	DataCostT* dc = (DataCostT*)m_datacostFn;
	for ( SiteID i = 0; i < size; ++i )
		addterm1_checked(e,i,dc->compute(activeSites[i],alpha_label),m_labelingDataCosts[activeSites[i]]);
}

//-------------------------------------------------------------------

template <typename SmoothCostT>
void GCoptimization::setupSmoothCostsExpansion(SiteID size,LabelID alpha_label,EnergyT *e,SiteID *activeSites)
{
	SiteID i,nSite,site,n,nNum,*nPointer;
	EnergyTermType *weights;
	SmoothCostT* sc = (SmoothCostT*)m_smoothcostFn;

	for ( i = size - 1; i >= 0; i-- )
	{
		site = activeSites[i];
		giveNeighborInfo(site,&nNum,&nPointer,&weights);
		for ( n = 0; n < nNum; n++ )
		{
			nSite = nPointer[n];
			if ( m_lookupSiteVar[nSite] == -1 ) 
				addterm1_checked(e,i,sc->compute(site,nSite,alpha_label,m_labeling[nSite]),
				                     sc->compute(site,nSite,m_labeling[site],m_labeling[nSite]),weights[n]);
			else if ( nSite < site ) 
			{
				addterm2_checked(e,i,m_lookupSiteVar[nSite],
				                 sc->compute(site,nSite,alpha_label,alpha_label),
				                 sc->compute(site,nSite,alpha_label,m_labeling[nSite]),
				                 sc->compute(site,nSite,m_labeling[site],alpha_label),
				                 sc->compute(site,nSite,m_labeling[site],m_labeling[nSite]),weights[n]);
			}
		}
	}
}

//-----------------------------------------------------------------------------------

template <typename DataCostT>
void GCoptimization::setupDataCostsSwap(SiteID size, LabelID alpha_label, LabelID beta_label,
										 EnergyT *e,SiteID *activeSites )
{
	DataCostT* dc = (DataCostT*)m_datacostFn;
	for ( SiteID i = 0; i < size; i++ )
	{
		e->add_term1(i,dc->compute(activeSites[i],alpha_label),
		               dc->compute(activeSites[i],beta_label) );
	}
}

//-------------------------------------------------------------------

template <typename SmoothCostT>
void GCoptimization::setupSmoothCostsSwap(SiteID size, LabelID alpha_label,LabelID beta_label,
										 EnergyT *e,SiteID *activeSites )
{
	SiteID i,nSite,site,n,nNum,*nPointer;
	EnergyTermType *weights;
	SmoothCostT* sc = (SmoothCostT*)m_smoothcostFn;

	for ( i = size - 1; i >= 0; i-- )
	{
		site = activeSites[i];
		giveNeighborInfo(site,&nNum,&nPointer,&weights);
		for ( n = 0; n < nNum; n++ )
		{
			nSite = nPointer[n];
			if ( m_lookupSiteVar[nSite] == -1 )
				addterm1_checked(e,i,sc->compute(site,nSite,alpha_label,m_labeling[nSite]),
				                     sc->compute(site,nSite,beta_label, m_labeling[nSite]),weights[n]);
			else if ( nSite < site )
			{
				addterm2_checked(e,i,m_lookupSiteVar[nSite],
				                 sc->compute(site,nSite,alpha_label,alpha_label),
				                 sc->compute(site,nSite,alpha_label,beta_label),
				                 sc->compute(site,nSite,beta_label,alpha_label),
				                 sc->compute(site,nSite,beta_label,beta_label),weights[n]);
			}
		}
	}
}

//-----------------------------------------------------------------------------------

template <typename DataCostT>
void GCoptimization::applyNewLabeling(EnergyT *e,SiteID *activeSites,SiteID size,LabelID alpha_label)
{
	DataCostT* dc = (DataCostT*)m_datacostFn;
	for ( SiteID i = 0; i < size; i++ )
	{
		if ( e->get_var(i) == 0 )
		{
			SiteID site = activeSites[i];
			LabelID prev = m_labeling[site];
			m_labeling[site] = alpha_label;
			m_labelCounts[alpha_label]++;
			m_labelCounts[prev]--;
			m_labelingDataCosts[site] = dc->compute(site,alpha_label);
		}
	}
	m_labelingInfoDirty = true;
	updateLabelingInfo(false,true,false); // labels have changed, so update necessary labeling info
}

//-----------------------------------------------------------------------------------

template <typename DataCostT>
void GCoptimization::updateLabelingDataCosts()
{
	DataCostT* dc = (DataCostT*)m_datacostFn;
	for (int i = 0; i < m_num_sites; ++i)
		m_labelingDataCosts[i] = dc->compute(i,m_labeling[i]);
}

//-----------------------------------------------------------------------------------

template <typename DataCostT>
bool GCoptimization::solveSpecialCases(EnergyType& energy)
{
	finalizeNeighbors();

	DataCostT* dc = (DataCostT*)m_datacostFn;
	bool sc = m_numNeighborsTotal != 0;
	bool lc = m_labelcostsAll != 0;

	if ( !dc && !sc && !lc )
	{
		energy = 0;
		return true;
	}

	if ( dc && !sc && !lc ) {
		// Special case: No label costs, so return trivial solution
		energy = 0;
		for ( SiteID i = 0; i < m_num_sites; ++i ) {
			LabelID minCostLabel = 0;
			EnergyTermType minCost = dc->compute(i, 0);
			for ( LabelID l = 1; l < m_num_labels; ++l ) {
				EnergyTermType lcost = dc->compute(i, l);
				if ( lcost < minCost ) {
					minCostLabel = l;
					minCost = lcost;
				}
			}
			if ( minCostLabel > GCO_MAX_ENERGYTERM )
				handleError(""Data cost was larger than GCO_MAX_ENERGYTERM; danger of integer overflow."");
			m_labeling[i] = minCostLabel;
			energy += minCost;
		}
		m_labelingInfoDirty = true;
		updateLabelingInfo();
		return true;
	}

	if ( !dc && !sc && lc ) {
		// Special case: No data costs, so return trivial solution
		LabelID minLabel = 0;
		EnergyType minLabelCost = GCO_MAX_ENERGYTERM*(EnergyType)m_num_labels;
		for ( LabelID l = 0; l < m_num_labels; ++l ) {
			EnergyType lcsum = 0;
			for ( LabelCostIter* lci = m_labelcostsByLabel[l]; lci; lci = lci->next )
				lcsum += lci->node->cost;
			if ( lcsum < minLabelCost ) {
				minLabel = l;
				minLabelCost = lcsum;
			}
		}
		for ( SiteID i = 0; i < m_num_sites; ++i )
			m_labeling[i] = minLabel;
		energy = minLabelCost;
		m_labelingInfoDirty = true;
		updateLabelingInfo();
		return true;
	}

	if ( dc && !sc && lc ) {
		LabelCost* lc;
		for ( lc = m_labelcostsAll; lc; lc = lc->next )
			if ( lc->numLabels > 1)
				break;
		if ( !lc ) {
			// Special case: Data costs and per-label costs 
			energy = solveGreedy<DataCostT>();
			return true;
		}
	}

	// Otherwise, use full-blown expansion/swap
	return false;
}

template <>
class GCoptimization::GreedyIter<GCoptimization::DataCostFnSparse> {
public:
	GreedyIter(DataCostFnSparse& dc, SiteID)
	: m_dc(dc), m_label(0), m_labelend(0)
	{ }

	OLGA_INLINE void start(const LabelID* labels, LabelID labelCount=1)
	{
		m_label = labels;
		m_labelend = labels + labelCount;
		if (labelCount > 0) {
			m_site = m_dc.begin(*labels);
			m_siteend = m_dc.end(*labels);
			while (m_site == m_siteend) {
				if (++m_label == m_labelend)
					break;
				m_site     = m_dc.begin(*m_label);
				m_siteend  = m_dc.end(*m_label);
			}
		}
	}
	OLGA_INLINE SiteID site()  const { return m_site.site(); }
	OLGA_INLINE SiteID label() const { return *m_label; }
	OLGA_INLINE bool   done()  const { return m_label >= m_labelend; }
	OLGA_INLINE GreedyIter& operator++() 
	{
		// The inner loop is over sites, not labels, because sparse data costs 
		// are stored as consecutive [sparse] SiteIDs with respect to each label.
		if (++m_site == m_siteend) {
			while (++m_label < m_labelend) {
				m_site     = m_dc.begin(*m_label);
				m_siteend  = m_dc.end(*m_label);
				if (m_site != m_siteend)
					break;
			}
		}
		return *this;
	}
	OLGA_INLINE EnergyTermType compute() const { return m_site.cost(); }
	OLGA_INLINE SiteID feasibleSites() const { return (SiteID)(m_siteend - m_site); }

private:
	DataCostFnSparse::iterator m_site;
	DataCostFnSparse::iterator m_siteend;
	DataCostFnSparse& m_dc;
	const LabelID* m_label;
	const LabelID* m_labelend;
};

template <typename DataCostT>
GCoptimization::EnergyType GCoptimization::solveGreedy()
{
	printStatus1(""starting greedy algorithm (1 cycle only)"");
	m_stepsThisCycle = m_stepsThisCycleTotal = 0;

	EnergyType estart = compute_energy();
	EnergyType efinal = 0;
	LabelID* oldLabeling = m_labeling;
	m_labeling = new LabelID[m_num_sites];
	EnergyType* e = new EnergyType[m_num_labels];
	LabelID* order = new LabelID[m_num_labels];  // order[0..activeCount-1] contains the activated labels so far

	try {
		gcoclock_t ticks0all = gcoclock();
		gcoclock_t ticks0 = gcoclock();

		// clear active flags
		for ( LabelCost* lc = m_labelcostsAll; lc; lc = lc->next)
			lc->active = false;

		DataCostT* dc = (DataCostT*)m_datacostFn;
		GreedyIter<DataCostT> iter(*dc,m_num_sites);
		LabelID alpha = 0;

		// Treat first iteration as special case. 
		// Ignore current labeling and just find the greedy initial label.
		for ( LabelID l = 0; l < m_num_labels; ++l ) {
			e[l] = 0;
			for ( LabelCostIter* lci = m_labelcostsByLabel[l]; lci; lci = lci->next )
				e[l] += lci->node->cost;
			iter.start(&l);
			e[l] += (EnergyType)(m_num_sites - iter.feasibleSites()) * GCO_MAX_ENERGYTERM; // pre-add GCO_MAX_ENERGYTERM for all infeasible sites
			for (; !iter.done(); ++iter) {
				EnergyTermType dataCost = iter.compute();
				if ( dataCost > GCO_MAX_ENERGYTERM )
					handleError(""Data cost was larger than GCO_MAX_ENERGYTERM; danger of integer overflow."");
				e[l] += dataCost;
				if ( e[l] > e[alpha] ) // break out early if this will definitely 
					break;             // not be a good label to start from
			}
			if ( e[l] < e[alpha] ) // choose alpha with minimum energy e[alpha]
				alpha = l;
		}
		for ( SiteID i = 0; i < m_num_sites; ++i ) {
			m_labeling[i] = alpha;
			m_labelingDataCosts[i] = dc->compute(i,alpha);
		}
		for ( LabelCostIter* lci = m_labelcostsByLabel[alpha]; lci; lci = lci->next )
			lci->node->active = true;

		// List of labels in the order that they were expanded upon (order[0] first, order[1] second, ...)
		for ( LabelID l = 0; l < m_num_labels; ++l )
			order[l] = l;
		order[alpha] = 0;
		order[0] = alpha;

		printStatus2(alpha,-1,m_num_sites,ticks0);

		// Greedily expand remaining labels
		for ( LabelID alpha_count = 1; alpha_count <= m_num_labels; ++alpha_count) {
			checkInterrupt();
			ticks0 = gcoclock();

			// Energy e[l] for expanding on label 'l' starts at e[alpha] + new labelcosts for introducing l
			LabelID alpha_prev = alpha;
			for ( LabelID li = alpha_count; li < m_num_labels; ++li ) {
				LabelID l = order[li];
				e[l] = e[alpha_prev];
				for ( LabelCostIter* lci = m_labelcostsByLabel[l]; lci; lci = lci->next )
					if ( !lci->node->active )
						e[l] += lci->node->cost;
			}

			// Loop over all sites and all remaining labels to calculate energy drop.
			for ( iter.start(&order[alpha_count],m_num_labels-alpha_count); !iter.done(); ++iter ) {
				EnergyTermType dc_l = iter.compute();
				EnergyTermType dc_i = m_labelingDataCosts[iter.site()];
				EnergyTermType delta_i = dc_l - dc_i;
				if ( delta_i < 0 )
					e[iter.label()] += delta_i;
			}

			// Choose the next alpha based on lowest resulting energy
			LabelID alpha_index = alpha_count-1;
			for ( LabelID li = alpha_count; li < m_num_labels; ++li ) {
				LabelID l = order[li];
				if ( e[l] < e[alpha] ) {
					alpha = l;
					alpha_index = li;
				}
			}

			if ( alpha == alpha_prev )
				break;

			// Append alpha to the list of activated labels
			LabelID temp = order[alpha_count];
			order[alpha_count] = order[alpha_index];
			order[alpha_index] = temp;

			// Apply the new labeling, updating m_labelingDataCosts and active labelcosts as necessary
			iter.start(&alpha);
			SiteID size = iter.feasibleSites();
			for ( ; !iter.done(); ++iter ) {
				EnergyTermType dc_l = iter.compute();
				EnergyTermType dc_i = m_labelingDataCosts[iter.site()];
				EnergyTermType delta_i = dc_l - dc_i;
				if ( delta_i < 0 ) {
					m_labeling[iter.site()] = alpha;
					m_labelingDataCosts[iter.site()] = dc_l;
				}
			}
			for ( LabelCostIter* lci = m_labelcostsByLabel[alpha]; lci; lci = lci->next )
				lci->node->active = true;
			printStatus2(alpha,-1,size,ticks0);
		}

		efinal = e[alpha];
		if ( efinal < estart ) {
			// Greedy succeeded in lowering energy compared to initial labeling
			delete [] oldLabeling;
			m_labelingInfoDirty = true;
			updateLabelingInfo(true,false,false); // update m_labelCounts only; m_labelingDataCosts and active labelcosts should be up to date
			printStatus1(1,false,ticks0all);
		} else {
			// Greedy failed to find a lower energy, so revert everything
			efinal = estart;
			delete [] m_labeling;
			m_labeling = oldLabeling;
			m_labelingInfoDirty = true;
			updateLabelingInfo(); // put all labeling info back the way it was
			printStatus1(1,false,ticks0all);
		}

		delete [] order;
		delete [] e;
	} catch (...) {
		delete [] order;
		delete [] e;
		throw;
	}
	return efinal;
}

//------------------------------------------------------------------

void GCoptimization::setDataCost(DataCostFn fn) { 
	specializeDataCostFunctor(DataCostFnFromFunction(fn));
	m_labelingInfoDirty = true;
}


//------------------------------------------------------------------

void GCoptimization::setDataCost(DataCostFnExtra fn, void *extraData) { 
	specializeDataCostFunctor(DataCostFnFromFunctionExtra(fn, extraData));
	m_labelingInfoDirty = true;
}

//-------------------------------------------------------------------

void GCoptimization::setDataCost(EnergyTermType *dataArray) {
	specializeDataCostFunctor(DataCostFnFromArray(dataArray, m_num_labels));
	m_labelingInfoDirty = true;
}

//-------------------------------------------------------------------

void GCoptimization::setDataCost(SiteID s, LabelID l, EnergyTermType e) {
	if ( !m_datacostIndividual )
	{
		EnergyTermType* table = new EnergyTermType[m_num_sites*m_num_labels];
		memset(table, 0, m_num_sites*m_num_labels*sizeof(EnergyTermType));
		specializeDataCostFunctor(DataCostFnFromArray(table, m_num_labels));
		m_datacostIndividual = table;
		m_labelingInfoDirty = true;
	}
	m_datacostIndividual[s*m_num_labels + l] = e;
	if ( m_labeling[s] == l )
		m_labelingInfoDirty = true; // m_labelingDataCosts is dirty
}

//-------------------------------------------------------------------

void GCoptimization::setDataCostFunctor(DataCostFunctor* f) {
	if ( m_datacostFnDelete )
		m_datacostFnDelete(m_datacostFn);
	if ( m_datacostIndividual )
	{
		delete [] m_datacostIndividual;
		m_datacostIndividual = 0;
	}
	m_datacostFn = f;
	m_datacostFnDelete          = 0;
	m_queryActiveSitesExpansion = &GCoptimization::queryActiveSitesExpansion<DataCostFunctor>;
	m_setupDataCostsExpansion   = &GCoptimization::setupDataCostsExpansion<DataCostFunctor>;
	m_setupDataCostsSwap        = &GCoptimization::setupDataCostsSwap<DataCostFunctor>;
	m_applyNewLabeling          = &GCoptimization::applyNewLabeling<DataCostFunctor>;
	m_updateLabelingDataCosts   = &GCoptimization::updateLabelingDataCosts<DataCostFunctor>;
	m_solveSpecialCases         = &GCoptimization::solveSpecialCases<DataCostFunctor>;
	m_labelingInfoDirty = true;
}

//-------------------------------------------------------------------

void GCoptimization::setDataCost(LabelID l, SparseDataCost *costs, SiteID count)
{
	if ( !m_datacostFn )
		specializeDataCostFunctor(DataCostFnSparse(numSites(),numLabels()));
	else if ( m_queryActiveSitesExpansion != (SiteID (GCoptimization::*)(LabelID,SiteID*))&GCoptimization::queryActiveSitesExpansion<DataCostFnSparse> )
		handleError(""Cannot apply sparse data costs after dense data costs have been used."");
	m_labelingInfoDirty = true;
	DataCostFnSparse* dc = (DataCostFnSparse*)m_datacostFn;
	dc->set(l,costs,count);
}

//-------------------------------------------------------------------

void GCoptimization::setSmoothCost(SmoothCostFn fn) {
	specializeSmoothCostFunctor(SmoothCostFnFromFunction(fn));
}

//-------------------------------------------------------------------

void GCoptimization::setSmoothCost(SmoothCostFnExtra fn, void* extraData) {
	specializeSmoothCostFunctor(SmoothCostFnFromFunctionExtra(fn, extraData));
}

//-------------------------------------------------------------------

void GCoptimization::setSmoothCost(EnergyTermType *smoothArray) {
	specializeSmoothCostFunctor(SmoothCostFnFromArray(smoothArray, m_num_labels));
}

//-------------------------------------------------------------------

void GCoptimization::setSmoothCost(LabelID l1, LabelID l2, EnergyTermType e){
	if ( !m_smoothcostIndividual )
	{
		EnergyTermType* table = new EnergyTermType[m_num_labels*m_num_labels];
		memset(table, 0, m_num_labels*m_num_labels*sizeof(EnergyTermType));
		specializeSmoothCostFunctor(SmoothCostFnFromArray(table, m_num_labels));
		m_smoothcostIndividual = table;
	} 
	m_smoothcostIndividual[l1*m_num_labels + l2] = e;
}

//-------------------------------------------------------------------

void GCoptimization::setSmoothCostFunctor(SmoothCostFunctor* f) {
	if ( m_smoothcostFnDelete )
		m_smoothcostFnDelete(m_smoothcostFn);
	if ( m_smoothcostIndividual )
	{
		delete [] m_smoothcostIndividual;
		m_smoothcostIndividual = 0;
	}
	m_smoothcostFn = f;
	m_smoothcostFnDelete        = 0;
	m_giveSmoothEnergyInternal  = &GCoptimization::giveSmoothEnergyInternal<SmoothCostFunctor>;
	m_setupSmoothCostsExpansion = &GCoptimization::setupSmoothCostsExpansion<SmoothCostFunctor>;
	m_setupSmoothCostsSwap      = &GCoptimization::setupSmoothCostsSwap<SmoothCostFunctor>;
}

//-------------------------------------------------------------------

void GCoptimization::setLabelCost(EnergyTermType cost) 
{
	EnergyTermType* lc = new EnergyTermType[m_num_labels];
	for ( LabelID i = 0; i < m_num_labels; ++i )
		lc[i] = cost;
	setLabelCost(lc);
	delete [] lc;
}

//-------------------------------------------------------------------

void GCoptimization::setLabelCost(EnergyTermType *costArray) 
{
	for ( LabelID i = 0; i < m_num_labels; ++i )
		setLabelSubsetCost(&i, 1, costArray[i]);
}

//-------------------------------------------------------------------

void GCoptimization::setLabelSubsetCost(LabelID* labels, LabelID numLabels, EnergyTermType cost)
{
	if ( cost < 0 )
		handleError(""Label costs must be non-negative."");
	if ( cost > GCO_MAX_ENERGYTERM )
		handleError(""Label cost was larger than GCO_MAX_ENERGYTERM; danger of integer overflow."");
	for ( LabelID i = 0; i < numLabels; ++i)
		if ( labels[i] < 0 || labels[i] >= m_num_labels )
			handleError(""Invalid label id was found in label subset list."");

	if ( !m_labelcostsByLabel ) {
		m_labelcostsByLabel = new LabelCostIter*[m_num_labels];
		memset(m_labelcostsByLabel, 0, m_num_labels*sizeof(void*));
	}

	// If this particular subset already has a cost, simply replace it.
	for ( LabelCostIter* lci = m_labelcostsByLabel[labels[0]]; lci; lci = lci->next ) {
		if ( numLabels == lci->node->numLabels ) {
			if ( !memcmp(labels, lci->node->labels, numLabels*sizeof(LabelID)) ) {
				// This label subset already exists, so just update the cost and return
				lci->node->cost = cost;
				return;
			}
		}
	}
	
	if (cost == 0)
		return;

	// Create a new LabelCost entry and add it to the appropriate lists
	m_labelcostCount++;
	LabelCost* lc = new LabelCost;
	lc->cost = cost; 
	lc->active = false;
	lc->aux = -1;
	lc->numLabels = numLabels;
	lc->labels = new LabelID[numLabels];
	memcpy(lc->labels, labels, numLabels*sizeof(LabelID));
	slist_prepend(m_labelcostsAll, lc);
	for ( LabelID i = 0; i < numLabels; ++i ) {
		LabelCostIter* lci = new LabelCostIter;
		lci->node = lc; 
		slist_prepend(m_labelcostsByLabel[labels[i]], lci);
	}
}

//-------------------------------------------------------------------

void GCoptimization::whatLabel(SiteID start, SiteID count, LabelID* labeling)
{
	assert(start >= 0 && start+count <= m_num_sites);
	memcpy(labeling, m_labeling+start, count*sizeof(LabelID));
}

//-------------------------------------------------------------------

GCoptimization::EnergyType GCoptimization::giveSmoothEnergy()
{
	finalizeNeighbors();
	if ( m_giveSmoothEnergyInternal ) 
		return( (this->*m_giveSmoothEnergyInternal)());
	return 0;
}

//-------------------------------------------------------------------

GCoptimization::EnergyType GCoptimization::giveDataEnergy()
{
	updateLabelingInfo();
	EnergyType energy = 0;
	for ( SiteID i = 0; i < m_num_sites; i++ )
		energy += m_labelingDataCosts[i];
	return energy;
}

GCoptimization::EnergyType GCoptimization::giveLabelEnergy()
{
	updateLabelingInfo();
	EnergyType energy = 0;
	for ( LabelCost* lc = m_labelcostsAll; lc; lc = lc->next)
		if ( lc->active )
			energy += lc->cost;
	return energy;
}

//-------------------------------------------------------------------
 
GCoptimization::EnergyType GCoptimization::compute_energy()
{
	return giveDataEnergy() + giveSmoothEnergy() + giveLabelEnergy();
}

//-------------------------------------------------------------------

void GCoptimization::permuteLabelTable()
{
	if ( !m_random_label_order )
		return;
	for ( LabelID i = 0; i < m_num_labels; i++ )
	{
		LabelID j = i + (rand() % (m_num_labels-i));
		LabelID temp    = m_labelTable[i];
		m_labelTable[i] = m_labelTable[j];
		m_labelTable[j] = temp;
	}
}

//-------------------------------------------------------------------

GCoptimization::EnergyType GCoptimization::expansion(int max_num_iterations)
{
	EnergyType new_energy, old_energy;
	if ( (this->*m_solveSpecialCases)(new_energy) )
		return new_energy;

	permuteLabelTable();
	updateLabelingInfo();

	try 
	{
		if ( max_num_iterations == -1 )
		{
			// Strategic expansion loop focuses on labels that successfuly reduced the energy
			printStatus1(""starting alpha-expansion w/ adaptive cycles"");
			std::vector<LabelID> queueSizes;
			queueSizes.push_back(m_num_labels);

			int cycle = 1;
			LabelID next = 0;
			do
			{
				gcoclock_t ticks0 = gcoclock();
				m_stepsThisCycle = 0; 

				// Make a pass over the unchecked labels in the current queue, i.e. m_labelTable[next..queueSize-1]
				LabelID queueSize = queueSizes.back();
				LabelID start = next;
				m_stepsThisCycleTotal = queueSize - start;
				do 
				{
					if ( !alpha_expansion(m_labelTable[next]) )
						std::swap(m_labelTable[next],m_labelTable[--queueSize]); // don't put this label in a new queue
					else
						++next; // keep this label for the next (smaller) queue
					m_stepsThisCycle++;
				} while ( next < queueSize );

				if ( next == start )  // No expansion was successful, so try more labels from the previous queue
				{
					next = queueSizes.back();
					queueSizes.pop_back();
				}
				else if ( queueSize < queueSizes.back()/2 ) // Some expansions were successful, so focus on them in a new queue
				{
					next = 0;
					queueSizes.push_back(queueSize);
				}
				else
					next = 0;  // All expansions were successful, so do another complete sweep
				
				printStatus1(cycle++,false,ticks0);
			} while ( !queueSizes.empty() );
			new_energy = compute_energy();
		}
		else
		{
			// Standard expansion loop sweeps over all labels each cycle
			printStatus1(""starting alpha-expansion w/ standard cycles"");
			new_energy = compute_energy();
			old_energy = new_energy+1;
			for ( int cycle = 1; cycle <= max_num_iterations; cycle++ )
			{
				gcoclock_t ticks0 = gcoclock();
				old_energy = new_energy;
				new_energy = oneExpansionIteration();
				printStatus1(cycle,false,ticks0);
				if ( new_energy == old_energy )
					break;
				permuteLabelTable();
			}
		}
	} 
	catch (...)
	{
		m_stepsThisCycle = m_stepsThisCycleTotal = 0;
		throw;
	}
	m_stepsThisCycle = m_stepsThisCycleTotal = 0; // set so that alpha_expansion() knows it's no inside expansion() if called externally
	return new_energy;
}

//-------------------------------------------------------------------

void GCoptimization::setLabelOrder(bool isRandom)
{
	m_random_label_order = isRandom;
	for ( LabelID i = 0; i < m_num_labels; i++ )
		m_labelTable[i] = i;
}

//-------------------------------------------------------------------

void GCoptimization::setLabelOrder(const LabelID* order, LabelID size)
{
	if ( size > m_num_labels )
		handleError(""setLabelOrder receieved too many labels"");
	for ( LabelID i = 0; i < size; ++i )
		if ( order[i] < 0 || order[i] >= m_num_labels )
			handleError(""Invalid label id in setLabelOrder"");
	m_random_label_order = false;
	memcpy(m_labelTable,order,size*sizeof(LabelID));
	memset(m_labelTable+size,-1,(m_num_labels-size)*sizeof(LabelID));
}

//------------------------------------------------------------------

void GCoptimization::handleError(const char *message)
{
	throw GCException(message);
}

//------------------------------------------------------------------

void GCoptimization::checkInterrupt()
{
	if ( utIsInterruptPending() )
		throw GCException(""Interrupted."");
}


//-------------------------------------------------------------------//
//                  METHODS for EXPANSION MOVES                      //  
//-------------------------------------------------------------------//

GCoptimization::EnergyType GCoptimization::setupLabelCostsExpansion(SiteID size,LabelID alpha_label,EnergyT *e,SiteID *activeSites)
{
	EnergyType alphaCostCorrection = 0;
	if ( !m_labelcostsAll )
		return alphaCostCorrection;

	const SiteID DISABLE = -2;
	const SiteID UNINIT  = -1;
	for ( LabelCost* lc = m_labelcostsAll; lc; lc = lc->next )
		lc->aux = UNINIT;

	// Skip higher-order costs that include alpha_label or any label used
	// outside the activeSites, since they cannot be eliminated by the expansion.
	if ( m_queryActiveSitesExpansion == (SiteID (GCoptimization::*)(LabelID,SiteID*))&GCoptimization::queryActiveSitesExpansion<DataCostFnSparse> )
	{
		// For sparse data costs, things are more complicated, because we must ensure that
		// no label cost for a fixed (non-active) non-alpha label is encoded in the graph.
		memset(m_activeLabelCounts,0,m_num_labels*sizeof(SiteID));
		for ( SiteID i = 0; i < size; ++i )
			m_activeLabelCounts[m_labeling[activeSites[i]]]++;

		for ( LabelID l = 0; l < m_num_labels; ++l )
		{
			if ( m_activeLabelCounts[l] != m_labelCounts[l] )
			{
				for ( LabelCostIter* lcj = m_labelcostsByLabel[l]; lcj; lcj = lcj->next )
					lcj->node->aux = DISABLE;
			}
		}
	}
	for ( LabelCostIter* lci = m_labelcostsByLabel[alpha_label]; lci; lci = lci->next )
		lci->node->aux = DISABLE;

	// Since we're explicitly omitting the alpha_label label costs from the binary energy, 
	// calculate what it would have been, so that we can potentially reject the expansion afterwards.
	if ( !m_labelCounts[alpha_label] )
	{
		for ( LabelCostIter* lci = m_labelcostsByLabel[alpha_label]; lci; lci = lci->next )
			if ( !lci->node->active )
				alphaCostCorrection += lci->node->cost;
	}

	// Add edges to the graph, including auxiliary vertices as needed
	for ( SiteID i = 0; i < size; i++ )
	{
		LabelID label_i = m_labeling[activeSites[i]];
		for ( LabelCostIter* lci = m_labelcostsByLabel[label_i]; lci; lci = lci->next ) 
		{
			LabelCost* lc = lci->node;
			if ( lc->aux == DISABLE )
				continue;

			// Add auxiliary variable if necessary, and add pairwise potential
			if ( lc->aux == UNINIT ) 
			{
				lc->aux = e->add_variable();
				e->add_term1(lc->aux,0,lc->cost);
				m_beforeExpansionEnergy += lc->cost;
			}
			e->add_term2(i,lc->aux,0,0,lc->cost,0);
		}
	}

	return alphaCostCorrection;
}

//-------------------------------------------------------------------
void GCoptimization::updateLabelingInfo(bool updateCounts, bool updateActive, bool updateCosts)
{
	if ( !m_labelingInfoDirty )
		return;

	m_labelingInfoDirty = false;

	if ( m_labelcostsAll )
	{
		if ( updateCounts )
		{
			memset(m_labelCounts,0,m_num_labels*sizeof(SiteID));
			for ( SiteID i = 0; i < m_num_sites; ++i )
				m_labelCounts[m_labeling[i]]++;
		}

		if ( updateActive )
		{
			for ( LabelCost* lc = m_labelcostsAll; lc; lc = lc->next )
				lc->active = false;

			EnergyType energy = 0;
			for ( LabelID l = 0; l < m_num_labels; ++l ) 
				if ( m_labelCounts[l] )
					for ( LabelCostIter* lci = m_labelcostsByLabel[l]; lci; lci = lci->next ) 
						lci->node->active = true;
		}
	}

	if ( updateCosts )
	{
		if (m_updateLabelingDataCosts)
			(this->*m_updateLabelingDataCosts)();
		else
			memset(m_labelingDataCosts,0,m_num_sites*sizeof(EnergyTermType));
	}
}

//-------------------------------------------------------------------
// Sets up the binary expansion energy, optimizes it, and updates the current labeling.
//
bool GCoptimization::alpha_expansion(LabelID alpha_label)
{
	if (alpha_label < 0)
		return false; // label was disabled due to setLabelOrder on subset of labels

	finalizeNeighbors();
	gcoclock_t ticks0 = gcoclock();

	if ( m_stepsThisCycleTotal == 0 )
		m_labelingInfoDirty = true; // if not inside expansion(), assume data cost function could have changed since last expansion
	updateLabelingInfo();

	// Determine list of active sites for this expansion move
	SiteID size = 0;
	SiteID *activeSites = new SiteID[m_num_sites];
	EnergyType afterExpansionEnergy = 0;
	try 
	{
		// Get list of active sites based on alpha and current labeling
		if ( m_queryActiveSitesExpansion )
			size = (this->*m_queryActiveSitesExpansion)(alpha_label,activeSites);
		if ( size == 0 )  // Nothing to do
		{
			delete [] activeSites;
			printStatus2(alpha_label,-1,size,ticks0);
			return false;
		}

		// Initialise reverse-lookup so that non-active neighbours can be identified
		// while constructing the graph
		for ( SiteID i = 0; i < size; i++ )
			m_lookupSiteVar[activeSites[i]] = i;

		// Create binary variables for each remaining site, add the data costs,
		// and compute the smooth costs between variables.
		EnergyT e(size+m_labelcostCount, // poor guess at number of pairwise terms needed :(
				 m_numNeighborsTotal+(m_labelcostCount?size+m_labelcostCount : 0),
				 handleError);
		e.add_variable(size);
		m_beforeExpansionEnergy = 0;
		if ( m_setupDataCostsExpansion   ) (this->*m_setupDataCostsExpansion  )(size,alpha_label,&e,activeSites);
		if ( m_setupSmoothCostsExpansion ) (this->*m_setupSmoothCostsExpansion)(size,alpha_label,&e,activeSites);
		EnergyType alphaCorrection = setupLabelCostsExpansion(size,alpha_label,&e,activeSites);
		checkInterrupt();
		afterExpansionEnergy = e.minimize() + alphaCorrection;
		checkInterrupt();

		if ( afterExpansionEnergy < m_beforeExpansionEnergy )
			(this->*m_applyNewLabeling)(&e,activeSites,size,alpha_label);

		for ( SiteID i = 0; i < size; i++ )
			m_lookupSiteVar[activeSites[i]] = -1; // restore m_lookupSite to all -1s

		printStatus2(alpha_label,-1,size,ticks0);
	} 
	catch (...)
	{
		delete [] activeSites;
		throw;
	}
	delete [] activeSites;
	return afterExpansionEnergy < m_beforeExpansionEnergy;
}

//-------------------------------------------------------------------

GCoptimization::EnergyType GCoptimization::oneExpansionIteration()
{
	permuteLabelTable();
	m_stepsThisCycle = 0;
	m_stepsThisCycleTotal = m_num_labels;

	// Each cycle is exactly one pass over the labels
	for (LabelID next = 0; next < m_num_labels; next++, m_stepsThisCycle++ )
		alpha_expansion(m_labelTable[next]);

	return compute_energy();
}

//-------------------------------------------------------------------//
//                  METHODS for SWAP MOVES                           //  
//-------------------------------------------------------------------//

GCoptimization::EnergyType GCoptimization::swap(int max_num_iterations)
{
	EnergyType new_energy,old_energy;
	if ( (this->*m_solveSpecialCases)(new_energy) )
		return new_energy;
	
	new_energy = compute_energy();
	old_energy = new_energy+1;
	printStatus1(""starting alpha/beta-swap"");

	if ( max_num_iterations == -1 )
		max_num_iterations = 10000000;
	int curr_cycle = 1;
	m_stepsThisCycleTotal = (m_num_labels*(m_num_labels-1))/2;
	try
	{
		while ( old_energy > new_energy && curr_cycle <= max_num_iterations)
		{
			gcoclock_t ticks0 = gcoclock();
			old_energy = new_energy;
			new_energy = oneSwapIteration();
			printStatus1(curr_cycle,true,ticks0);
			curr_cycle++;
		}
	} 
	catch (...)
	{
		m_stepsThisCycle = m_stepsThisCycleTotal = 0;
		throw;
	}
	m_stepsThisCycle = m_stepsThisCycleTotal = 0;

	return(new_energy);
}

//--------------------------------------------------------------------------------

GCoptimization::EnergyType GCoptimization::oneSwapIteration()
{
	LabelID next,next1;
	permuteLabelTable();
	m_stepsThisCycle = 0;

	for (next = 0;  next < m_num_labels;  next++ )
		for (next1 = m_num_labels - 1;  next1 >= 0;  next1-- )
			if ( m_labelTable[next] < m_labelTable[next1] )
			{
				alpha_beta_swap(m_labelTable[next],m_labelTable[next1]); 
				m_stepsThisCycle++;
			}

	return(compute_energy());
}

//---------------------------------------------------------------------------------

void GCoptimization::alpha_beta_swap(LabelID alpha_label, LabelID beta_label)
{
	assert( alpha_label >= 0 && alpha_label < m_num_labels && beta_label >= 0 && beta_label < m_num_labels);
	if ( m_labelcostsAll )
		handleError(""Label costs only implemented for alpha-expansion."");

	finalizeNeighbors();
	gcoclock_t ticks0 = gcoclock();

	// Determine the list of active sites for this swap move
	SiteID size = 0;
	SiteID *activeSites = new SiteID[m_num_sites];
	try
	{
		for ( SiteID i = 0; i < m_num_sites; i++ )
		{
			if ( m_labeling[i] == alpha_label || m_labeling[i] == beta_label )
			{
				activeSites[size] = i;
				m_lookupSiteVar[i] = size;
				size++;
			}
		}
		if ( size == 0 )
		{
			delete [] activeSites;
			printStatus2(alpha_label,beta_label,size,ticks0);
			return;
		}

		// Create binary variables for each remaining site, add the data costs,
		// and compute the smooth costs between variables.
		EnergyT e(size,m_numNeighborsTotal,handleError);
		e.add_variable(size);
		if ( m_setupDataCostsSwap   ) (this->*m_setupDataCostsSwap  )(size,alpha_label,beta_label,&e,activeSites);
		if ( m_setupSmoothCostsSwap ) (this->*m_setupSmoothCostsSwap)(size,alpha_label,beta_label,&e,activeSites);
		checkInterrupt();
		e.minimize();
		checkInterrupt();
		
		// Apply the new labeling
		for ( SiteID i = 0; i < size; i++ )
		{
			m_labeling[activeSites[i]] = (e.get_var(i) == 0) ? alpha_label : beta_label;
			m_lookupSiteVar[activeSites[i]] = -1; // restore lookupSiteVar to all -1s
		}
		m_labelingInfoDirty = true;
	} 
	catch (...)
	{
		delete [] activeSites;
		throw;
	}
	delete [] activeSites;

	printStatus2(alpha_label,beta_label,size,ticks0);
}


//////////////////////////////////////////////////////////////////////////////////////////////////
// Functions for the GCoptimizationGridGraph, derived from GCoptimization
////////////////////////////////////////////////////////////////////////////////////////////////////

GCoptimizationGridGraph::GCoptimizationGridGraph(SiteID width, SiteID height,LabelID num_labels)
						:GCoptimization(width*height,num_labels)
{
	assert( (width > 1) && (height > 1) && (num_labels > 1 ));

	m_weightedGraph = 0;
	for (int  i = 0; i < 4; i ++ )	m_unityWeights[i] = 1;

	m_width  = width;
	m_height = height;

	m_numNeighbors = new SiteID[m_num_sites];
	m_neighbors = new SiteID[4*m_num_sites];

	SiteID indexes[4] = {-1,1,-m_width,m_width};

	SiteID indexesL[3] = {1,-m_width,m_width};
	SiteID indexesR[3] = {-1,-m_width,m_width};
	SiteID indexesU[3] = {1,-1,m_width};
	SiteID indexesD[3] = {1,-1,-m_width};

	SiteID indexesUL[2] = {1,m_width};
	SiteID indexesUR[2] = {-1,m_width};
	SiteID indexesDL[2] = {1,-m_width};
	SiteID indexesDR[2] = {-1,-m_width};

	setupNeighbData(1,m_height-1,1,m_width-1,4,indexes);

	setupNeighbData(1,m_height-1,0,1,3,indexesL);
	setupNeighbData(1,m_height-1,m_width-1,m_width,3,indexesR);
	setupNeighbData(0,1,1,width-1,3,indexesU);
	setupNeighbData(m_height-1,m_height,1,m_width-1,3,indexesD);

	setupNeighbData(0,1,0,1,2,indexesUL);
	setupNeighbData(0,1,m_width-1,m_width,2,indexesUR);
	setupNeighbData(m_height-1,m_height,0,1,2,indexesDL);
	setupNeighbData(m_height-1,m_height,m_width-1,m_width,2,indexesDR);
}

//-------------------------------------------------------------------

GCoptimizationGridGraph::~GCoptimizationGridGraph()
{
	delete [] m_numNeighbors;
	if ( m_neighbors )
		delete [] m_neighbors;
	if (m_weightedGraph) delete [] m_neighborsWeights;
}


//-------------------------------------------------------------------

void GCoptimizationGridGraph::setupNeighbData(SiteID startY,SiteID endY,SiteID startX,
											  SiteID endX,SiteID maxInd,SiteID *indexes)
{
	SiteID x,y,pix;
	SiteID n;

	for ( y = startY; y < endY; y++ )
		for ( x = startX; x < endX; x++ )
		{
			pix = x+y*m_width;
			m_numNeighbors[pix] = maxInd;
			m_numNeighborsTotal += maxInd;

			for (n = 0; n < maxInd; n++ )
				m_neighbors[pix*4+n] = pix+indexes[n];
		}
}

//-------------------------------------------------------------------

void GCoptimizationGridGraph::finalizeNeighbors()
{
}

//-------------------------------------------------------------------

void GCoptimizationGridGraph::setSmoothCostVH(EnergyTermType *smoothArray, EnergyTermType *vCosts, EnergyTermType *hCosts)
{
	setSmoothCost(smoothArray);
	m_weightedGraph = 1;
	computeNeighborWeights(vCosts,hCosts);
}

//-------------------------------------------------------------------

void GCoptimizationGridGraph::giveNeighborInfo(SiteID site, SiteID *numSites, SiteID **neighbors, EnergyTermType **weights)
{
	*numSites  = m_numNeighbors[site];
	*neighbors = &m_neighbors[site*4];
	
	if (m_weightedGraph) *weights  = &m_neighborsWeights[site*4];
	else *weights = m_unityWeights;
}

//-------------------------------------------------------------------

void GCoptimizationGridGraph::computeNeighborWeights(EnergyTermType *vCosts,EnergyTermType *hCosts)
{
	SiteID i,n,nSite;
	GCoptimization::EnergyTermType weight;
	
	m_neighborsWeights = new EnergyTermType[m_num_sites*4];

	for ( i = 0; i < m_num_sites; i++ )
	{
		for ( n = 0; n < m_numNeighbors[i]; n++ )
		{
			nSite = m_neighbors[4*i+n];
			if ( i-nSite == 1 )            weight = hCosts[nSite];
			else if (i-nSite == -1 )       weight = hCosts[i];
			else if ( i-nSite == m_width ) weight = vCosts[nSite];
			else if (i-nSite == -m_width ) weight = vCosts[i];
	
			m_neighborsWeights[i*4+n] = weight;
		}
	}

}
////////////////////////////////////////////////////////////////////////////////////////////////
// Functions for the GCoptimizationGeneralGraph, derived from GCoptimization
////////////////////////////////////////////////////////////////////////////////////////////////////

GCoptimizationGeneralGraph::GCoptimizationGeneralGraph(SiteID num_sites,LabelID num_labels):GCoptimization(num_sites,num_labels)
{
	assert( num_sites > 1 && num_labels > 1 );

	m_neighborsIndexes = 0;
	m_neighborsWeights = 0;
	m_numNeighbors     = 0;
	m_neighbors        = 0;

	m_needTodeleteNeighbors        = true;
	m_needToFinishSettingNeighbors = true;
}

//------------------------------------------------------------------

GCoptimizationGeneralGraph::~GCoptimizationGeneralGraph()
{
		
	if ( m_neighbors )
		delete [] m_neighbors;

	if ( m_numNeighbors && m_needTodeleteNeighbors )
	{
		for ( SiteID i = 0; i < m_num_sites; i++ )
		{
			if (m_numNeighbors[i] != 0 )
			{
				delete [] m_neighborsIndexes[i];
				delete [] m_neighborsWeights[i];
			}
		}

		delete [] m_numNeighbors;
		delete [] m_neighborsIndexes;
		delete [] m_neighborsWeights;
	}
}

//------------------------------------------------------------------

void GCoptimizationGeneralGraph::finalizeNeighbors()
{
	if ( !m_needToFinishSettingNeighbors )
		return;
	m_needToFinishSettingNeighbors = false;

	Neighbor *tmp;
	SiteID i,site,count;

	EnergyTermType *tempWeights = new EnergyTermType[m_num_sites];
	SiteID *tempIndexes         = new SiteID[m_num_sites];
	
	if ( !tempWeights || !tempIndexes ) handleError(""Not enough memory"");

	m_numNeighbors     = new SiteID[m_num_sites];
	m_neighborsIndexes = new SiteID*[m_num_sites];
	m_neighborsWeights = new EnergyTermType*[m_num_sites];
	
	if ( !m_numNeighbors || !m_neighborsIndexes || !m_neighborsWeights ) handleError(""Not enough memory."");

	for ( site = 0; site < m_num_sites; site++ )
	{
		if ( m_neighbors && !m_neighbors[site].isEmpty() )
		{
			m_neighbors[site].setCursorFront();
			count = 0;
			
			while ( m_neighbors[site].hasNext() )
			{
				tmp = (Neighbor *) (m_neighbors[site].next());
				tempIndexes[count] =  tmp->to_node;
				tempWeights[count] =  tmp->weight;
				delete tmp;
				count++;
			}
			m_numNeighbors[site]     = count;
			m_numNeighborsTotal     += count;
			m_neighborsIndexes[site] = new SiteID[count];
			m_neighborsWeights[site] = new EnergyTermType[count];
			
			if ( !m_neighborsIndexes[site] || !m_neighborsWeights[site] ) handleError(""Not enough memory."");
			
			for ( i = 0; i < count; i++ )
			{
				m_neighborsIndexes[site][i] = tempIndexes[i];
				m_neighborsWeights[site][i] = tempWeights[i];
			}
		}
		else m_numNeighbors[site] = 0;

	}

	delete [] tempIndexes;
	delete [] tempWeights;
	if (m_neighbors) {
		delete [] m_neighbors;
		m_neighbors = 0;
	}
}
//------------------------------------------------------------------------------

void GCoptimizationGeneralGraph::giveNeighborInfo(SiteID site, SiteID *numSites, 
												  SiteID **neighbors, EnergyTermType **weights)
{
	if (m_numNeighbors) {
		(*numSites)  =  m_numNeighbors[site];
		(*neighbors) = m_neighborsIndexes[site];
		(*weights)   = m_neighborsWeights[site];
	} else {
		*numSites = 0;
		*neighbors = 0;
		*weights = 0;
	}
}


//------------------------------------------------------------------

void GCoptimizationGeneralGraph::setNeighbors(SiteID site1, SiteID site2, EnergyTermType weight)
{

	assert( site1 < m_num_sites && site1 >= 0 && site2 < m_num_sites && site2 >= 0);
	if ( m_needToFinishSettingNeighbors == false )
		handleError(""Already set up neighborhood system."");

	if ( !m_neighbors )
	{
		m_neighbors = (LinkedBlockList *) new LinkedBlockList[m_num_sites];
		if ( !m_neighbors ) handleError(""Not enough memory."");
	}

	Neighbor *temp1 = (Neighbor *) new Neighbor;
	Neighbor *temp2 = (Neighbor *) new Neighbor;

	temp1->weight  = weight;
	temp1->to_node = site2;

	temp2->weight  = weight;
	temp2->to_node = site1;

	m_neighbors[site1].addFront(temp1);
	m_neighbors[site2].addFront(temp2);
	
}
//------------------------------------------------------------------

void GCoptimizationGeneralGraph::setAllNeighbors(SiteID *numNeighbors,SiteID **neighborsIndexes,
												 EnergyTermType **neighborsWeights)
{
	m_needTodeleteNeighbors = false;
	m_needToFinishSettingNeighbors = false;
	if ( m_numNeighborsTotal > 0 )
		handleError(""Already set up neighborhood system."");
	m_numNeighbors     = numNeighbors;
	m_numNeighborsTotal = 0;
	for (int site = 0; site < m_num_sites; site++ ) m_numNeighborsTotal += m_numNeighbors[site];
	m_neighborsIndexes = neighborsIndexes;
	m_neighborsWeights = neighborsWeights;
}



//------------------------------------------------------------------
// boring status messages

void GCoptimization::printStatus1(const char* extraMsg)
{
	if ( m_verbosity < 1 )
		return;
	if ( extraMsg )
		printf(""gco>> %s\\n"",extraMsg);
	printf(""gco>> initial energy: \\tE=%lld (E=%lld+%lld+%lld)\\n"",(long long)compute_energy(),
		(long long)giveDataEnergy(), (long long)giveSmoothEnergy(), (long long)giveLabelEnergy()); 
	flushnow(); 
}

void GCoptimization::printStatus1(int cycle, bool isSwap, gcoclock_t ticks0)
{
	if ( m_verbosity < 1 )
		return;
	gcoclock_t ticks1 = gcoclock();
	printf(""gco>> after cycle %2d: \\tE=%lld (E=%lld+%lld+%lld);"",cycle,(long long)compute_energy(),
		(long long)giveDataEnergy(),(long long)giveSmoothEnergy(),(long long)giveLabelEnergy());
	if ( m_stepsThisCycleTotal > 0 )
		printf(isSwap ? "" \\t%d swaps(s);"" : "" \\t%d expansions(s);"",m_stepsThisCycleTotal);
	if ( m_verbosity == 1 )
	{
		// Don't print time if time is already printed at finer scale, since printing
		// itself takes time (esp in MATLAB) and makes time useless at this level
		int ms = (int)(1000*(ticks1 - ticks0) / GCO_CLOCKS_PER_SEC);
		printf("" \\t%d ms"",ms);
	}
	printf(""\\n"");
	flushnow(); 
}

void GCoptimization::printStatus2(int alpha, int beta, int numVars, gcoclock_t ticks0)
{
	if ( m_verbosity < 2 )
		return;
	int microsec = (int)(1000000*(gcoclock() - ticks0) / GCO_CLOCKS_PER_SEC);
	if ( beta >= 0 )
		printf(""gco>>   after swap(%d,%d):"",alpha+INDEX0,beta+INDEX0);
	else
		printf(""gco>>   after expansion(%d):"",alpha+INDEX0);
	printf("" \\tE=%lld (E=%lld+%lld+%lld);\\t %lld vars;"",
		(long long)compute_energy(),(long long)giveDataEnergy(),
		(long long)giveSmoothEnergy(),(long long)giveLabelEnergy(),(long long)numVars);
	if ( m_stepsThisCycleTotal > 0 )
		printf("" \\t(%d of %d);"",m_stepsThisCycle+1,m_stepsThisCycleTotal);

	printf(microsec > 100 ? ""\\t %.2f ms\\n"" : ""\\t %.3f ms\\n"",(double)microsec/1000.0);
	flushnow();
}




//-------------------------------------------------------------------
// DataCostFnSparse methods
//-------------------------------------------------------------------


GCoptimization::DataCostFnSparse::DataCostFnSparse(SiteID num_sites, LabelID num_labels)
: m_num_sites(num_sites)
, m_num_labels(num_labels)
, m_buckets_per_label((m_num_sites + cSitesPerBucket-1)/cSitesPerBucket)
, m_buckets(0)
{
}

GCoptimization::DataCostFnSparse::DataCostFnSparse(const DataCostFnSparse& src)
: m_num_sites(src.m_num_sites)
, m_num_labels(src.m_num_labels)
, m_buckets_per_label(src.m_buckets_per_label)
, m_buckets(0)
{
	assert(!src.m_buckets); // not implemented
}

GCoptimization::DataCostFnSparse::~DataCostFnSparse()
{
	if (m_buckets) {
		for (LabelID l = 0; l < m_num_labels; ++l)
			if (m_buckets[l*m_buckets_per_label].begin)
				delete [] m_buckets[l*m_buckets_per_label].begin;
		delete [] m_buckets;
	}
}

void GCoptimization::DataCostFnSparse::set(LabelID l, const SparseDataCost* costs, SiteID count)
{
	// Create the bucket if necessary, and copy all the costs
	//
	if (!m_buckets) {
		m_buckets = new DataCostBucket[m_num_labels*m_buckets_per_label];
		memset(m_buckets, 0, m_num_labels*m_buckets_per_label*sizeof(DataCostBucket));
	}

	DataCostBucket* b = &m_buckets[l*m_buckets_per_label];
	if (b->begin)
		delete [] b->begin;
	SparseDataCost* next = new SparseDataCost[count];
	memcpy(next,costs,count*sizeof(SparseDataCost));

	//
	// Scan the list of costs and remember pointers to delimit the 'buckets', i.e. where 
	// ranges of SiteIDs lie along the array. Buckets can be empty (begin == end).
	//
	const SparseDataCost* end  = next+count;
	SiteID prev_site = -1;
	for (int i = 0; i < m_buckets_per_label; ++i) {
		b[i].begin = b[i].predict = next;
		SiteID end_site = (i+1)*cSitesPerBucket;
		while (next < end && next->site < end_site) {
			if (next->site < 0 || next->site >= m_num_sites)
				throw GCException(""Invalid site id given for sparse data cost; must be within range."");
			if (next->site <= prev_site)
				throw GCException(""Sparse data costs must be sorted in increasing order of SiteID"");
			prev_site = next->site;
			++next;
		}
		b[i].end = next;
	}
}

GCoptimization::EnergyTermType GCoptimization::DataCostFnSparse::search(DataCostBucket& b, SiteID s)
{
	// Perform binary search for requested SiteID
	//
	const SparseDataCost* L = b.begin;
	const SparseDataCost* R = b.end-1;
	if ( R - L == m_num_sites )
		return b.begin[s].cost; // special case: this particular label is actually dense
	do {
		const SparseDataCost* mid = (const SparseDataCost*)((((size_t)L+(size_t)R) >> 1) & cDataCostPtrMask);
		if (s < mid->site)
			R = mid-1;         // eliminate upper range
		else if (mid->site < s)
			L = mid+1;         // eliminate lower range
		else {
			b.predict = mid+1;
			return mid->cost;  // found it!
		}
	} while (R - L > cLinearSearchSize);
	
	// Finish off with linear search over the remaining elements
	//
	do {
		if (L->site >= s) {
			if (L->site == s) {
				b.predict = L+1;
				return L->cost;
			}
			break;
		}
	} while (++L <= R);
	b.predict = L;

	return GCO_MAX_ENERGYTERM; // the site belongs to this bucket but with no cost specified
}

OLGA_INLINE GCoptimization::EnergyTermType GCoptimization::DataCostFnSparse::compute(SiteID s, LabelID l)
{
	DataCostBucket& b = m_buckets[l*m_buckets_per_label + (s >> cLogSitesPerBucket)];
	if (b.begin == b.end)
		return GCO_MAX_ENERGYTERM;
	if (b.predict < b.end) {
		// Check for correct prediction
		if (b.predict->site == s)
			return (b.predict++)->cost; // predict++ for next time
		
		// If the requested site is missing from the site ids near 'predict'
		// then we know it doesn't exist in the bucket, so return INF
		if (b.predict->site > s && b.predict > b.begin && (b.predict-1)->site < s)
			return GCO_MAX_ENERGYTERM;
	}
	if ( (size_t)b.end - (size_t)b.begin == cSitesPerBucket*sizeof(SparseDataCost) )
		return b.begin[s-b.begin->site].cost; // special case: this particular bucket is actually dense!

	return search(b,s);
}

GCoptimization::SiteID GCoptimization::DataCostFnSparse::queryActiveSitesExpansion(LabelID alpha_label, const LabelID* labeling, SiteID* activeSites)
{
	const SparseDataCost* next = m_buckets[alpha_label*m_buckets_per_label].begin;
	const SparseDataCost* end  = m_buckets[alpha_label*m_buckets_per_label + m_buckets_per_label-1].end;
	SiteID count = 0;
	for (; next < end; ++next) {
		if ( labeling[next->site] != alpha_label )
			activeSites[count++] = next->site;
	}
	return count;
}

",16193,True,2907.9804843861416,median
":sectnums:
= Groovy 开发包
:hp-tags: Groovy dev


.原文
http://www.groovy-lang.org/groovy-dev-kit.html

==== Working with IO

Groovy 提供了大量的辅助方法用于 IO 处理。你可以使用标准的 JAVA 代码在 Groovy 中处理这些问题，Groovy 也提供了很多便利的方法处理文件，流，reader 等等

特别可以可以看一下，下面类中添加的方法：

- the `java.io.File class` : http://docs.groovy-lang.org/latest/html/groovy-jdk/java/io/File.html
- the `java.io.InputStream` class: http://docs.groovy-lang.org/latest/html/groovy-jdk/java/io/InputStream.html
- the `java.io.OutputStream` class: http://docs.groovy-lang.org/latest/html/groovy-jdk/java/io/OutputStream.html
- the `java.io.Reader` class: http://docs.groovy-lang.org/latest/html/groovy-jdk/java/io/Reader.html
- the `java.io.Writer` class: http://docs.groovy-lang.org/latest/html/groovy-jdk/java/io/Writer.html
- the `java.nio.file.Path` class: http://docs.groovy-lang.org/latest/html/groovy-jdk/java/nio/file/Path.html

下面章节将主要介绍这些辅助方法使用的范例，但并不全面，如果需要了解更全面的内容，可以查看 http://groovy-lang.org/gdk.html[GDK API]

===== 读取文件

第一个实例，看看如何打印出文件中的每行内容：
[source]
----
new File(baseDir, 'haiku.txt').eachLine { line ->
    println line
}
----

方法 eachLine 是由 Groovy 自动加入 File 类中。
如果你希望知道行号，可以使用下面方法：

[source]
new File(baseDir, 'haiku.txt').eachLine { line, nb ->
    println ""Line $nb: $line""
}

如果有情况在 eachLine 方法中抛出异常，这方法将会确保资源是被合理关闭。Groovy 针对所有的 IO 处理都会遵循此中方式。

在一定条件下，我们使用 Reader ，同样也会感受到 Groovy 对资源自动化管理的好处。
下面的实例，将演示在异常发生时，reader 也将会被关闭。
[source]
def count = 0, MAXSIZE = 3
new File(baseDir,""haiku.txt"").withReader { reader ->
    while (reader.readLine()) {
        if (++count > MAXSIZE) {
            throw new RuntimeException('Haiku should only have 3 verses')
        }
    }
}

如果你希望将每一行内容存入 list， 你可以这么办：

[source]
def list = new File(baseDir, 'haiku.txt').collect {it}

或者你可以通过 `as` 操作符将内容转化为数组：
[source]
def array = new File(baseDir, 'haiku.txt') as String[]

将文件内容写入 byte[] 将要写多少代码？

Groovy 让这一切变的如此简单：

[source]
byte[] contents = file.bytes

使用 IO 不仅仅在处理文件。事实上，大量的操作依靠输入输出流，这也是 Groovy 增加了大量方法支持其，可以查看http://docs.groovy-lang.org/latest/html/groovy-jdk/java/io/InputStream.html[文档]
在下面的例子中，你可以很容易从文件中的获取 InputStream :
[source]
def is = new File(baseDir,'haiku.txt').newInputStream()
// do something ...
is.close()

然而你会看到，这样处理你将不得不去执行关闭 inputstream 。在 Groovy 中有更好的办法，使用 withInputStream 来帮助你处理这一切：
[source]
new File(baseDir,'haiku.txt').withInputStream { stream ->
    // do something ...
}


===== 写文件
当然在一些情况下，我们不仅仅要读文件，也需要来写文件。
我们有一个选择就是使用 Writer：
[source]
new File(baseDir,'haiku.txt').withWriter('utf-8') { writer ->
    writer.writeLine 'Into the ancient pond'
    writer.writeLine 'A frog jumps'
    writer.writeLine 'Water’s sound!'
}

但或者还有更简单的方法，使用 `<<` 操作符就可以满足需求：
[source]
new File(baseDir,'haiku.txt') << '''Into the ancient pond
A frog jumps
Water’s sound!'''

通常我们并不处理文本内容，所以你可以使用 Writer 或直接将字节写入，如：
[source]
file.bytes = [66,22,11]

你也可以直接操作输出流，向下面这样：
[source]
def os = new File(baseDir,'data.bin').newOutputStream()
// do something ...
os.close()

当然你同样看到这里的操作，还是需要关闭输出流。同样我们可以使用 withOutputStream 来更优雅的处理关闭与异常：
[source]
new File(baseDir,'data.bin').withOutputStream { stream ->
    // do something ...
}

===== 遍历文件树

在脚本中，遍历文件树，找到指定的文件并处理是比较常见的任务。Groovy 提供了多种方法进行处理。
列出文件目录下的所有文件：
[source]
----
dir.eachFile { file ->   <1>
    println file.name
}
dir.eachFileMatch(~/.*\\.txt/) { file ->  <2>
    println file.name
}
----
<1> 目录中找到的文件，执行闭包中代码
<2> 目录中满足条件文件，执行闭包中代码

通常情况下，你需要处理更深层次的文件，这种情况下可以使用 eachFileRecurse:
[source]
dir.eachFileRecurse { file ->   <1>
    println file.name
}

dir.eachFileRecurse(FileType.FILES) { file -> <2>
    println file.name
}

<1> 目录中递归查找到文件或目录后执行闭包中代码
<2> 目录中递归查找到文件后执行闭包中代码

对于更复杂的遍历技术你可以使用 `traverse` 方法，在这里需要你按指定遍历需求，进行相应的配置：
[source]
----
dir.traverse { file ->
    if (file.directory && file.name=='bin') {
        FileVisitResult.TERMINATE		<1>
    } else {
        println file.name
        FileVisitResult.CONTINUE  		<2>
    }

}
----
<1> 如果当前文件为目录并且被命名为 bin ， 将停止便利
<2>	否则打印文件名，继续遍历

===== Data & objects
在 JAVA 中通常使用 java.io.DataOutputStream & java.io.DataInputStream 来做对象的序列化与反序列化。
在 Groovy 中的使用将更加简单。
看看下面的例子，你可以使用下面代码将数据序列化至文件中，并在将其反序列化：
[source]
----
boolean b = true
String message = 'Hello from Groovy'
// Serialize data into a file
file.withDataOutputStream { out ->
    out.writeBoolean(b)
    out.writeUTF(message)
}
// ...
// Then read it back
file.withDataInputStream { input ->
    assert input.readBoolean() == b
    assert input.readUTF() == message
}
----

如果你数据对象实现 Serializable 接口，你可以使用下面关于对象的输出流来处理：
[source]
----
Person p = new Person(name:'Bob', age:76)
// Serialize data into a file
file.withObjectOutputStream { out ->
    out.writeObject(p)
}
// ...
// Then read it back
file.withObjectInputStream { input ->
    def p2 = input.readObject()
    assert p2.name == p.name
    assert p2.age == p.age
}
----

===== 执行外部进程
前面章节描述了 Groovy 中文件，流，reader的处理方式。然而对于系统管理员或开发人员，他们通常都需要与系统相关进程进行交互。
Groovy 也提供了一种简单的方式来执行命令行进程。可以简单的使用一行字符串，然后调用 `exxcute()` 方法来执行。
例如：
[source]
----
def process = ""ls -l"".execute()     	<1>
println ""Found text ${process.text}""	<2>
----
<1> 执行 ls 命令
<2> 打印命令输出结果

`execute()` 返回 `java.lang.Process` 实例，其可以通过 in/out/err streams 处理，并且检查进程退出值。
与上面命令一样，这里我们会对进程返回结果数据以流方式读取，每次读取一行数据：
[source]
----
def process = ""ls -l"".execute()		<1>
process.in.eachLine { line ->		<2>
    println line 					<3>
}
----
<1>	执行命令
<2>	按行读取进程输出数据
<3>	打印数据结果

值得注意的是与输入流对应的输出流命令，你可以发送数据至进程的 `out` .

请注意很多命令都是内建于 shell 中，如果你想在 windows 系统下列出当前目录中的文件，并且怎么写：
[source]
----
def process = ""dir"".execute()
println ""${process.text}""
----

你就会收到 IOException 描述：Cannot run program ""dir"": CreateProcess error=2, The system cannot find the file specified （无法执行 dir ： CreateProcess error=2, 系统无法找到制定的文件）

这是因为 `dir` 内建于 `cmd.exe` 中，并无法单独执行。
你需要这样写：
[source]
def process = ""cmd /c dir"".execute()
println ""${process.text}""

此外， `java.lang.Process` 中也隐藏了一些功能缺陷，值得我们关注。
在 javadoc 中有如下描述：

[NOTE]
由于一些平台给输入输出流提供的缓存十分有限，从子进程中无法及时写入或读取，将导致子进程阻塞或死锁。
Because some native platforms only provide limited buffer size for standard input and output streams, failure to promptly write the input stream or read the output stream of the subprocess may cause the subprocess to block, and even deadlock


正因为如此，Groovy提供一些额外的辅助方法，这使得流处理的过程更容易。
下面代码将演示如果如何吞掉你程序的输出（包括错误输出流）：
[source]
----
def p = ""rm -f foo.tmp"".execute([], tmpDir)
p.consumeProcessOutput()
p.waitFor()
----

这里有一些 `consumeProcessOutput` 的变化，在使用 `StringBuffer`, `InputStream`, `OutputStream` 等时。
具体的例子，请查看 http://docs.groovy-lang.org/latest/html/groovy-jdk/java/lang/Process.html[GDK API for java.lang.Process]

另外，这里还有 `pipeTo` 命令，可以将进程中输出流导入到其他进程的输入流中。

参考下面例子：

.Pipes in action
[source]
----
proc1 = 'ls'.execute()
proc2 = 'tr -d o'.execute()
proc3 = 'tr -d e'.execute()
proc4 = 'tr -d i'.execute()
proc1 | proc2 | proc3 | proc4
proc4.waitFor()
if (proc4.exitValue()) {
    println proc4.err.text
} else {
    println proc4.text
}
----

.Consuming errors
[source]
----
def sout = new StringBuilder()
def serr = new StringBuilder()
proc2 = 'tr -d o'.execute()
proc3 = 'tr -d e'.execute()
proc4 = 'tr -d i'.execute()
proc4.consumeProcessOutput(sout, serr)
proc2 | proc3 | proc4
[proc2, proc3].each { it.consumeProcessErrorStream(serr) }
proc2.withWriter { writer ->
    writer << 'testfile.groovy'
}
proc4.waitForOrKill(1000)
println ""Standard output: $sout""
println ""Standard error: $serr""
----

==== Working with collections
Groovy 提供各种集合类型，包括 http://www.groovy-lang.org/groovy-dev-kit.html#Collections-Lists[lists]，http://www.groovy-lang.org/groovy-dev-kit.html#Collections-Maps[maps]，http://www.groovy-lang.org/groovy-dev-kit.html#Collections-Ranges[ranges]。
其中大部份都是以 Java 集合类型为基础，并添加了一些附加方法在 http://www.groovy-lang.org/gdk.html[Groovy 开发包]中。
Most of those are based on the Java collection types and decorated with additional methods found in the Groovy development kit.



===== Lists

====== List literals

你可以像下面那样创建 lists 。[] 用于创建空的列表。

[source]
----
def list = [5, 6, 7, 8]
assert list.get(2) == 7
assert list[2] == 7
assert list instanceof java.util.List

def emptyList = []
assert emptyList.size() == 0
emptyList.add(5)
assert emptyList.size() == 1
----


每个 list 表达式都实现了 `java.util.List`。
当让 lists 也可以用于创建新的 lists。

[source]
----
def list1 = ['a', 'b', 'c']
//construct a new list, seeded with the same items as in list1
def list2 = new ArrayList<String>(list1)

assert list2 == list1 // == checks that each corresponding element is the same

// clone() can also be called
def list3 = list1.clone()
assert list3 == list1
----

list 是有序序列对象：
[source]
----
def list = [5, 6, 7, 8]
assert list.size() == 4
assert list.getClass() == ArrayList     // the specific kind of list being used

assert list[2] == 7                     // indexing starts at 0
assert list.getAt(2) == 7               // equivalent method to subscript operator []
assert list.get(2) == 7                 // alternative method

list[2] = 9
assert list == [5, 6, 9, 8,]           // trailing comma OK

list.putAt(2, 10)                       // equivalent method to [] when value being changed
assert list == [5, 6, 10, 8]
assert list.set(2, 11) == 10            // alternative method that returns old value
assert list == [5, 6, 11, 8]

assert ['a', 1, 'a', 'a', 2.5, 2.5f, 2.5d, 'hello', 7g, null, 9 as byte]
//objects can be of different types; duplicates allowed

assert [1, 2, 3, 4, 5][-1] == 5             // use negative indices to count from the end
assert [1, 2, 3, 4, 5][-2] == 4
assert [1, 2, 3, 4, 5].getAt(-2) == 4       // getAt() available with negative index...
try {
    [1, 2, 3, 4, 5].get(-2)                 // but negative index not allowed with get()
    assert false
} catch (e) {
    assert e instanceof ArrayIndexOutOfBoundsException
}
----



====== 列表用于布尔表式

.列表返回布尔值

[source]
----
assert ![]             // an empty list evaluates as false

//all other lists, irrespective of contents, evaluate as true
assert [1] && ['a'] && [0] && [0.0] && [false] && [null]
----

====== 列表迭代器

可使用 each 和 eachWithIndex 方法，用于列表上元素的迭代操作，可参考下面代码：
[source]
----
[1, 2, 3].each {
    println ""Item: $it"" // `it` is an implicit parameter corresponding to the current element
}
['a', 'b', 'c'].eachWithIndex { it, i -> // `it` is the current element, while `i` is the index
    println ""$i: $it""
}
----

在迭代的基础上，通常需要将列表中的元素经过一定转换，构建新的列表。这种操作称为 mapping ，在 Groovy 中可以使用 `collect` 方法:

[source]
----
assert [1, 2, 3].collect { it * 2 } == [2, 4, 6]

// shortcut syntax instead of collect
assert [1, 2, 3]*.multiply(2) == [1, 2, 3].collect { it.multiply(2) }

def list = [0]
// it is possible to give `collect` the list which collects the elements
assert [1, 2, 3].collect(list) { it * 2 } == [0, 2, 4, 6]
assert list == [0, 2, 4, 6]
----


====== 操作列表

.过滤和查询
http://www.groovy-lang.org/gdk.html[Groovy 开发包]中，集合上包含了很多方法用于增强标准集合的处理，可以看下面的例子:

[source]
----
assert [1, 2, 3].find { it > 1 } == 2           // find 1st element matching criteria
assert [1, 2, 3].findAll { it > 1 } == [2, 3]   // find all elements matching critieria
assert ['a', 'b', 'c', 'd', 'e'].findIndexOf {      // find index of 1st element matching criteria
    it in ['c', 'e', 'g']
} == 2

assert ['a', 'b', 'c', 'd', 'c'].indexOf('c') == 2  // index returned
assert ['a', 'b', 'c', 'd', 'c'].indexOf('z') == -1 // index -1 means value not in list
assert ['a', 'b', 'c', 'd', 'c'].lastIndexOf('c') == 4

assert [1, 2, 3].every { it < 5 }               // returns true if all elements match the predicate
assert ![1, 2, 3].every { it < 3 }
assert [1, 2, 3].any { it > 2 }                 // returns true if any element matches the predicate
assert ![1, 2, 3].any { it > 3 }

assert [1, 2, 3, 4, 5, 6].sum() == 21                // sum anything with a plus() method
assert ['a', 'b', 'c', 'd', 'e'].sum {
    it == 'a' ? 1 : it == 'b' ? 2 : it == 'c' ? 3 : it == 'd' ? 4 : it == 'e' ? 5 : 0
    // custom value to use in sum
} == 15
assert ['a', 'b', 'c', 'd', 'e'].sum { ((char) it) - ((char) 'a') } == 10
assert ['a', 'b', 'c', 'd', 'e'].sum() == 'abcde'
assert [['a', 'b'], ['c', 'd']].sum() == ['a', 'b', 'c', 'd']

// an initial value can be provided
assert [].sum(1000) == 1000
assert [1, 2, 3].sum(1000) == 1006

assert [1, 2, 3].join('-') == '1-2-3'           // String joining
assert [1, 2, 3].inject('counting: ') {
    str, item -> str + item                     // reduce operation
} == 'counting: 123'
assert [1, 2, 3].inject(0) { count, item ->
    count + item
} == 6
----

下面是在 Groovy 代码中惯用的在集合中查找最大值与最小值的方法:
[source]
----
def list = [9, 4, 2, 10, 5]
assert list.max() == 10
assert list.min() == 2

// we can also compare single characters, as anything comparable
assert ['x', 'y', 'a', 'z'].min() == 'a'

// we can use a closure to specify the sorting behaviour
def list2 = ['abc', 'z', 'xyzuvw', 'Hello', '321']
assert list2.max { it.size() } == 'xyzuvw'
assert list2.min { it.size() } == 'z'
----

除了使用闭包，也可以使用 `Comparator` 定义比较方法：
[source]
----
Comparator mc = { a, b -> a == b ? 0 : (a < b ? -1 : 1) }

def list = [7, 4, 9, -6, -1, 11, 2, 3, -9, 5, -13]
assert list.max(mc) == 11
assert list.min(mc) == -13

Comparator mc2 = { a, b -> a == b ? 0 : (Math.abs(a) < Math.abs(b)) ? -1 : 1 }


assert list.max(mc2) == -13
assert list.min(mc2) == -1

assert list.max { a, b -> a.equals(b) ? 0 : Math.abs(a) < Math.abs(b) ? -1 : 1 } == -13
assert list.min { a, b -> a.equals(b) ? 0 : Math.abs(a) < Math.abs(b) ? -1 : 1 } == -1
----

.添加／删除列表元素
我们可以使用 `[]` 声明一个空列表并且使用 `<<` 向列表中追加元素：
[source]
----
def list = []
assert list.empty

list << 5
assert list.size() == 1

list << 7 << 'i' << 11
assert list == [5, 7, 'i', 11]

list << ['m', 'o']
assert list == [5, 7, 'i', 11, ['m', 'o']]

//first item in chain of << is target list
assert ([1, 2] << 3 << [4, 5] << 6) == [1, 2, 3, [4, 5], 6]

//using leftShift is equivalent to using <<
assert ([1, 2, 3] << 4) == ([1, 2, 3].leftShift(4))
----

你可以通过多种方式向列表中添加元素:
[source]
----
assert [1, 2] + 3 + [4, 5] + 6 == [1, 2, 3, 4, 5, 6]
// equivalent to calling the `plus` method
assert [1, 2].plus(3).plus([4, 5]).plus(6) == [1, 2, 3, 4, 5, 6]

def a = [1, 2, 3]
a += 4      // creates a new list and assigns it to `a`
a += [5, 6]
assert a == [1, 2, 3, 4, 5, 6]

assert [1, *[222, 333], 456] == [1, 222, 333, 456]
assert [*[1, 2, 3]] == [1, 2, 3]
assert [1, [2, 3, [4, 5], 6], 7, [8, 9]].flatten() == [1, 2, 3, 4, 5, 6, 7, 8, 9]

def list = [1, 2]
list.add(3)
list.addAll([5, 4])
assert list == [1, 2, 3, 5, 4]

list = [1, 2]
list.add(1, 3) // add 3 just before index 1
assert list == [1, 3, 2]

list.addAll(2, [5, 4]) //add [5,4] just before index 2
assert list == [1, 3, 5, 4, 2]

list = ['a', 'b', 'z', 'e', 'u', 'v', 'g']
list[8] = 'x' // the [] operator is growing the list as needed
// nulls inserted if required
assert list == ['a', 'b', 'z', 'e', 'u', 'v', 'g', null, 'x']
----
相比较 `<<` , `+` 操作符将创建新的 list 对象，这样的将会带来性能问题，通常会弱化这样的操作：

http://www.groovy-lang.org/gdk.html[Groovy 开发包] 也提供通过列表中的值来删除列表的方法：

[source]
----
assert ['a','b','c','b','b'] - 'c' == ['a','b','b','b']
assert ['a','b','c','b','b'] - 'b' == ['a','c']
assert ['a','b','c','b','b'] - ['b','c'] == ['a']

def list = [1,2,3,4,3,2,1]
list -= 3           // creates a new list by removing `3` from the original one
assert list == [1,2,4,2,1]
assert ( list -= [2,4] ) == [1,1]
----

也可以通过列表索引删除元素:
[source]
----
def list = [1,2,3,4,5,6,2,2,1]
assert list.remove(2) == 3          // remove the third element, and return it
assert list == [1,2,4,5,6,2,2,1]
----

如需要删除列表中与指定值相同的第一个元素，而不是所有，可以调用 `remove` 方法 ：
[source]
----
def list= ['a','b','c','b','b']
assert list.remove('c')             // remove 'c', and return true because element removed
assert list.remove('b')             // remove first 'b', and return true because element removed

assert ! list.remove('z')           // return false because no elements removed
assert list == ['a','b','b']
----

删除列表中的所有元素，可以使用 `clear` 方法：
[source]
----
def list= ['a',2,'c',4]
list.clear()
assert list == []
----

.Set operations
http://www.groovy-lang.org/gdk.html[Groovy 开发包]中有方法可以很方便的操作集合。
[source]
----
assert 'a' in ['a','b','c']             // returns true if an element belongs to the list
assert ['a','b','c'].contains('a')      // equivalent to the `contains` method in Java
assert [1,3,4].containsAll([1,4])       // `containsAll` will check that all elements are found

assert [1,2,3,3,3,3,4,5].count(3) == 4  // count the number of elements which have some value
assert [1,2,3,3,3,3,4,5].count {
    it%2==0                             // count the number of elements which match the predicate
} == 2

assert [1,2,4,6,8,10,12].intersect([1,3,6,9,12]) == [1,6,12]  //  相交

assert [1,2,3].disjoint( [4,6,9] )  // 不相交
assert ![1,2,3].disjoint( [2,4,6] )
----

.排序
使用集合类型，通常都需要进行排序。Groovy 中提供了多种列表的排序方式，包括闭包比较方式，如下面例子:
[source]
----
assert [6, 3, 9, 2, 7, 1, 5].sort() == [1, 2, 3, 5, 6, 7, 9]

def list = ['abc', 'z', 'xyzuvw', 'Hello', '321']
assert list.sort {
    it.size()
} == ['z', 'abc', '321', 'Hello', 'xyzuvw']

def list2 = [7, 4, -6, -1, 11, 2, 3, -9, 5, -13]
assert list2.sort { a, b -> a == b ? 0 : Math.abs(a) < Math.abs(b) ? -1 : 1 } ==
        [-1, 2, 3, 4, 5, -6, 7, -9, 11, -13]

Comparator mc = { a, b -> a == b ? 0 : Math.abs(a) < Math.abs(b) ? -1 : 1 }

// JDK 8+ only
// list2.sort(mc)
// assert list2 == [-1, 2, 3, 4, 5, -6, 7, -9, 11, -13]

def list3 = [6, -3, 9, 2, -7, 1, 5]

Collections.sort(list3)
assert list3 == [-7, -3, 1, 2, 5, 6, 9]

Collections.sort(list3, mc)
assert list3 == [1, 2, -3, 5, 6, -7, 9]
----

.复制元素
Groovy 开发包中也提供了操作符重载复制元素的方法：
[source]
----
assert [1, 2, 3] * 3 == [1, 2, 3, 1, 2, 3, 1, 2, 3]
assert [1, 2, 3].multiply(2) == [1, 2, 3, 1, 2, 3]
assert Collections.nCopies(3, 'b') == ['b', 'b', 'b']

// nCopies from the JDK has different semantics than multiply for lists
assert Collections.nCopies(2, [1, 2]) == [[1, 2], [1, 2]] //not [1,2,1,2]
----


===== Maps
======  Map literals
在 Groovy 中可以通过语法 `[:]` 创建 map:
[source]
----
def map = [name: 'Gromit', likes: 'cheese', id: 1234]
assert map.get('name') == 'Gromit'
assert map.get('id') == 1234
assert map['name'] == 'Gromit'
assert map['id'] == 1234
assert map instanceof java.util.Map

def emptyMap = [:]
assert emptyMap.size() == 0
emptyMap.put(""foo"", 5)
assert emptyMap.size() == 1
assert emptyMap.get(""foo"") == 5
----
Map 的 key 默认为 String 类型: [a:1] 与 ['a':1] 等价。
Map keys are strings by default: [a:1] is equivalent to ['a':1]。
如果变量名为 a ，你想用 a 的值作为 map 的 key， 这样就会出现混淆。对于这种情况，就需要添加括号，向下面代码中描述：
[source]
----
def a = 'Bob'
def ages = [a: 43]
assert ages['Bob'] == null // `Bob` is not found
assert ages['a'] == 43     // because `a` is a literal!

ages = [(a): 43]            // now we escape `a` by using parenthesis
assert ages['Bob'] == 43   // and the value is found!
----

Map 中可以通过 clone 方法获取一个新的拷贝:
[source]
----
def map = [
        simple : 123,
        complex: [a: 1, b: 2]
]
def map2 = map.clone()
assert map2.get('simple') == map.get('simple')
assert map2.get('complex') == map.get('complex')
map2.get('complex').put('c', 3)
assert map.get('complex').get('c') == 3
----
上面例子是关于 map 的浅拷贝。

====== Map property notation
Maps 可以像 beans 那样通过属性访问符，获取或设置属性值，只要 key 为 map 中有效字符：
[source]
----
def map = [name: 'Gromit', likes: 'cheese', id: 1234]
assert map.name == 'Gromit'     // can be used instead of map.get('Gromit')
assert map.id == 1234

def emptyMap = [:]
assert emptyMap.size() == 0
emptyMap.foo = 5
assert emptyMap.size() == 1
assert emptyMap.foo == 5
----
[NOTE]
`map.foo` 会在 map 中查找 key 为 foo 的值。这意味着 foo.class 将会返回 `null` ，因为在 map 中不能以 `class` 作为 key。如果需要得到这个 key 的 `class` ， 你需要使用 getClass() ：
[source]
----
def map = [name: 'Gromit', likes: 'cheese', id: 1234]
assert map.class == null
assert map.get('class') == null
assert map.getClass() == LinkedHashMap // this is probably what you want

map = [1      : 'a',
       (true) : 'p',
       (false): 'q',
       (null) : 'x',
       'null' : 'z']
assert map.containsKey(1) // 1 is not an identifier so used as is
assert map.true == null
assert map.false == null
assert map.get(true) == 'p'
assert map.get(false) == 'q'
assert map.null == 'z'
assert map.get(null) == 'x'
----

====== maps 上的迭代
在 Groovy 开发包中，惯用的迭代方法为 `each` 和 `eachWithIndex`。
值得注意的是，map 创建是有序的，如果在 map 上使用的迭代，其返回的实体顺序与加入时顺序一致。
[source]
----
def map = [
        Bob  : 42,
        Alice: 54,
        Max  : 33
]

// `entry` is a map entry
map.each { entry ->
    println ""Name: $entry.key Age: $entry.value""
}

// `entry` is a map entry, `i` the index in the map
map.eachWithIndex { entry, i ->
    println ""$i - Name: $entry.key Age: $entry.value""
}

// Alternatively you can use key and value directly
map.each { key, value ->
    println ""Name: $key Age: $value""
}

// Key, value and i as the index in the map
map.eachWithIndex { key, value, i ->
    println ""$i - Name: $key Age: $value""
}
----

====== 操作 Map

.添加／删除元素
向 map 中添加元素，可以使用 `put` ， 下标操作符或 `putAll` 方法:
[source]
----
def defaults = [1: 'a', 2: 'b', 3: 'c', 4: 'd']
def overrides = [2: 'z', 5: 'x', 13: 'x']

def result = new LinkedHashMap(defaults)
result.put(15, 't')
result[17] = 'u'
result.putAll(overrides)
assert result == [1: 'a', 2: 'z', 3: 'c', 4: 'd', 5: 'x', 13: 'x', 15: 't', 17: 'u']
----

调用 `clear` 方法可以清除 map  中的所有元素：
[source]
----
def m = [1:'a', 2:'b']
assert m.get(1) == 'a'
m.clear()
assert m == [:]
----

Maps 生成使用 object 的 equals 和 hashcode 方法。这意味着你绝不可使用 hash code 会变化的对象作为 key， 否则你将无法获取对应的值。
这里需要提到是，你绝不可使用 GString 作为 map 的 key，因为 GString 的 hash code 与 String 类型的 hash code 不一致：

[source]
----
def key = 'some key'
def map = [:]
def gstringKey = ""${key.toUpperCase()}""
map.put(gstringKey,'value')
assert map.get('SOME KEY') == null
----

.Keys, values and entries

[source]
----
def map = [1:'a', 2:'b', 3:'c']

def entries = map.entrySet()
entries.each { entry ->
  assert entry.key in [1,2,3]
  assert entry.value in ['a','b','c']
}

def keys = map.keySet()
assert keys == [1,2,3] as Set
----

Mutating values returned by the view (be it a map entry, a key or a value) is highly discouraged because success of the operation directly depends on the type of the map being manipulated. In particular, Groovy relies on collections from the JDK that in general make no guarantee that a collection can safely be manipulated through keySet, entrySet, or values.

.过滤／查询
Groovy 开发包中包括过滤，查询，收集方法与 http://www.groovy-lang.org/groovy-dev-kit.html#List-Filtering[list] 中相似：
The Groovy development kit contains filtering, searching and collecting methods similar to those found for lists:
[source]
----
def people = [
    1: [name:'Bob', age: 32, gender: 'M'],
    2: [name:'Johnny', age: 36, gender: 'M'],
    3: [name:'Claire', age: 21, gender: 'F'],
    4: [name:'Amy', age: 54, gender:'F']
]

def bob = people.find { it.value.name == 'Bob' } // find a single entry
def females = people.findAll { it.value.gender == 'F' }

// both return entries, but you can use collect to retrieve the ages for example
def ageOfBob = bob.value.age
def agesOfFemales = females.collect {
    it.value.age
}

assert ageOfBob == 32
assert agesOfFemales == [21,54]

// but you could also use a key/pair value as the parameters of the closures
def agesOfMales = people.findAll { id, person ->
    person.gender == 'M'
}.collect { id, person ->
    person.age
}
assert agesOfMales == [32, 36]

// `every` returns true if all entries match the predicate
assert people.every { id, person ->
    person.age > 18
}

// `any` returns true if any entry matches the predicate

assert people.any { id, person ->
    person.age == 54
}
----

.分组

[source]
----
assert ['a', 7, 'b', [2, 3]].groupBy {
    it.class
} == [(String)   : ['a', 'b'],
      (Integer)  : [7],
      (ArrayList): [[2, 3]]
]

assert [
        [name: 'Clark', city: 'London'], [name: 'Sharma', city: 'London'],
        [name: 'Maradona', city: 'LA'], [name: 'Zhang', city: 'HK'],
        [name: 'Ali', city: 'HK'], [name: 'Liu', city: 'HK'],
].groupBy { it.city } == [
        London: [[name: 'Clark', city: 'London'],
                 [name: 'Sharma', city: 'London']],
        LA    : [[name: 'Maradona', city: 'LA']],
        HK    : [[name: 'Zhang', city: 'HK'],
                 [name: 'Ali', city: 'HK'],
                 [name: 'Liu', city: 'HK']],
]
----


===== Ranges
`Ranges` 允许你创建连续值的列表对象。Ranges 可以像 List 一样使用，Range 继承 `java.util.List`。
`Ranges` 使用 `..` 定义闭区间。
`Ranges` 使用 `..<` 定义半开区间，其包含第一个值，不包含最后一个值。
[source]
----
// an inclusive range
def range = 5..8
assert range.size() == 4
assert range.get(2) == 7
assert range[2] == 7
assert range instanceof java.util.List
assert range.contains(5)
assert range.contains(8)

// lets use a half-open range
range = 5..<8
assert range.size() == 3
assert range.get(2) == 7
assert range[2] == 7
assert range instanceof java.util.List
assert range.contains(5)
assert !range.contains(8)

//get the end points of the range without using indexes
range = 1..10
assert range.from == 1
assert range.to == 10
----
int 型 ranges 实现十分有效，创建一个轻量的 java 对象可以包括启始值与终止值。

`Ranges` 可以在任何实现 `java.lang.Comparable` 接口的 java 对象上使用，可以通过 next() 和 previous() 方法分别返回范围中，当前数据前后的值。例如，你可以创建一个 String 有序范围:
[source]
----
// an inclusive range
def range = 'a'..'d'
assert range.size() == 4
assert range.get(2) == 'c'
assert range[2] == 'c'
assert range instanceof java.util.List
assert range.contains('a')
assert range.contains('d')
assert !range.contains('e')
----
你可使用 `for` 循环：
[source]
----
for (i in 1..10) {
    println ""Hello ${i}""
}
----

也可以使用 Groovy 中比较惯用的方式，使用 each 方法进行迭代操作：
[source]
----
(1..10).each { i ->
    println ""Hello ${i}""
}
----

Ranges 可以在 `switch` 中使用：
[source]
----
switch (years) {
    case 1..10: interestRate = 0.076; break;
    case 11..25: interestRate = 0.052; break;
    default: interestRate = 0.037;
}
----

===== 集合语法增强

====== GPath support
属性符号对 lists 和 maps 的支持， Groovy 提供了语法糖用于处理嵌套的集合对象，可参考下面例子：
[source]
----
def listOfMaps = [['a': 11, 'b': 12], ['a': 21, 'b': 22]]
assert listOfMaps.a == [11, 21] //GPath notation
assert listOfMaps*.a == [11, 21] //spread dot notation

listOfMaps = [['a': 11, 'b': 12], ['a': 21, 'b': 22], null]
assert listOfMaps*.a == [11, 21, null] // caters for null values
assert listOfMaps*.a == listOfMaps.collect { it?.a } //equivalent notation
// But this will only collect non-null values
assert listOfMaps.a == [11,21]
----

====== Spread operator

`Spread operator` 被用于集合内部的集合操作。这种语法糖可以避免使用 `putAll` ，有利于在单行内代码实现。
[source]
----
assert [ 'z': 900,
         *: ['a': 100, 'b': 200], 'a': 300] == ['a': 300, 'b': 200, 'z': 900]
//spread map notation in map definition
assert [*: [3: 3, *: [5: 5]], 7: 7] == [3: 3, 5: 5, 7: 7]

def f = { [1: 'u', 2: 'v', 3: 'w'] }
assert [*: f(), 10: 'zz'] == [1: 'u', 10: 'zz', 2: 'v', 3: 'w']
//spread map notation in function arguments
f = { map -> map.c }
assert f(*: ['a': 10, 'b': 20, 'c': 30], 'e': 50) == 30

f = { m, i, j, k -> [m, i, j, k] }
//using spread map notation with mixed unnamed and named arguments
assert f('e': 100, *[4, 5], *: ['a': 10, 'b': 20, 'c': 30], 6) ==
        [[""e"": 100, ""b"": 20, ""c"": 30, ""a"": 10], 4, 5, 6]
----

====== The star-dot `*.' operator

`*.` 操作符用于集合上所有元素调用方法或属性：
[source]
----
assert [1, 3, 5] == ['a', 'few', 'words']*.size()

class Person {
    String name
    int age
}
def persons = [new Person(name:'Hugo', age:17), new Person(name:'Sandra',age:19)]
assert [17, 19] == persons*.age
----

====== 下标操作符用于切片
你可以使用下标表达式在 lists，maps，arrays 上进行索引定位。
字符串被看作一种特殊的集合：
[source]
----
def text = 'nice cheese gromit!'
def x = text[2]

assert x == 'c'
assert x.class == String

def sub = text[5..10]
assert sub == 'cheese'

def list = [10, 11, 12, 13]
def answer = list[2,3]
assert answer == [12,13]
----

注意你可以使用 ranges 提取集合的一部分：
[source]
----
list = 100..200
sub = list[1, 3, 20..25, 33]
assert sub == [101, 103, 120, 121, 122, 123, 124, 125, 133]
----

下标操作符可以用于更新集合（集合类型为可变集合）:
[source]
----
list = ['a','x','x','d']
list[1..2] = ['b','c']
assert list == ['a','b','c','d']
----

下标可以使用负数，可以方便从集合末尾开发提取：
你可以使用负数下标从末尾计算 List ，array ， String 等
[source]
----
text = ""nice cheese gromit!""
x = text[-1]
assert x == ""!""

def name = text[-7..-2]
assert name == ""gromit""
----
你可以使用逆向范围，将集合结果进行反转。

[source]
----
text = ""nice cheese gromit!""
name = text[3..1]
assert name == ""eci""
----

===== 增强集合方法

对于 http://www.groovy-lang.org/groovy-dev-kit.html#Collections-Lists[lists] , http://www.groovy-lang.org/groovy-dev-kit.html#Collections-Maps[maps] 和 http://www.groovy-lang.org/groovy-dev-kit.html#Collections-Ranges[ranges] ， Groovy 提供了大量扩展方法用于过滤，收集，分组以及计算等等，其可以在自身上执行并且更容易使用迭代处理。

具体的内容可以阅读 http://www.groovy-lang.org/gdk.html[Groovy 开发包 API] 文档：

- methods added to Iterable can be found http://docs.groovy-lang.org/latest/html/groovy-jdk/java/lang/Iterable.html[here]
- methods added to Iterator can be found http://docs.groovy-lang.org/latest/html/groovy-jdk/java/util/Iterator.html[here]
- methods added to Collection can be found http://docs.groovy-lang.org/latest/html/groovy-jdk/java/util/Collection.html[here]
- methods added to List can be found http://docs.groovy-lang.org/latest/html/groovy-jdk/java/util/List.html[here]
- methods added to Map can be found http://docs.groovy-lang.org/latest/html/groovy-jdk/java/util/Map.html[here]


==== Handy utilities (工具集)

===== ConfigSlurper

`ConfigSlurper` 是用于读取从 Groovy script 中读取配置信息。类似于 Java 中的 `*.properties` 文件， `ConfigSlurper` 中可以使用点符号。它也可以在闭包范围内定义内容以及任何的对象类型。
[source]
----
def config = new ConfigSlurper().parse('''
    app.date = new Date()  			<1>
    app.age  = 42
    app {							<2>
        name = ""Test${42}""
    }
''')

assert config.app.date instanceof Date
assert config.app.age == 42
assert config.app.name == 'Test42'
----
<1> 使用点符号
<2> 使用闭包替代点符号

从上面的例子可以看到，`parse` 返回 `groovy.util.ConfigObject` 实例。 `ConfigObject` 实现了 `java.util.Map` 返回配置值或 `ConfigObject` 实例，但绝不会为 null.

[source]
----
def config = new ConfigSlurper().parse('''
    app.date = new Date()
    app.age  = 42
    app.name = ""Test${42}""
''')

assert config.test != null   	<1>
----
<1>  `config.test` 并没有定义，但是当其被调用时返回 `ConfigObject` 实例。

当配置中的变量名称中包含点时，可以使用单引号或双引号标注。
[source]
----
def config = new ConfigSlurper().parse('''
    app.""person.age""  = 42
''')

assert config.app.""person.age"" == 42
----

`ConfigSlurper` 可以支持按环境配置。`environments` 中包含各个环境组成，被用于闭包中。
让我们创建一个指定开发环境配置值。可以使用 `ConfigSlurper(String)` 构造方法指定目标环境。
[source]
----
def config = new ConfigSlurper('development').parse('''
  environments {
       development {
           app.port = 8080
       }

       test {
           app.port = 8082
       }

       production {
           app.port = 80
       }
  }
''')

assert config.app.port == 8080
----

`ConfigSlurper` 中的 `environments` 并没有强制指定特殊的环境名称。其可以由代码自行定义。
`environments` 是内置方法，`registerConditionalBlock` 方法可以用来注册 `environments` 以外的，其他的方法名称。
[source]
----
def slurper = new ConfigSlurper()
slurper.registerConditionalBlock('myProject', 'developers')		// <1>

def config = slurper.parse('''
  sendMail = true

  myProject {
       developers {
           sendMail = false
       }
  }
''')

assert !config.sendMail
----
<1> 向 `ConfigSlurper` 注册一个新的块

为与 Java 集成, `toProperties` 方法用于将 `ConfigObject` 转化为 `java.util.Properties` 对象，可以存储为 `*.properties` 文本文件。需要注意，配置的值将被转换为字符串类型，当将它们加入到 `Properties` 中时。

[source]
----
def config = new ConfigSlurper().parse('''
    app.date = new Date()
    app.age  = 42
    app {
        name = ""Test${42}""
    }
''')

def properties = config.toProperties()

assert properties.""app.date"" instanceof String
assert properties.""app.age"" == '42'
assert properties.""app.name"" == 'Test42'
----

`Expando` 类用于创建动态扩展对象。
每个 `Expando` 实例均为独立，动态创建的，可以在运行时动态扩展属性。
[source]
----
def expando = new Expando()
expando.name = 'John'

assert expando.name == 'John'
----

当其动态属性注册为闭包代码块，一旦调用其将按照方法调用执行。
[source]
----
def expando = new Expando()
expando.toString = { -> 'John' }
expando.say = { String s -> ""John says: ${s}"" }

assert expando as String == 'John'
assert expando.say('Hi') == 'John says: Hi'
----

====== Observable list, map and set
Groovy 中自带 lists, map, sets 的观察器。这些集合对象，在添加，删除，或修改元素时，均为触发 `java.beans.PropertyChangeEvent` 事件。
需要注意的是，其不仅仅是发送信号，还会将留存属性值的历史变化。

根据不同的操作，这些集合将触发特定的 `PropertyChangeEvent` 类型。例如，添加一个元素到集合中，将触发 `ObservableList.ElementAddedEvent` 事件。
[source]
----
def event 					// <1>
def listener = {
    if (it instanceof ObservableList.ElementEvent)  {  		//<2>
        event = it
    }
} as PropertyChangeListener


def observable = [1, 2, 3] as ObservableList 				//<3>
observable.addPropertyChangeListener(listener) 				//<4>

observable.add 42 											//<5>

assert event instanceof ObservableList.ElementAddedEvent

def elementAddedEvent = event as ObservableList.ElementAddedEvent
assert elementAddedEvent.changeType == ObservableList.ChangeType.ADDED
assert elementAddedEvent.index == 3
assert elementAddedEvent.oldValue == null
assert elementAddedEvent.newValue == 42
----

<1> 声明一个 `PropertyChangeEventListener` 用于监听触发事件
<2> `ObservableList.ElementEvent` 对于监听器事件
<3> 注册监听器
<4> 创建一个可观察列表
<5> 触发添加事件

请注意，添加一个元素会触发两个事件。第一个是 `ObservableList.ElementAddedEvent` ，第二个是 `PropertyChangeEvent`，其监听属性数量变化。
当多个元素被移除，调用 `clear()` 方法，会触发 `ObservableList.ElementClearedEvent` 类型事件，它将保留删除的所有元素。

[source]
----
def event
def listener = {
    if (it instanceof ObservableList.ElementEvent)  {
        event = it
    }
} as PropertyChangeListener


def observable = [1, 2, 3] as ObservableList
observable.addPropertyChangeListener(listener)

observable.clear()

assert event instanceof ObservableList.ElementClearedEvent

def elementClearedEvent = event as ObservableList.ElementClearedEvent
assert elementClearedEvent.values == [1, 2, 3]
assert observable.size() == 0
----


`ObservableMap` and `ObservableSet` 概念与本章节 `ObservableList` 一样。
",12113,False,2082.911010533127,median
"= EatMe 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-W11-3/main

By: `AY1920S1-CS2103T-W11-3`      Since: `Sep 2019`      Licence: `MIT`

== Setting up

Refer to the guide <<SettingUp#, here>>.

== Design

[[Design-Architecture]]
=== Architecture

.Architecture Diagram
image::ArchitectureDiagram.png[]

The *_Architecture Diagram_* given above explains the high-level design of the EatMe 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/eatme/Main.java[`Main`] and link:{repoURL}/src/main/java/seedu/eatme/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.

// tag::generalDiagrams1[]
[[Design-Ui]]
=== UI component

.Structure of the UI Component
image::UiClassDiagram.png[]

*API* : link:{repoURL}/src/main/java/seedu/eatme/ui/Ui.java[`Ui.java`]

The UI consists of a `MainWindow` that is made up of parts e.g.`CommandBox`, `ResultDisplay`, `EateryListPanel`, `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/eatme/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.
* Listens for changes to `Model` data so that the UI can be updated with the modified data.

[[Design-Logic]]
=== Logic component

[[fig-LogicClassDiagram]]
.Structure of the Logic Component
image::LogicClassDiagram.png[]

*API* :
link:{repoURL}/src/main/java/seedu/eatme/logic/Logic.java[`Logic.java`]

.  `Logic` uses the `EatMeParser` 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 an `Eatery`).
.  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.

// end::generalDiagrams1[]

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::ArchitectureSequenceDiagram.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.

// tag::generalDiagrams2[]
[[Design-Model]]
=== Model component

.Structure of the Model Component
image::ModelClassDiagram.png[]

*API* : link:{repoURL}/src/main/java/seedu/eatme/model/Model.java[`Model.java`]

The `Model`,

* stores a `UserPref` object that represents the user's preferences.
* stores a `EateryList` object that represents the data from the list of eateries in the app.
* stores the `FeedList` object that represents the data from the list of feeds in the app.
* exposes an unmodifiable `ObservableList<Eatery>` 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.
* exposes an unmodifiable `ObservableList<FeedPost>` 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

.Structure of the Storage

image::StorageClassDiagram.png[width=400]

*API* : link:{repoURL}/src/main/java/seedu/eatme/storage/Storage.java[`Storage.java`]

The `Storage` component,

* can save `UserPref` objects in json format and read it back.
* can save `EateryList` objects in json format and read it back.
* can save `FeedList` objects in json format and read it back.
// end::generalDiagrams2[]

[[Design-Commons]]
=== Common classes

Classes used by multiple components are in the `seedu.eatme.commons` package.

== Implementation

This section describes some noteworthy details on how certain features are implemented.

// tag::add[]
=== Add Eatery feature
==== Implementation

The add feature allows the user to add an eatery with the compulsory fields: `Name`, `Address`, and `Category`. The `Tag` field(s), however, is an optional field. The user can add tag(s) to the eatery later on using the `addtag` feature, if needed. The add mechanism is facilitated by `EateryList`. It implements the following operations:

* `EateryList#hasEatery()` -- Checks if an eatery with the same identity already exists in the eatery list.
* `EateryList#addEatery()` -- Adds an eatery to the eatery list. The eatery must not already exist in the eatery list.

These operations are exposed in the `Model` interface as `Model#hasEatery()` and `Model#addEatery()` respectively.

Given below is an example usage scenario and how the add mechanism behaves at each step.

Step 1. The user launches the application for the first time. The `EateryList` will be initialized with the initial json data stored.

Step 2. The user executes `add \\n Two Chefs Eating Place \\a 116 Commonwealth Cres, #01-129 \\c Chinese` to add a new eatery. Before executing the command, the command would need to be parsed first. Hence, the `EatMeParser` would create `AddCommandParser`.

[NOTE]
If the command is missing the name, address, or category (i.e. `\\n`, `\\a`, and `\\c`), `AddCommandParser` will throw an `ParserException` to the user with an error message specifying that the command parameters are incorrect, and an example usage of the command.

Step 3. `AddCommandParser` creates new objects for the different compulsory fields i.e. `Name`, `Address`, and `Category` (and also the `Tag`, if present), and passes these objects into the constructor for `Eatery` to create a new `Eatery`.

Step 4. `AddCommandParser` returns a new `AddCommand` with the newly created `Eatery` as a parameter.

Step 5. `AddCommand` calls `Model#hasEatery` to check if the eatery already exists. If it does exist, `AddCommand` will throw a CommandException specifying that there's already a duplicate eatery in `EateryList`. Else, `AddCommand` will call `Model#addEatery` to add the eatery into `EateryList`.

Step 6. After successfully adding the eatery into `EateryList`, `AddCommand` will return the `CommandResult` to the `Ui`.

The following sequence diagram shows how the add eatery feature is executed.

image:AddSequenceDiagram.png[]

The following sequence diagram shows the reference sequence diagram for creating `Eatery e`.

image:AddCreateSequenceDiagram.png[width=400]

==== Design Considerations
===== Aspect: How Add executes
* **Alternative 1 (current choice):** Making Tag field not final.
** Pros:
*** Easily implemented.
*** More user-friendly as users would most likely want to delete or add new tags.
** Cons: Does not follow the logic of the original Address Book 3 application. Hence, more code needs to be refactored.

* **Alternative 2:** Making Tag field final.
** Pros: Follows the logic of the original Address Book 3 application; don't need to refactor more code.
** Cons: Not as user-friendly.
// end::add[]

// tag::edit[]
=== Edit Eatery feature
==== Implementation
The edit feature allows the user to edit any fields from the selected eatery i.e. `Name`, `Address`, `Category`, and `Tag` field(s). This feature would replace existing `Name`, `Address`, `Category`, and `Tag` associated with the eatery, with the new ones inputted by the user. Hence, this feature is not advised for users who wants to add more tags to the current list of tags. The edit mechanism is facilitated by `EateryList`. It implements the following operations:

* `EateryList#setEatery()` -- Replaces an eatery with another eatery in the `EateryList`.

These operations are exposed in the `Model` interface as `Model#setEatery()`.

Given below is an example usage scenario and how the add mechanism behaves at each step.

Step 1. The user launches the application for the first time. The `EateryList` will be initialized with the initial json data stored.

Step 2. The user executes `edit 1 \\a 116 Commonwealth Cres, #01-140` to edit the address of an existing eatery. Before executing the command, the command would need to be parsed first. Hence, the `EatMeParser` would create `EditCommandParser`.

Step 3. `EditCommandParser` creates `EditEateryDescriptor` using the parameters specified (i.e. address, in this scenario).

Step 4. `EditCommandParser` returns a new `EditCommand` with the newly created `EditEateryDescriptor` as a parameter.

Step 5. `EditCommand` creates a new `Eatery` using the existing `Eatery` to be edited and `EditEateryDescriptor`.

Step 6. If the newly created `Eatery` is not a duplicate of the existing `Eatery`, `EditCommand` calls `Model#hasEatery` to check if the eatery exists in the list. If the eatery is a duplicate or it exists in the list, `EditCommand` will throw a CommandException specifying that there's already a duplicate eatery in `EateryList`. Else, `EditCommand` will call `Model#setEatery` to modify the eatery.

Step 7. After successfully editing the eatery, `EditCommand` will return the `CommandResult` to the `Ui`.

The following sequence diagram shows how the edit eatery feature is executed.

image:EditSequenceDiagram.png[]

The following sequence diagram shows the reference sequence diagram for creating an `EditEateryDescriptor e`.

image:EditEateryDescriptorSequenceDiagram.png[width=400]

The reference sequence diagram for creating `Eatery edited` has been omitted as the steps are the same as the reference sequence diagram for `add` command above.

==== Design Considerations
===== Aspect: Replace or directly manipulating the eatery's list of tags
* **Alternative 1 (current choice):** Replace the entire list of tags
** Pros:
*** Easy to implement.
*** More user-friendly -- command makes more sense to the user.
** Cons: Need to create additional commands to handle explicit manipulation of tags (i.e. `addtag` and `removetag` commands to the current list of tags.

* **Alternative 2:** Manipulating to the list of tags
** Pros:
*** Easy to implement.
*** Don't need to create an additional commands to manipulate tags.
** Cons: Not as user-friendly -- might need to specify more argument parameters to handle manipulation of tags (e.g. `\\at [tags]` to add tags and `\\rt [tags]` to remove existing tags).
// end::edit[]

// tag::revieweatery[]
=== Review Eatery feature
==== Implementation

The review mechanism is facilitated by `EateryList`.
It is stored internally as a set of reviews along with the other
attributes of an eatery.
Additionally, it implements the following operations:

* `Eatery#addReview` -- Adds a review to the eatery identified by the user input.

Given below is an example usage scenario and how the review mechanism behaves at each step.

Step 1. The user launches the application for the first time. The `EateryList` will be initialized with the initial json data stored.

Step 2. The user executes `review 1 ...` command to add a review to the first Eatery in the address book. The `review` command will call `Eatery#addReview()`.
[NOTE]
If the index given is not a valid index (ie, out of bounds or negative), it will return an error to the user rather than attempting to review the Eatery.

[NOTE]
If the review is missing a `Description`, `Rating`, `Cost` or a `Date` field, an error will be shown to the user instead of adding the review.


Step 3. The eatery list now returns a success message upon successfully adding a review to the eatery.

The following diagram shows the activities involved.
image:ReviewActivityDiagram.png[]

The following diagram shows how the method is executed.
image:ReviewSequenceDiagram.png[]

===== Aspect: How review executes

* ** Alternative 1 (current choice) **
Adds a review to an eatery's list of reviews.
** Pros: Easy to understand and implement.
** Cons: The set of reviews of an `Eatery` is not final, unlike tags.

* ** Alternative 2**
Return a new set of reviews every time a review is added.
** Pros: Makes the set of reviews final, adhering to the existing model.
** Cons: Highly inefficient

===== Aspect: Data Structure used to store Reviews

* **Alternative 1 (current choice):**
No further nesting of Review field in Eatery.
** Pros: Easily implemented and will not compromise speed.
** Cons: The OOP model might be different from other Commands.
* **Alternative 2:** Further nesting of Review field in Eatery.
** Pros: A better OOP model.
** Cons: May decrease performance and difficult to implement.
// end::revieweatery[]

// tag::editreview[]
=== Edit Review feature
==== Implementation

The edit review mechanism is facilitated by `EateryList`. It makes use of the following operations:

* `EateryList#getActiveEatery`
* `EateryList#getActiveReviews`

Given below is an example usage scenario and how the close mechanism behaves at each step.

Step 1. The user decides to check the reviews of an eatery by using `show` command.

Step 2. The user then decides to edit the first review of the eatery and executes `editreview 1 ...` with the necessary fields.

[NOTE]
If none of the fields entered are different from the existing fields, the user will be shown an error saying that at least one field should be different.

[NOTE]
If the user input is not according to the given format, an error will be shown to the user instead of attempting to edit the review.

Step 3. The application returns a success message upon successfully editing the review.

The following diagram shows the activities involved.
image:EditReviewActivityDiagram.png[]

==== Design Considerations:

===== Aspect: How edit review executes
* ** Alternative 1 (current choice)**:
When the show command is used, `EateryList#setActiveEatery` will set the eatery shown as the active eatery.
When the user attempts to edit review, the eatery is accessed using `EateryList#getActiveEatery`. The reviews are modified by using
`EateryList#getActiveReviews`, which returns a list of reviews. The changed list is set to the `ActiveEatery`
by `Eatery#setReviews`.

** Pros: Easy to access and edit reviews.
** Cons: The `ActiveEatery` is not modified until the `show` command is used on another eatery.

* ** Alternative 2**:
Operate directly on the list of reviews after using `show` command and set the changed list to the eatery.

** Pros: `EditReview` is only accessible after using `show` command.
** Cons: Difficult to implement and understand.
// end::editreview[]

//tag::deletereview[]
=== Delete Review feature
==== Implementation

The delete review mechanism is facilitated by `EateryList`. It makes use of the following operations:

* `EateryList#getActiveEatery`
* `EateryList#getActiveReviews`

Given below is an example usage scenario and how the close mechanism behaves at each step.

Step 1. The user decides to check the reviews of an eatery by using `show` command.

Step 2. The user then decides to delete the first review of the eatery and executes `deletereview 1 ...` .

[NOTE]
If the index given is not a valid index (ie, out of bounds or negative), it will return an error to the user rather than attempting to close the Eatery.

Step 3. The application returns a success message upon successfully deleting the review.

==== Design Considerations:

===== Aspect: How delete review executes
* ** Alternative 1 (current choice)**:
When the show command is used, `EateryList#setActiveEatery` will set the eatery shown as the active eatery.
When the user attempts to delete a review, the eatery is accessed using `EateryList#getActiveEatery`. The reviews are modified by using
`EateryList#getActiveReviews`, which returns a list of reviews. The changed list is set to the `ActiveEatery`
by `Eatery#setReviews`.

** Pros: Easy to access and delete reviews.
** Cons: The `ActiveEatery` is not modified until the `show` command is used on another eatery.

* ** Alternative 2**:
Operate directly on the list of reviews after using `show` command and set the changed list to the eatery.

** Pros: `DeleteReview` is only accessible after using `show` command.
** Cons: Difficult to implement and understand.

The following diagram shows the use case of review field as a whole.

image:ReviewUseCaseDiagram.png[]

//end::deletereview[]

//tag::addtag[]
=== Add Tag feature
==== Implementation
The addtag mechanism is facilitated by the EateryList and implement the following operations:

* `EateryList#getFilteredEateryList`
* `EateryList#setEatery`

The effects of add tag are cumulative, ie it does not replace existing tags but adds the given tags.

Given below is an example usage scenario and how the addtag mechanism behaves.

Step 1. The user launches the application and wants to add tags to the first eatery displayed.

Step 2. The user executes `addtag 1 ...` to add the required tags to the eatery.

[NOTE]
If the index specified is invalid (negative or out of bounds) or the format of the command is wrong,
an error will be shown to the user.

Step 3. If the tags to be added are not associated with eatery previously, they will be added to the eatery.

Step 4. AddTag success message is shown to the user.

==== Design Considerations:
===== How AddTag executes:
* ** Current choice: **
Returns a new Eatery object with the existing and new tags. The tags to be added are checked
if they are already associated with the eatery before adding.

** Pros:
Preserves the OOP model of the project and there is no need for setter methods.

** Cons: Very inefficient to return new Eatery object every time tags are changed.

//end::addtag[]

//tag:: deletetag[]
=== Delete Tag feature

==== Implementation
The deleteTag mechanism is facilitated by the EateryList and implement the following operations:

* `EateryList#getFilteredEateryList`
* `EateryList#setEatery`

Given below is an example usage scenario and how the addtag mechanism behaves.

Step 1. The user launches the application and wants to delete tags from the first eatery displayed.

Step 2. The user executes `deletetag 1 ...` to delete the required tags from the eatery.

[NOTE]
If the index specified is invalid (negative or out of bounds) or the format of the command is wrong,
an error will be shown to the user.

Step 3. If the tags to be deleted are not associated with eatery previously, no changes will be made.

Step 4. DeleteTag success message is shown to the user.

==== Design Considerations:
===== How AddTag executes:
* ** Current choice: **
Returns a new Eatery object with the existing and new tags. The tags to be deleted are checked
if they are already associated with the eatery before deleting.

** Pros:
Preserves the OOP model of the project and there is no need for setter methods.

** Cons: Very inefficient to return new Eatery object every time tags are changed.
//end::deletetag[]

// tag::close[]
=== Close Eatery feature
==== Implementation

The close mechanism is facilitated by `EateryList`. It implements ReadOnlyEateryList interface with the following operation:

* `EateryList#setEatery()` -- Replaces an Eatery with a modified Eatery specified by the user input.

Given below is an example usage scenario and how the close mechanism behaves at each step.

Step 1. The user launches the application for the first time. The `EateryList` will be initialized with the initial json data stored.

Step 2. The user executes `close 1` command to close the 1st Eatery in the address book.
[NOTE]
If the index given is not a valid index (ie, out of bounds or negative), CloseCommand will throw a CommandException to the user rather than attempting to close the Eatery.

Step 3. The address book now returns a success message upon successfully closing the Eatery, and the Eatery will be highlighted in red.

Step 4. The user then decides that he wants to close another Eatery.
[NOTE]
If the index given points to an Eatery already closed (ie, 1 in this situation), CloseCommand will throw a CommandException to the user rather than attempting to close the Eatery.

The following sequence diagram shows how the `close` command works:

image:CloseSequenceDiagram.png[width=600]

The following activity diagram summarizes what happens when a user executes a new `close` command:

image:CloseCommitActivityDiagram.png[width=400]

==== Design Considerations
===== Aspect: How Close executes
* **Alternative 1 (current choice):** Returns a new Eatery with identical fields except for the isOpen field.
** Pros:
*** Follows pre-exisiting EditCommand implementation.
*** No need for setter methods.
** Cons: Have to return a new object each time a change is made.
* **Alternative 2:** Setter method for isOpen field of Eatery.
** Pros: No need for extra methods in the flow to change the object.
** Cons:
*** Breaks pre-existing EditCommand implementation.
*** Need for setter methods.

===== Aspect: Data structure to support the Close command
* **Alternative 1 (current choice):** Uses a boolean value to keep track if the Eatery is reopened or closed.
** Pros: Easily implemented.
** Cons: An additional variable to check when executing other commands. Possibility of incorrect manipulation of an Eatery object
* **Alternative 2:** Maintain two separate lists of Eateries for Reopened and Closed.
** Pros: Closed Eateries stored apart from Reopened Eateries. Commands executed will only affect Eateries stored in a particular list.
** Cons: Requires proper handling of individual data structures to ensure each list is maintained and updated correctly.
// end::close[]

// tag::reopen[]
=== Reopen Eatery feature
==== Implementation

The reopen mechanism is facilitated by `AddressBook`. It implements the `ReadOnlyAddressBook` interface with the following operation:

* `AddressBook#setEatery()` -- Replaces an Eatery with a modified Eatery specified by the user input.

Given below is an example usage scenario and how the reopen mechanism behaves at each step.

Step 1. The user launches the application for the first time. The `AddressBook` will be initialized with the initial json data stored.

Step 2. The user executes `reopen 1` command to close the 1st Eatery in the address book.
[NOTE]
If the index given is not a valid index (ie, out of bounds or negative), ReopenCommand will throw a CommandException to the user rather than attempting to reopen the Eatery.

Step 3. The address book now returns a success message upon successfully reopening the Eatery, and the Eatery will not longer be highlighted in red.

Step 4. The user then decides that he wants to reopen another Eatery.
[NOTE]
If the index given points to an Eatery already reopened (ie, 1 in this situation), ReopenCommand will throw a CommandException to the user rather than attempting to reopen the Eatery.

The following sequence diagram shows how the `reopen` command works:

image:ReopenSequenceDiagram.png[width=600]

The following activity diagram summarizes what happens when a user executes a new `reopen` command:

image:ReopenCommitActivityDiagram.png[width=400]

==== Design Considerations
===== Aspect: How Reopen executes
* **Alternative 1 (current choice):** Returns a new Eatery with identical fields except for the isOpen field.
** Pros:
*** Follows pre-existing EditCommand implementation.
*** No need for setter methods.
** Cons: Have to return a new object each time a change is made.
* **Alternative 2:** Setter method for isOpen field of Eatery.
** Pros: No need for extra methods in the flow to change the object.
** Cons:
*** Breaks pre-existing EditCommand implementation.
*** Need for setter methods.

===== Aspect: Data structure to support the Reopen command
* **Alternative 1 (current choice):** Uses a boolean value to keep track if the Eatery is reopened or closed.
** Pros: Easily implemented.
** Cons: An additional variable to check when executing other commands. Possibility of incorrect manipulation of an Eatery object
* **Alternative 2:** Maintain two separate lists of Eateries for Reopened and Closed.
** Pros: Reopened Eateries stored apart from Closed Eateries. Commands executed will only affect Eateries stored in a particular list.
** Cons: Requires proper handling of individual data structures to ensure each list is maintained and updated correctly.
// end::reopen[]

// tag::stats[]
=== Statistics feature
==== Implementation

The stats feature allows the user to generate statistics about the eateries they have visited and reviews they have made at those visited eateries.

Given below is an example usage scenario and how the stats mechanism behaves at each step.

Step 1. The user launches the application for the first time. The `EateryList` will be initialised with the initial or previous json data stored.

Step 2. The user executes `stats` to generate statistics for the current application state. The `EatMeParser` would return a `StatsCommand` to execute the command.

Step 3. `StatsCommand` then creates `Statistics` to generate the different types of statistics needed. To create the different types of statistics, `Statistics` would, first, sort the eateries in `EateryList` based on different conditions i.e. categories, total expense, total number of visits. After sorting the eateries, `Statistics` would then use these sorted lists to generate the appropriate statistics.

[NOTE]
If the user executes the `stats` command in the Todo mode, `StatsCommand` would throw a `CommandException` to the user specifying that the user is in the wrong mode. In addition, if there is no eateries with any reviews in the application at the time of `stats` execution, the `StatsCommand` would throw a `CommandException` error saying that there is no data to generate statistics. Lastly, if there is any error during the generating of statistics, the `StatsCommand` will throw another `CommandException` saying that there is an unknown error and the application is unable to generate statistics.

Step 4. `StatsCommand` would then call `Model#setStatistics()` with `Statistics` as a a parameter.

Step 5. After successfully generating the statistics, `StatsCommand` will return the `CommandResult` to the `Ui`.

The following sequence diagram shows how the statistics feature is executed.
image:StatsSequenceDiagram.png[]

Since the statistic feature has a different user interface compared to the other commands i.e. `AddCommand`, `AddTagCommand`, etc., it would be useful to explain how the different user interface components work.

Step 1. When the `Ui` receives the `CommandResult` from `StatsCommand`, the `Ui` will call `MainWindow#showStats()`.

Step 2. `MainWindow#showStats() will check if `StatsWindow` is already open. If it is opened, it will call `StatsWindow#initStats()` and focuses the window. Else, it will call `StatsWindow#initStats()` and displays the window.

Step 3. In `StatsWindow#initStats()`, `StatsWindow` will create a `CustomLayeredGraph` and `CustomPiechart` to create the graph and pie chart needed for the statistics report.

The following sequence diagram shows how the statistics feature shows the statistics to the user.
image:StatsUiSequenceDiagram.png[]

==== Design Considerations
===== Aspect: Whether the statistics should auto-update when an eatery is added or a review is added to an eatery.
* ** Alternative 1 (current choice):** Not making the statistics auto-update
*** Pros: Easy to implement; don't need to refactor existing code to make use of ObservableList and add ListChange listeners.
*** Cons: User would need to call `stats` command after every addition or change made to the eatery or reviews of an eatery.

* ** Alternative 2: ** Making the statistics auto-update
*** Pros: User would not need to call `stats` command after every addition or change made to the eatery or reviews of an eatery.
*** Cons: Need to refactor a lot of existing code.

More detailed explanation for choosing *alternative 1*: Although it may be annoying for the user to keep calling `stats` command after every change made, we realise that since `stats` acts as a statistics report for the users, users may not call the `stats` command as often to justify refactoring the entire code. Furthermore, to make a change to the eatery or reviews, the user would still need to minimize `StatsWindow` and unminimize it to view the auto-updated changes. Hence, the number of steps the user would need to execute to see the change in statistics is the same even for both auto-update and without auto-update.
// end::stats[]

// tag::modeCommand[]
=== Changing Mode of EatMe feature
==== Implementation
Allows the user to toggle between Main mode and Todo mode. It extends `Command`, and once mode is switched, all other command functions would be affected.
The mode is determined through the value of a boolean variable named `isMainMode`.

Given below is an example usage of how the mode command behaves.

Step 1: The user launches the application. Data from `eaterylist` will be fetched and will be initialised in Main Mode by default.

Step 2: The user execute `mode` command and the mode of the application will be switched to `todo` mode, displaying items in the `todo` list instead.

Step 3: The user can execute `mode` command again, returning the application to `main` mode, showing the items stored in the `main` list.

The following sequence diagram shows how the `mode` command works:

image::ModeCommandSequence.png[]

The following activity diagram summarizes what happens when a user executes a new command:

image::ModeCommandActivity.png[]

==== Design Considerations
===== Aspect: How Mode execute
* **Alternative 1 (current choice):** Toggle between mode through a boolean value.
** Pros: Easy for implementation.
** Cons: An additional factor to check when executing any other commands; Possibility of mis-manipulation of data.

===== Aspect: Data structure to support Mode Command
* **Alternative 1 (current choice):** Maintain two separate lists for Main mode and Todo Mode.
** Pros: Data between the two modes will be separated. Commands executed will only affect data stored in the list for the particular mode.
** Cons: More effort required for maintenance purposes. Need to make sure that data from main list should not go into todo list, and vice versa
//end::modeCommand[]

//tag::saveTodoCommand[]
=== Saving Todo Eatery feature
==== Implementation
This command allows the user to save an eatery from the todo list to the main eatery list. It extends `Command`.

Given below is an example usage of how the SaveTodo Command behaves.

Step 1: The user launches the application. Data from `EateryList` will be fetched and initialised in main mode by default.

Step 2: The user executes mode command and the mode of the application will be switched to Todo mode, displaying items in the todo list instead.

Step 3: The user can execute `save 1`, indicating to the system the index of eatery to be saved.

Step 4: The eatery in the todo list will be removed and an add command will be constructed in the CommandBox for the user to input any necessary fields before adding.

The following sequence diagram shows how the `SaveTodo` command works:

image::SaveTodoCommandSequence.png[]

The following activity diagram summarizes what happens when a user executes a new command:

image::SaveTodoCommandActivity.png[]

==== Design Considerations
===== Aspect: How SaveTodo execute
* **Alternative 1 (current choice):** Construct the commands as a string before displaying to the user.
** Pros: User-friendly. User will be able to add the eatery to the main list with minimum effort.
** Cons: Unable to save directly to the main list from todo list. Possible situation can be that the user did not add the new eatery after executing `saveTodo` command.
This situation will result in the user requiring to type the whole `add` command on his own as information will not be saved.

* **Alternative 2** Allow eatery to have the same attributes fields as eatery in main list
** Pros: As eatery in todo list and main list have the same attributes, it will be possible to `save` the eatery directly to the main list without further input from the user.
** Cons: User will be required to include additional field when adding an eatery in the todo list. Field entered may be irrelevant as user had yet to visit the eatery.

===== Aspect: Data structure to support SaveTodo Command
* **Alternative 1 (current choice):** No additional data structure is required for `SaveTodo` command

//end::saveTodoCommand[]

// tag::newsFeedFeature[]
=== News Feed Feature
As people who really love food, we are interested in keeping up-to-date with the latest food trends and newest eateries to try.
The news feed allows the user to save their favorite food blogs to EatMe and have access to the latest food-related articles right from within the app.
Should a food blog become irrelevant, the user also has the option to remove it and no longer display its articles.

==== Terminology
Some terms are used in this feature:

- `Feed` - A food blog
- `Feed Post` - An article from a feed
- `News Feed Panel` - The right column of the app showing news articles

==== Implementation
The current news feed supports two commands:

- `AddFeed` - Add a new feed
- `DeleteFeed` - Delete a feed and its associated feed posts

===== `AddFeed` - Add a new feed
The following activity diagram shows the flow when the user wants to add a new feed.

image::AddFeedActivityDiagram.png[]

Step 1. The user launches the application.

Step 2. EatMe fetches the latest feed posts from the user's existing feeds and displays them to the user in the news feed panel.

Step 3. The user finds a new favorite food blog called _Eatbook_ and wants to add it into the app. The user executes `addfeed \\n Eatbook \\a https://eatbook.sg/feed` to add the new feed. `AddFeedCommand` calls `Model#addFeed` with the new feed object, which will in turn add the new feed to the Model's internal feed list.

The following sequence diagram shows how the `AddFeed` command executes.

image::AddFeedSequenceDiagram.png[]

===== `DeleteFeed` - Delete a feed and its associated feed posts
The following activity diagram shows the flow when the user wants to delete a feed.

image::DeleteFeedActivityDiagram.png[]

Step 1. The user launches the application.

Step 2. EatMe fetches the latest feed posts from the user's existing feeds and displays them to the user in the news feed panel.

Step 3. The user is no longer interested in the food blog _Eatbook_ and wants to delete it from the app. The user executes `deletefeed \\n Eatbook` to delete the feed. `DeleteFeedCommand` calls `Model#deleteFeed` with the feed to delete, which will in turn remove the feed to the Model's internal feed list.

The following sequence diagram shows how the `DeleteFeed` command executes.

image::DeleteFeedSequenceDiagram.png[]

==== Design Considerations
===== Aspect: Storage of feed list
* Alternative 1: Store the feed list in the existing Eatery list JSON file.
** Pros: Single JSON file for all of the user's data (eateries, todos, feeds).
** Cons: When sharing your JSON file with another user, the feeds would be transferred as well - Poor user experience because favorite food blogs are a personal choice and should not be transferred when sharing eateries.
* Alternative 2 (current choice): Store the feed list as a separate JSON file.
** Pros: Separation of eatery-related and feed-related information into two separate JSON files - Allows sharing of eateries without affecting feeds.
** Cons: Two separate files - Minor inconvenience if the user wants to backup their data to another location.

===== Aspect: Offline behavior of news feed
* Alternative 1 (current implementation): Store the feed posts from the last successful update in the feed list JSON file
** Pros: Allows for offline access to feed posts.
** Cons:
*** Feed posts may be outdated if the user has not opened the app with Internet connectivity for a long time.
*** Larger feed list JSON file size.
* Alternative 2: Show an error message when offline.
** Pros: Small and simple feed list JSON file.
** Cons: Unable to view feed posts when offline.
// end::newsFeedFeature[]

// tag::load[]
=== Load friend's EateryList feature
==== Implementation

The load mechanism is facilitated by `ModelManager`. It implements the `Model` interface with the following operation:

* `Model#setUserPrefs()` -- Replaces the existing UserPrefs with a modified UserPrefs specified by the user input.

Given below is an example usage scenario and how the load mechanism behaves at each step.

Step 1. The user launches the application for the first time. The `EateryList` will be initialized with the initial json data stored.

Step 2. The user executes `load \\u Alice` command to change the `UserPrefs` of the `ModelManger`.
[NOTE]
If the command is missing the username (i.e. `load \\u`), LoadCommandParser will throw an ParserException to the user with an error message specifying that the command parameters are incorrect, and an example usage of the command.
[NOTE]
If the command is missing the username and the prefix (i.e. `load`), this will be interpreted as loading the owner's own Eatery List.

Step 3. The Eatery List now returns a success message upon successfully changing the `UserPrefs`, and prompts the user to relaunch the application.

Step 4. The user then decides that he wants to change his `UserPrefs` to another friend's one. Before exiting the application, the user can still enter `load \\u Bob` command to change the `UserPrefs`.
[NOTE]
If the user attempts to load a file that has already been set in the `UserPrefs`, the LoadCommand will throw a CommandException to the user with an error message specifying that the `UserPrefs` has already been changed.
[NOTE]
If the user attempts to load a file that does not exist in the default filepath, the LoadCommand will throw a CommandException to the user with an error message to prompt him to check that the file exists.

Step 5. The user then decides that he wants to change his `UserPrefs` back to his own instead. Before exiting the application, the user can still enter `load` command to reset the `UserPrefs` of the `ModelManage` back to his own Eatery List.

The following sequence diagram shows how the `load` command works:

image:LoadSequenceDiagram.png[width=600]

The following activity diagram summarizes what happens when a user executes a new `load` command:

image:LoadCommitActivityDiagram.png[width=400]

==== Design Considerations
===== Aspect: How Load executes
* **Alternative 1 (current choice):** Modifies the existing model in the Eatery List.
** Pros: Easily implemented without needing to relaunch the GUI.
** Cons: Require the application to be terminated for the storage to save UserPrefs.
* **Alternative 2:** Creates a new model to replace the current one.
** Pros: Easier to implement the loading of file without relaunching the application.
** Cons: Need to relaunch the GUI so that the new file can be seen.

===== Aspect: User Experience to execute Load
* **Alternative 1 (current choice):** The user has to relaunch the application.
** Pros:
*** Easily implemented.
*** Clear to the user that the UserPaths has been changed.
** Cons: Additional work from the user
* **Alternative 2:** Relaunch the GUI
** Pros: The user does not need to reload the application.
** Cons:
*** Harder to implement.
*** Might confuse the user if the UserPaths has been changed. Especially if the friend's EateryList is similar to the user (i.e. same school).
// end::load[]

=== 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 EatMe
* `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]
// tag::appendix[]
== Product Scope

*Target user profile*:

* has a need to manage a significant number of <<eatery, eateries>>
** budget
** <<category, category>>
** location
* prefer desktop apps over other types
* can type fast
* prefers typing over mouse input
* is reasonably comfortable using CLI apps

*Value proposition*: manage eateries faster than a typical mouse/GUI driven app with statistics of key details such as budget, category and location

[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...
|`* * *` |food blogger |keep a list of outstanding cafes |clear them in an orderly fashion.

|`* * *` |student |keep a list of affordable eateries |save money

|`* * *` |person with many food allergies |keep track of dishes I have ordered before |avoid ordering hazardous food

|`* * *` |foodie |remember places |share this experience with my family and friends

|`* *` |digital nomad |tag places with free power + wifi |sit there for extended periods of time

|`*` |working adult |view the menu beforehand |save time from thinking what to eat
|=======================================================================

[appendix]
== Use Cases

(For all use cases below, the *System* is the `EatMe` and the *Actor* is the `user`, unless specified otherwise)

[discrete]
=== Use case: Removing an eatery from todo

*MSS*

1.  User requests to view his todo list
2.  EatMe toggles to the todo mode
3.  User requests to mark an eatery as visited in the list
4.  EatMe shifts the data over
5.  EatMe toggles to the main mode
6.  EatMe requests user for whatever information left that is required before saving in the main mode
+
Use case ends.

*Extensions*

[none]
* 2a. The list is empty.
+
Use case ends.

* 3a. The given eatery is invalid.
+
[none]
** 3a1. EatMe shows an error message.
+
Use case resumes at step 2.

* 6a. The given information is of the wrong format.
+
[none]
** 6a1. EatMe shows an error message.
+
Use case resumes at step 8.

[discrete]
=== Use case: Tagging an eatery in main

*MSS*

1.  User requests to add a tag to an eatery
2.  EatMe updates the eatery accordingly
+
Use case ends.

*Extensions*

[none]
* 1a. The list is empty.
+
Use case ends.

* 1b. The user gives invalid information.
+
[none]
** 1b1. EatMe shows an error message.
+
Use case resumes at step 1.

[discrete]
=== Use case: Viewing a different Eatery List file
*MSS*

1.  User requests to view another Eatery List file
2.  EatMe updates the preferences.json file
3.  EatMe requests the user to relaunch the application
3.  User relaunches the application and see the new file displayed
+
Use case ends.

*Extensions*

[none]
* 1a. The file does not exist.
+
** 1a1. EatMe shows an error message.
+
Use case resumes at step 1.


* 1b. The user gives a file that is already loaded in to the preferences.json
+
[none]
** 1b1. EatMe shows an error message.
+
Use case resumes at step 1

* 1c. The user gives no arguments, just load.
+
[none]
** 1c1. EatMe updates the preferences.json file with the owner's file.
+
Use case resumes at step 2.

[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 1000 eateries without a noticeable sluggishness in performance for typical usage.
.  A user with above average typing speed for regular English text (i.e. not code, system admin commands, etc.) should be able to accomplish most of the tasks faster using commands than using the mouse.
.  Main functionalities of the app (i.e. CRUD) should work without WiFi.

[appendix]
== Glossary

[[mainstream-os]] Mainstream OS::
Windows, Linux, Unix, OS-X

[[eatery]] Eatery::
Any place that serves food open to the public (e.g. restaurants, cafes, roadside, pushcart, etc.)

[[category]] Category::
Any type of cuisines (e.g. Chinese, International)

[[feed]] Feed::
Any food blog

[appendix]
== Product Survey

*WhatsMyFood*

Author: Casa de Sante Inc

Pros:

* Nice User Interface
* Has camera function to upload pictures of the food

Cons:

* Does not have a todo feature for users to create a wishlist
* Does not have a feed list feature for users to follow their favourite food bloggers
//end::appendix[]

[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 eateries. 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.

=== General

. Changing the mode of application

.. Test case: `mode` +
Expected: Success Message displayed, indicating the current mode of application

. Load eateries from other user profiles

.. Prerequisite: The the file to which will be loaded must already exist
... Test Case: `load \\u Alice` +
Expected: Updates the preferences.json file to the specified file.
... Test Case: `load \\u Alice.json` +
Expected: Updates the preferences.json file to the specified file. (the .json file type will be handled by the ParserUtil)
... Test Case: `load` +
Expected: Updates the preferences.json file to the owner's file.
... Test Case: `load` followed by `load` again +
Expected: Shows error as the file has already been updated.
... Test Case: `load \\u` +
Expected: Shows error as the field is missing.

=== Working in Main mode

. Adding an eatery

.. Test case: `add \\n WaaCow \\a Utown \\c Japanese \\t expensive` +
Expected: Adds a new eatery named WaaCow to the list.
.. Test case: `add \\n Mos Burger` +
Expected: Shows error message stating compulsory fields are missing.
.. Test case: `add \\n MosBurger \\a Clementi \\c Fastfood \\t 23` +
Expected: Shows error message stating invalid tag format.

. Editing an eatery

.. Prerequisite: At least one eatery in the list.
... Test case: `edit 1 \\n HelpMe` +
Expected: Eatery at index 1 will have its name changed to ""HelpMe"".
... Test case: `edit 1` +
Expected: Shows an error message specifying that at least one field should be given.
... Test case: `edit 1000` +
Expected: Shows an error message specifying that an invalid eatery index was given.


. Add a review
.. Prerequisite: The eatery to which the review is being added must exist.
... Test Case: `review 1 \\d good \\p 3 \\r 3 \\w 11/11/2019` +
Expected: Adds the new review to the eatery.

... Test Case: `review` +
Expected: Shows error as the fields are missing.

... Test Case: `review \\d good \\p 2 \\r 3` +
Expected: Shows error even if one of the fields is missing.

. Edit a review
.. Prerequisite: The review to edit must exist and at least one of the fields being changed must have data different from the existing one.
... Test Case: `editreview 1 \\r 3.2` +
Expected: The rating of the review is changed to 3.2.
... Test Case: `editreview` +
Expected: Shows error as no index.

. Delete a review
.. Prerequisite: The review to delete must exist.
... Test Case: `deletereview 1` +
Expected: Review is deleted.

. Generating statistics

.. Prerequisite: At least one review in the app.
... Test case: `stats` +
Expected: Statistics window will pop-up, showing the statistics.

.. Prerequisite: No reviews in the app.
... Test case: `stats` +
Expected: Shows an error message specifying that there is not enough reviews to generate statistics.

. Close an eatery
.. Prerequisite: The eatery to close must exist
... Test Case: `close 1` +
Expected: The eatery at index 1 will be closed. A red highlight will be seen over the eatery card.
... Test Case: `close` +
Expected: Shows error as no index.
.. Test Case: `close 1` followed by `close 1` again +
Expected: Shows error as eatery has already been closed.

. Reopen an eatery

.. Prerequisite: The eatery to reopen must exist

... Test Case: `reopen 1` +
Expected: The eatery at index 1 will be reopened. The eatery card will no longer be highlighted in red.
... Test Case: `reopen` +
Expected: Shows error as no index.
... Test Case: `reopen 1` followed by `reopen 1` again +
Expected: Shows error as eatery has already been reopened.

=== Working in Todo mode

. Saving a todo eatery

.. Prerequisite: At least one eatery in todo list
... Test case: `save 1` +
Expected: Application toggled to main mode and constructed `add` command shown in command box.
... Test case: `save abc` +
Expected: Shows error message.


=== News Feed

. Adding a new feed
.. Prerequisites: The feed list already already contains one feed, ""Ladyironchef"" with the Web address ""https://www.ladyironchef.com/feed"".

... Test case: `addfeed \\n Eatbook \\a https://eatbook.sg/feed` +
   Expected: Adds the new feed ""Eatbook"" and fetches its 5 most recent feed posts.
... Test case: `addfeed` +
   Expected: Shows error message that the command is invalid (missing name and address).
... Test case: `addfeed \\n Eatbook` +
   Expected: Shows error message that the command is invalid (missing address).
... Test case: `addfeed \\a https://eatbook.sg/feed` +
   Expected: Shows error message that the command is invalid (missing name).

. Deleting a feed
.. Prerequisites: The feed list already already contains two feeds, ""Ladyironchef"" and ""Eatbook"".

... Test case: `deletefeed \\n Eatbook` +
   Expected: Deletes the feed ""Eatbook"" and all of its associated feed posts.
... Test case: `deletefeed` +
   Expected: Shows error message that the command is invalid (missing name).
... Test case: `deletefeed \\n NonExistentFeed` +
   Expected: Shows error message that the feed does not exist.

",12443,False,2180.8246100862234,median
"// This file is part of chrony
//
// Copyright (C) Richard P. Curnow  1997-2003
// Copyright (C) Stephen Wadeley  2016
// Copyright (C) Miroslav Lichvar  2009-2017
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of version 2 of the GNU General Public License as
// published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License along
// with this program; if not, write to the Free Software Foundation, Inc.,
// 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

= chronyc(1)
:doctype: manpage
:man manual: User manual
:man source: chrony @CHRONY_VERSION@

== NAME

chronyc - command-line interface for chrony daemon

== SYNOPSIS

*chronyc* [_OPTION_]... [_COMMAND_]...

== DESCRIPTION

*chronyc* is a command-line interface program which can be used to monitor
*chronyd*'s performance and to change various operating parameters whilst it is
running.

If no commands are specified on the command line, *chronyc* will expect input
from the user. The prompt _chronyc>_ will be displayed when it is being run
from a terminal. If *chronyc*'s input or output are redirected from or to a file,
the prompt is not shown.

There are two ways *chronyc* can access *chronyd*. One is the Internet
Protocol (IPv4 or IPv6) and the other is a Unix domain socket, which is
accessible locally by the root or _chrony_ user. By default, *chronyc* first
tries to connect to the Unix domain socket. The compiled-in default path is
_@CHRONYRUNDIR@/chronyd.sock_. If that fails (e.g. because *chronyc* is
running under a non-root user), it will try to connect to 127.0.0.1 and then
::1.

Only the following monitoring commands, which do not affect the behaviour of
*chronyd*, are allowed from the network: *activity*, *manual list*,
*rtcdata*, *smoothing*, *sources*, *sourcestats*, *tracking*, *waitsync*. The
set of hosts from which *chronyd* will accept these commands can be configured
with the <<chrony.conf.adoc#cmdallow,*cmdallow*>> directive in the *chronyd*'s
configuration file or the <<cmdallow,*cmdallow*>> command in *chronyc*. By
default, the commands are accepted only from localhost (127.0.0.1 or ::1).

All other commands are allowed only through the Unix domain socket. When sent
over the network, *chronyd* will respond with a '`Not authorised`' error, even
if it is from localhost. In chrony versions before 2.2 they were allowed
from the network if they were authenticated with a password, but that is no
longer supported.

Having full access to *chronyd* via *chronyc* is more or less equivalent to
being able to modify the *chronyd*'s configuration file and restart it.

== OPTIONS

*-4*::
With this option hostnames will be resolved only to IPv4 addresses.

*-6*::
With this option hostnames will be resolved only to IPv6 addresses.

*-n*::
This option disables resolving of IP addresses to hostnames, e.g. to avoid slow
DNS lookups. Long addresses will not be truncated to fit into the column.

*-c*::
This option enables printing of reports in a comma-separated values (CSV)
format. IP addresses will not be resolved to hostnames, time will be printed as
number of seconds since the epoch and values in seconds will not be converted
to other units.

*-d*::
This option enables printing of debugging messages if *chronyc* was compiled
with debugging support.

*-m*::
Normally, all arguments on the command line are interpreted as one command.
With this option multiple commands can be specified. Each argument will be
interpreted as a whole command.

*-h* _host_::
This option allows the user to specify which host (or comma-separated list of
addresses) running the *chronyd* program is to be contacted. This allows for
remote monitoring, without having to connect over SSH to the other host first.
+
The default is to contact *chronyd* running on the same host where
*chronyc* is being run.

*-p* _port_::
This option allows the user to specify the UDP port number which the target
*chronyd* is using for its monitoring connections. This defaults to 323; there
would rarely be a need to change this.

*-f* _file_::
This option is ignored and is provided only for compatibility.

*-a*::
This option is ignored and is provided only for compatibility.

*-v*::
With this option *chronyc* displays its version number on the terminal and
exits.

== COMMANDS

This section describes each of the commands available within the *chronyc*
program.

=== System clock

[[tracking]]*tracking*::
The *tracking* command displays parameters about the system's clock
performance. An example of the output is shown below.
+
----
Reference ID    : CB00710F (foo.example.net)
Stratum         : 3
Ref time (UTC)  : Fri Jan 27 09:49:17 2017
System time     : 0.000006523 seconds slow of NTP time
Last offset     : -0.000006747 seconds
RMS offset      : 0.000035822 seconds
Frequency       : 3.225 ppm slow
Residual freq   : -0.000 ppm
Skew            : 0.129 ppm
Root delay      : 0.013639022 seconds
Root dispersion : 0.001100737 seconds
Update interval : 64.2 seconds
Leap status     : Normal
----
+
The fields are explained as follows:
+
*Reference ID*:::
This is the reference ID and name (or IP address) of the server to which the
computer is currently synchronised. For IPv4 addresses, the reference ID is
equal to the address and for IPv6 addresses it is the first 32 bits of the MD5
sum of the address.
+
If the reference ID is _7F7F0101_ and there is no name or IP address, it means
the computer is not synchronised to any external source and that you have the
_local_ mode operating (via the <<local,*local*>> command in *chronyc*, or the
<<chrony.conf.adoc#local,*local*>> directive in the configuration file).
+
The reference ID is printed as a hexadecimal number. Note that in older
versions it used to be printed in quad-dotted notation and could be confused
with an IPv4 address.
*Stratum*:::
The stratum indicates how many hops away from a computer with an attached
reference clock we are. Such a computer is a stratum-1 computer, so the
computer in the example is two hops away (i.e. _foo.example.net_ is a
stratum-2 and is synchronised from a stratum-1).
*Ref time*:::
This is the time (UTC) at which the last measurement from the reference
source was processed.
*System time*:::
In normal operation, *chronyd* by default never steps the system clock, because
any jump in the time can have adverse consequences for certain application
programs. Instead, any error in the system clock is corrected by slightly
speeding up or slowing down the system clock until the error has been removed,
and then returning to the system clock's normal speed. A consequence of this is
that there will be a period when the system clock (as read by other programs)
will be different from *chronyd*'s estimate of the current true time (which it
reports to NTP clients when it is operating in server mode). The value reported
on this line is the difference due to this effect.
*Last offset*:::
This is the estimated local offset on the last clock update.
*RMS offset*:::
This is a long-term average of the offset value.
*Frequency*:::
The '`frequency`' is the rate by which the system's clock would be wrong if
*chronyd* was not correcting it. It is expressed in ppm (parts per million).
For example, a value of 1 ppm would mean that when the system's clock thinks it
has advanced 1 second, it has actually advanced by 1.000001 seconds relative to
true time.
*Residual freq*:::
This shows the '`residual frequency`' for the currently selected reference
source. This reflects any difference between what the measurements from the
reference source indicate the frequency should be and the frequency currently
being used.
+
The reason this is not always zero is that a smoothing procedure is
applied to the frequency. Each time a measurement from the reference
source is obtained and a new residual frequency computed, the estimated
accuracy of this residual is compared with the estimated accuracy (see
'`skew`' next) of the existing frequency value. A weighted average is
computed for the new frequency, with weights depending on these accuracies.
If the measurements from the reference source follow a consistent trend, the
residual will be driven to zero over time.
*Skew*:::
This is the estimated error bound on the frequency.
*Root delay*:::
This is the total of the network path delays to the stratum-1 computer from
which the computer is ultimately synchronised.
*Root dispersion*:::
This is the total dispersion accumulated through all the computers back to
the stratum-1 computer from which the computer is ultimately synchronised.
Dispersion is due to system clock resolution, statistical measurement
variations, etc.
+
An absolute bound on the computer's clock accuracy (assuming the stratum-1
computer is correct) is given by:
+
----
clock_error <= |system_time_offset| + root_dispersion + (0.5 * root_delay)
----
*Update interval*:::
This is the interval between the last two clock updates.
*Leap status*:::
This is the leap status, which can be _Normal_, _Insert second_, _Delete
second_ or _Not synchronised_.

[[makestep]]*makestep*::
*makestep* _threshold_ _limit_::
Normally *chronyd* will cause the system to gradually correct any time offset,
by slowing down or speeding up the clock as required. In certain situations,
the system clock might be so far adrift that this slewing process would take a
very long time to correct the system clock.
+
The *makestep* command can be used in this situation. There are two forms of
the command. The first form has no parameters. It tells *chronyd* to cancel any
remaining correction that was being slewed and jump the system clock by the
equivalent amount, making it correct immediately.
+
The second form configures the automatic stepping, similarly to the
<<chrony.conf.adoc#makestep,*makestep*>> directive. It has two parameters,
stepping threshold (in seconds) and number of future clock updates for which
the threshold will be active. This can be used with the <<burst,*burst*>>
command to quickly make a new measurement and correct the clock by stepping if
needed, without waiting for *chronyd* to complete the measurement and update
the clock.
+
----
makestep 0.1 1
burst 1/2
----
+
BE WARNED: Certain software will be seriously affected by such jumps in the
system time. (That is the reason why *chronyd* uses slewing normally.)

[[maxupdateskew]]*maxupdateskew* _skew-in-ppm_::
This command has the same effect as the
<<chrony.conf.adoc#maxupdateskew,*maxupdateskew*>> directive in the
configuration file.

[[waitsync]]*waitsync* [_max-tries_ [_max-correction_ [_max-skew_ [_interval_]]]]::
The *waitsync* command waits for *chronyd* to synchronise.
+
Up to four optional arguments can be specified. The first is the maximum number
of tries before giving up and returning a non-zero error code. When 0 is
specified, or there are no arguments, the number of tries will not be limited.
+
The second and third arguments are the maximum allowed remaining correction of
the system clock and the maximum allowed skew (in ppm) as reported by the
<<tracking,*tracking*>> command in the *System time* and *Skew* fields. If not
specified or zero, the value will not be checked.
+
The fourth argument is the interval specified in seconds in which the check is
repeated. The interval is 10 seconds by default.
+
An example is:
+
----
waitsync 60 0.01
----
+
which will wait up to about 10 minutes (60 times 10 seconds) for *chronyd* to
synchronise to a source and the remaining correction to be less than 10
milliseconds.

=== Time sources

[[sources]]*sources* [*-v*]::
This command displays information about the current time sources that *chronyd*
is accessing.
+
The optional argument *-v* can be specified, meaning _verbose_. In this case,
extra caption lines are shown as a reminder of the meanings of the columns.
+
----
210 Number of sources = 3
MS Name/IP address         Stratum Poll Reach LastRx Last sample
===============================================================================
#* GPS0                          0   4   377    11   -479ns[ -621ns] +/-  134ns
^? foo.example.net               2   6   377    23   -923us[ -924us] +/-   43ms
^+ bar.example.net               1   6   377    21  -2629us[-2619us] +/-   86ms
----
+
The columns are as follows:
+
*M*:::
This indicates the mode of the source. _^_ means a server, _=_ means a peer
and _#_ indicates a locally connected reference clock.
*S*:::
This column indicates the state of the source.
* _*_ indicates the source to which *chronyd* is currently synchronised.
* _+_ indicates acceptable sources which are combined with the selected
  source.
* _-_ indicates acceptable sources which are excluded by the combining
  algorithm.
* _?_ indicates sources to which connectivity has been lost or whose packets
  do not pass all tests. It is also shown at start-up, until at least 3 samples
  have been gathered from it.
* _x_ indicates a clock which *chronyd* thinks is a falseticker (i.e. its
  time is inconsistent with a majority of other sources).
* _~_ indicates a source whose time appears to have too much variability.
*Name/IP address*:::
This shows the name or the IP address of the source, or reference ID for reference
clocks.
*Stratum*:::
This shows the stratum of the source, as reported in its most recently
received sample. Stratum 1 indicates a computer with a locally attached
reference clock. A computer that is synchronised to a stratum 1 computer is
at stratum 2. A computer that is synchronised to a stratum 2 computer is at
stratum 3, and so on.
*Poll*:::
This shows the rate at which the source is being polled, as a base-2
logarithm of the interval in seconds. Thus, a value of 6 would indicate that
a measurement is being made every 64 seconds. *chronyd* automatically varies
the polling rate in response to prevailing conditions.
*Reach*:::
This shows the source's reachability register printed as an octal number. The
register has 8 bits and is updated on every received or missed packet from
the source. A value of 377 indicates that a valid reply was received for all
from the last eight transmissions.
*LastRx*:::
This column shows how long ago the last sample was received from the source.
This is normally in seconds. The letters _m_, _h_, _d_ or _y_ indicate
minutes, hours, days, or years.
*Last sample*:::
This column shows the offset between the local clock and the source at the
last measurement. The number in the square brackets shows the actual measured
offset. This can be suffixed by _ns_ (indicating nanoseconds), _us_
(indicating microseconds), _ms_ (indicating milliseconds), or _s_ (indicating
seconds). The number to the left of the square brackets shows the original
measurement, adjusted to allow for any slews applied to the local clock
since. The number following the _+/-_ indicator shows the margin of error in
the measurement. Positive offsets indicate that the local clock is ahead of
the source.

[[sourcestats]]*sourcestats* [*-v*]::
The *sourcestats* command displays information about the drift rate and offset
estimation process for each of the sources currently being examined by
*chronyd*.
+
The optional argument *-v* can be specified, meaning _verbose_. In this case,
extra caption lines are shown as a reminder of the meanings of the columns.
+
An example report is:
+
----
210 Number of sources = 1
Name/IP Address            NP  NR  Span  Frequency  Freq Skew  Offset  Std Dev
===============================================================================
foo.example.net            11   5   46m     -0.001      0.045      1us    25us
----
+
The columns are as follows:
+
*Name/IP Address*:::
This is the name or IP address of the NTP server (or peer) or reference ID of the
reference clock to which the rest of the line relates.
*NP*:::
This is the number of sample points currently being retained for the server.
The drift rate and current offset are estimated by performing a linear
regression through these points.
*NR*:::
This is the number of runs of residuals having the same sign following the
last regression. If this number starts to become too small relative to the
number of samples, it indicates that a straight line is no longer a good fit
to the data. If the number of runs is too low, *chronyd* discards older
samples and re-runs the regression until the number of runs becomes
acceptable.
*Span*:::
This is the interval between the oldest and newest samples. If no unit is
shown the value is in seconds. In the example, the interval is 46 minutes.
*Frequency*:::
This is the estimated residual frequency for the server, in parts per
million. In this case, the computer's clock is estimated to be running 1 part
in 10^9 slow relative to the server.
*Freq Skew*:::
This is the estimated error bounds on *Freq* (again in parts per million).
*Offset*:::
This is the estimated offset of the source.
*Std Dev*:::
This is the estimated sample standard deviation.

[[reselect]]*reselect*::
To avoid excessive switching between sources, *chronyd* can stay synchronised
to a source even when it is not currently the best one among the available
sources.
+
The *reselect* command can be used to force *chronyd* to reselect the best
synchronisation source.

[[reselectdist]]*reselectdist* _distance_::
The *reselectdist* command sets the reselection distance. It is equivalent to
the <<chrony.conf.adoc#reselectdist,*reselectdist*>> directive in the
configuration file.

=== NTP sources

[[activity]]*activity*::
This command reports the number of servers and peers that are online and
offline. If the *auto_offline* option is used in specifying some of the servers
or peers, the *activity* command can be useful for detecting when all of them
have entered the offline state after the network link has been disconnected.
+
The report shows the number of servers and peers in 5 states:
+
*online*:::
the server or peer is currently online (i.e. assumed by *chronyd* to be reachable)
*offline*:::
the server or peer is currently offline (i.e. assumed by *chronyd* to be
unreachable, and no measurements from it will be attempted.)
*burst_online*:::
a burst command has been initiated for the server or peer and is being
performed; after the burst is complete, the server or peer will be returned to
the online state.
*burst_offline*:::
a burst command has been initiated for the server or peer and is being
performed; after the burst is complete, the server or peer will be returned to
the offline state.
*unresolved*:::
the name of the server or peer was not resolved to an address yet; this source is
not visible in the *sources* and *sourcestats* reports.

[[ntpdata]]*ntpdata* [_address_]::
The *ntpdata* command displays the last valid measurement and other
NTP-specific information about the specified NTP source, or all NTP sources if
no address was specified. An example of the output is shown below.
+
----
Remote address  : 203.0.113.15 (CB00710F)
Remote port     : 123
Local address   : 203.0.113.74 (CB00714A)
Leap status     : Normal
Version         : 4
Mode            : Server
Stratum         : 1
Poll interval   : 10 (1024 seconds)
Precision       : -24 (0.000000060 seconds)
Root delay      : 0.000015 seconds
Root dispersion : 0.000015 seconds
Reference ID    : 47505300 (GPS)
Reference time  : Fri Nov 25 15:22:12 2016
Offset          : -0.000060878 seconds
Peer delay      : 0.000175634 seconds
Peer dispersion : 0.000000681 seconds
Response time   : 0.000053050 seconds
Jitter asymmetry: +0.00
NTP tests       : 111 111 1111
Interleaved     : No
Authenticated   : No
TX timestamping : Kernel
RX timestamping : Kernel
Total TX        : 24
Total RX        : 24
Total valid RX  : 24
----
+
The fields are explained as follows:
+
*Remote address*:::
The IP address of the NTP server or peer, and the corresponding reference ID.
*Remote port*:::
The UDP port number to which the request was sent. The standard NTP port is
123.
*Local address*:::
The local IP address which received the response, and the corresponding
reference ID.
*Leap status*:::
*Version*:::
*Mode*:::
*Stratum*:::
*Poll interval*:::
*Precision*:::
*Root delay*:::
*Root dispersion*:::
*Reference ID*:::
*Reference time*:::
The NTP values from the last valid response.
*Offset*:::
*Peer delay*:::
*Peer dispersion*:::
The measured values.
*Response time*:::
The time the server or peer spent in processing of the request and waiting
before sending the response.
*Jitter asymmetry*:::
The estimated asymmetry of network jitter on the path to the source. The
asymmetry can be between -0.5 and 0.5. A negative value means the delay of
packets sent to the source is more variable than the delay of packets sent
from the source back.
*NTP tests*:::
Results of RFC 5905 tests 1 through 3, 5 through 7, and tests for maximum
delay, delay ratio, delay dev ratio, and synchronisation loop.
*Interleaved*:::
This shows if the response was in the interleaved mode.
*Authenticated*:::
This shows if the response was authenticated.
*TX timestamping*:::
The source of the local transmit timestamp. Valid values are _Daemon_,
_Kernel_, and _Hardware_.
*RX timestamping*:::
The source of the local receive timestamp.
*Total TX*:::
The number of packets sent to the source.
*Total RX*:::
The number of all packets received from the source.
*Total valid RX*:::
The number of valid packets received from the source.

[[add_peer]]*add peer* _address_ [_option_]...::
The *add peer* command allows a new NTP peer to be added whilst
*chronyd* is running.
+
Following the words *add peer*, the syntax of the following
parameters and options is similar to that for the
<<chrony.conf.adoc#peer,*peer*>> directive in the configuration file.
The following peer options can be set in the command: *port*, *minpoll*,
*maxpoll*, *presend*, *maxdelayratio*, *maxdelay*, *key*.
+
An example of using this command is shown below.
+
----
add peer foo.example.net minpoll 6 maxpoll 10 key 25
----

[[add_server]]*add server* _address_ [_option_]...::
The *add server* command allows a new NTP server to be added whilst
*chronyd* is running.
+
Following the words *add server*, the syntax of the following parameters and
options is similar to that for the <<chrony.conf.adoc#server,*server*>>
directive in the configuration file.
The following server options can be set in the command: *port*, *minpoll*,
*maxpoll*, *presend*, *maxdelayratio*, *maxdelay*, *key*.
+
An example of using this command is shown below:
+
----
add server foo.example.net minpoll 6 maxpoll 10 key 25
----

[[delete]]*delete* _address_::
The *delete* command allows an NTP server or peer to be removed
from the current set of sources.

[[burst]]
*burst* _good_/_max_ [_mask_/_masked-address_]::
*burst* _good_/_max_ [_masked-address_/_masked-bits_]::
*burst* _good_/_max_ [_address_]::
The *burst* command tells *chronyd* to make a set of measurements to each of
its NTP sources over a short duration (rather than the usual periodic
measurements that it makes). After such a burst, *chronyd* will revert to the
previous state for each source. This might be either online, if the source was
being periodically measured in the normal way, or offline, if the source had
been indicated as being offline. (A source can be switched between the online
and offline states with the <<online,*online*>> and <<offline,*offline*>>
commands.)
+
The _mask_ and _masked-address_ arguments are optional, in which case *chronyd*
will initiate a burst for all of its currently defined sources.
+
The arguments have the following meaning and format:
+
_good_:::
This defines the number of good measurements that *chronyd* will want to
obtain from each source. A measurement is good if it passes certain tests,
for example, the round trip time to the source must be acceptable. (This
allows *chronyd* to reject measurements that are likely to be bogus.)
_max_:::
This defines the maximum number of measurements that *chronyd* will attempt
to make, even if the required number of good measurements has not been
obtained.
_mask_:::
This is an IP address with which the IP address of each of *chronyd*'s
sources is to be masked.
_masked-address_:::
This is an IP address. If the masked IP address of a source matches this
value then the burst command is applied to that source.
_masked-bits_:::
This can be used with _masked-address_ for CIDR notation, which is a shorter
alternative to the form with mask.
_address_:::
This is an IP address or a hostname. The burst command is applied only to
that source.
::
+
If no _mask_ or _masked-address_ arguments are provided, every source will be
matched.
+
An example of the two-argument form of the command is:
+
----
burst 2/10
----
+
This will cause *chronyd* to attempt to get two good measurements from each
source, stopping after two have been obtained, but in no event will it try more
than ten probes to the source.
+
Examples of the four-argument form of the command are:
+
----
burst 2/10 255.255.0.0/1.2.0.0
burst 2/10 2001:db8:789a::/48
----
+
In the first case, the two out of ten sampling will only be applied to sources
whose IPv4 addresses are of the form _1.2.x.y_, where _x_ and _y_ are
arbitrary. In the second case, the sampling will be applied to sources whose
IPv6 addresses have first 48 bits equal to _2001:db8:789a_.
+
Example of the three-argument form of the command is:
+
----
burst 2/10 foo.example.net
----

[[maxdelay]]*maxdelay* _address_ _delay_::
This allows the *maxdelay* option for one of the sources to be modified, in the
same way as specifying the *maxdelay* option for the
<<chrony.conf.adoc#server,*server*>> directive in the configuration file.

[[maxdelaydevratio]]*maxdelaydevratio* _address_ _ratio_::
This allows the *maxdelaydevratio* option for one of the sources to be
modified, in the same way as specifying the *maxdelaydevratio* option for the
<<chrony.conf.adoc#server,*server*>> directive in the configuration file.

[[maxdelayratio]]*maxdelayratio* _address_ _ratio_::
This allows the *maxdelayratio* option for one of the sources to be modified,
in the same way as specifying the *maxdelayratio* option for the
<<chrony.conf.adoc#server,*server*>> directive in the configuration file.

[[maxpoll]]*maxpoll* _address_ _maxpoll_::
The *maxpoll* command is used to modify the maximum polling interval for one of
the current set of sources. It is equivalent to the *maxpoll* option in the
<<chrony.conf.adoc#server,*server*>> directive in the configuration file.
+
Note that the new maximum polling interval only takes effect after the next
measurement has been made.

[[minpoll]]*minpoll* _address_ _minpoll_::
The *minpoll* command is used to modify the minimum polling interval for one of
the current set of sources. It is equivalent to the *minpoll* option in the
<<chrony.conf.adoc#server,*server*>> directive in the configuration file.
+
Note that the new minimum polling interval only takes effect after the next
measurement has been made.

[[minstratum]]*minstratum* _address_ _minstratum_::
The *minstratum* command is used to modify the minimum stratum for one of the
current set of sources. It is equivalent to the *minstratum* option in the
<<chrony.conf.adoc#server,*server*>> directive in the configuration file.

[[offline]]
*offline* [_address_]::
*offline* [_masked-address_/_masked-bits_]::
*offline* [_mask_/_masked-address_]::
The *offline* command is used to warn *chronyd* that the network connection to
a particular host or hosts is about to be lost, e.g. on computers with
intermittent connection to their time sources.
+
Another case where *offline* could be used is where a computer serves time to a
local group of computers, and has a permanent connection to true time servers
outside the organisation. However, the external connection is heavily loaded at
certain times of the day and the measurements obtained are less reliable at
those times. In this case, it is probably most useful to determine the
gain or loss rate during the quiet periods and let the whole network coast through
the loaded periods. The *offline* and *online* commands can be used to achieve
this.
+
There are four forms of the *offline* command. The first form is a wildcard,
meaning all sources. The second form allows an IP address mask and a masked
address to be specified. The third form uses CIDR notation. The fourth form
uses an IP address or a hostname. These forms are illustrated below.
+
----
offline
offline 255.255.255.0/1.2.3.0
offline 2001:db8:789a::/48
offline foo.example.net
----
+
The second form means that the *offline* command is to be applied to any source
whose IPv4 address is in the _1.2.3_ subnet. (The host's address is logically
and-ed with the mask, and if the result matches the _masked-address_ the host
is processed.) The third form means that the command is to be applied to all
sources whose IPv6 addresses have their first 48 bits equal to _2001:db8:789a_. The
fourth form means that the command is to be applied only to that one source.
+
The wildcard form of the address is equivalent to:
+
----
offline 0.0.0.0/0.0.0.0
offline ::/0
----

[[online]]
*online* [_address_]::
*online* [_masked-address_/_masked-bits_]::
*online* [_mask_/_masked-address_]::
The *online* command is opposite in function to the <<offline,*offline*>>
command. It is used to advise *chronyd* that network connectivity to a
particular source or sources has been restored.
+
The syntax is identical to that of the <<offline,*offline*>> command.

[[polltarget]]*polltarget* _address_ _polltarget_::
The *polltarget* command is used to modify the poll target for one of the
current set of sources. It is equivalent to the *polltarget* option in the
<<chrony.conf.adoc#server,*server*>> directive in the configuration file.

[[refresh]]*refresh*::
The *refresh* command can be used to force *chronyd* to resolve the names of
configured sources to IP addresses again, e.g. after suspending and resuming
the machine in a different network.
+
Sources that stop responding will be replaced with newly resolved addresses
automatically after 8 polling intervals, but this command can still be useful
to replace them immediately and not wait until they are marked as unreachable.

=== Manual time input

[[manual]]
*manual* *on*::
*manual* *off*::
*manual* *delete* _index_::
*manual* *list*::
*manual* *reset*::
The manual command enables and disables use of the <<settime,*settime*>>
command, and is used to modify the behaviour of the manual clock driver.
+
The *on* form of the command enables use of the *settime* command.
+
The *off* form of the command disables use of the *settime* command.
+
The *list* form of the command lists all the samples currently stored in
*chronyd*. The output is illustrated below.
+
----
210 n_samples = 1
#    Date  Time(UTC)    Slewed   Original   Residual
====================================================
 0 27Jan99 22:09:20       0.00       0.97       0.00
----
+
The columns are as as follows:
+
. The sample index (used for the *manual delete* command).
. The date and time of the sample.
. The system clock error when the timestamp was entered, adjusted to allow
  for changes made to the system clock since.
. The system clock error when the timestamp was entered, as it originally was
  (without allowing for changes to the system clock since).
. The regression residual at this point, in seconds. This allows '`outliers`'
  to be easily spotted, so that they can be deleted using the *manual delete*
  command.
::
+
The *delete* form of the command deletes a single sample. The parameter is the
index of the sample, as shown in the first column of the output from *manual
list*. Following deletion of the data point, the current error and drift rate
are re-estimated from the remaining data points and the system clock trimmed if
necessary. This option is intended to allow '`outliers`' to be discarded, i.e.
samples where the administrator realises they have entered a very poor
timestamp.
+
The *reset* form of the command deletes all samples at once. The system clock
is left running as it was before the command was entered.

[[settime]]*settime* _time_::
The *settime* command allows the current time to be entered manually, if this
option has been configured into *chronyd*. (It can be configured either with
the <<chrony.conf.adoc#manual,*manual*>> directive in the configuration file,
or with the <<manual,*manual*>> command of *chronyc*.)
+
It should be noted that the computer's sense of time will only be as accurate
as the reference you use for providing this input (e.g. your watch), as well as
how well you can time the press of the return key.
+
Providing your computer's time zone is set up properly, you will be able to
enter a local time (rather than UTC).
+
The response to a successful *settime* command indicates the amount that the
computer's clock was wrong. It should be apparent from this if you have entered
the time wrongly, e.g. with the wrong time zone.
+
The rate of drift of the system clock is estimated by a regression process
using the entered measurement and all previous measurements entered during the
present run of *chronyd*. However, the entered measurement is used for
adjusting the current clock offset (rather than the estimated intercept from
the regression, which is ignored). Contrast what happens with the
<<manual,*manual delete*>> command, where the intercept is used to set the
current offset (since there is no measurement that has just been entered in
that case).
+
The time is parsed by the public domain _getdate_ algorithm. Consequently, you
can only specify time to the nearest second.
+
Examples of inputs that are valid are shown below:
+
----
settime 16:30
settime 16:30:05
settime Nov 21, 2015 16:30:05
----
+
For a full description of getdate, see the getdate documentation
(bundled, for example, with the source for GNU tar).

=== NTP access

[[accheck]]*accheck* _address_::
This command allows you to check whether client NTP access is allowed from a
particular host.
+
Examples of use, showing a named host and a numeric IP address, are as follows:
+
----
accheck foo.example.net
accheck 1.2.3.4
accheck 2001:db8::1
----
+
This command can be used to examine the effect of a series of *allow*, *allow
all*, *deny*, and *deny all* commands specified either via *chronyc*, or in
*chronyd*'s configuration file.

[[clients]]*clients*::
This command shows a list of clients that have accessed the server, through
either the NTP or command ports. It does not include accesses over
the Unix domain command socket. There are no arguments.
+
An example of the output is:
+
----
Hostname                      NTP   Drop Int IntL Last     Cmd   Drop Int  Last
===============================================================================
localhost                       2      0   2   -   133      15      0  -1     7
foo.example.net                12      0   6   -    23       0      0   -     -
----
+
Each row shows the data for a single host. Only hosts that have passed the host
access checks (set with the <<allow,*allow*>>, <<deny,*deny*>>,
<<cmdallow,*cmdallow*>> and <<cmddeny,*cmddeny*>> commands or configuration
file directives) are logged. The intervals are displayed as a power of 2 in
seconds.
+
The columns are as follows:
+
. The hostname of the client.
. The number of NTP packets received from the client.
. The number of NTP packets dropped to limit the response rate.
. The average interval between NTP packets.
. The average interval between NTP packets after limiting the response rate.
. Time since the last NTP packet was received
. The number of command packets received from the client.
. The number of command packets dropped to limit the response rate.
. The average interval between command packets.
. Time since the last command packet was received.

[[serverstats]]*serverstats*::
The *serverstats* command displays how many valid NTP and command requests
*chronyd* as a server received from clients, how many of them were dropped to
limit the response rate as configured by the
<<chrony.conf.adoc#ratelimit,*ratelimit*>> and
<<chrony.conf.adoc#cmdratelimit,*cmdratelimit*>> directives, and how many
client log records were dropped due to the memory limit configured by the
<<chrony.conf.adoc#clientloglimit,*clientloglimit*>> directive. An example of
the output is shown below.
+
----
NTP packets received       : 1598
NTP packets dropped        : 8
Command packets received   : 19
Command packets dropped    : 0
Client log records dropped : 0
----

[[allow]]*allow* [*all*] [_subnet_]::
The effect of the allow command is identical to the
<<chrony.conf.adoc#allow,*allow*>> directive in the configuration file.
+
The syntax is illustrated in the following examples:
+
----
allow foo.example.net
allow all 1.2
allow 3.4.5
allow 6.7.8/22
allow 6.7.8.9/22
allow 2001:db8:789a::/48
allow 0/0
allow ::/0
allow
allow all
----

[[deny]]*deny* [*all*] [_subnet_]::
The effect of the allow command is identical to the
<<chrony.conf.adoc#deny,*deny*>> directive in the configuration file.
+
The syntax is illustrated in the following examples:
+
----
deny foo.example.net
deny all 1.2
deny 3.4.5
deny 6.7.8/22
deny 6.7.8.9/22
deny 2001:db8:789a::/48
deny 0/0
deny ::/0
deny
deny all
----

[[local]]
*local* [_option_]...::
*local* *off*::
The *local* command allows *chronyd* to be told that it is to appear as a
reference source, even if it is not itself properly synchronised to an external
source. (This can be used on isolated networks, to allow one computer to be a
master time server with the other computers slaving to it.)
+
The first form enables the local reference mode on the host. The syntax is
identical to the <<chrony.conf.adoc#local,*local*>> directive in the
configuration file.
+
The second form disables the local reference mode.

[[smoothing]]*smoothing*::
The *smoothing* command displays the current state of the NTP server time
smoothing, which can be enabled with the
<<chrony.conf.adoc#smoothtime,*smoothtime*>> directive. An example of the
output is shown below.
+
----
Active         : Yes
Offset         : +1.000268817 seconds
Frequency      : -0.142859 ppm
Wander         : -0.010000 ppm per second
Last update    : 17.8 seconds ago
Remaining time : 19988.4 seconds
----
+
The fields are explained as follows:
+
*Active*:::
This shows if the server time smoothing is currently active. Possible values
are _Yes_ and _No_. If the *leaponly* option is included in the *smoothtime*
directive, _(leap second only)_ will be shown on the line.
*Offset*:::
This is the current offset applied to the time sent to NTP clients. Positive
value means the clients are getting time that's ahead of true time.
*Frequency*:::
The current frequency offset of the served time. Negative value means the
time observed by clients is running slower than true time.
*Wander*:::
The current frequency wander of the served time. Negative value means the
time observed by clients is slowing down.
*Last update*:::
This field shows how long ago the time smoothing process was updated, e.g.
*chronyd* accumulated a new measurement.
*Remaining time*:::
The time it would take for the smoothing process to get to zero offset and
frequency if there were no more updates.

[[smoothtime]]
*smoothtime* *activate*::
*smoothtime* *reset*::
The *smoothtime* command can be used to activate or reset the server time
smoothing process if it is configured with the
<<chrony.conf.adoc#smoothtime,*smoothtime*>> directive.

=== Monitoring access

[[cmdaccheck]]*cmdaccheck* _address_::
This command is similar to the <<accheck,*accheck*>> command, except that it is
used to check whether monitoring access is permitted from a named host.
+
Examples of use are as follows:
+
----
cmdaccheck foo.example.net
cmdaccheck 1.2.3.4
cmdaccheck 2001:db8::1
----

[[cmdallow]]*cmdallow* [*all*] [_subnet_]::
This is similar to the <<allow,*allow*>> command, except that it is used to
allow particular hosts or subnets to use *chronyc* to monitor with *chronyd* on
the current host.

[[cmddeny]]*cmddeny* [*all*] [_subnet_]::
This is similar to the <<deny,*deny*>> command, except that it is used to allow
particular hosts or subnets to use *chronyc* to monitor *chronyd* on the
current host.

=== Real-time clock (RTC)

[[rtcdata]]*rtcdata*::
The *rtcdata* command displays the current RTC parameters.
+
An example output is shown below.
+
----
RTC ref time (GMT) : Sat May 30 07:25:56 2015
Number of samples  : 10
Number of runs     : 5
Sample span period :  549
RTC is fast by     :    -1.632736 seconds
RTC gains time at  :  -107.623 ppm
----
+
The fields have the following meaning:
+
*RTC ref time (GMT)*:::
This is the RTC reading the last time its error was measured.
*Number of samples*:::
This is the number of previous measurements being used to determine the RTC
gain or loss rate.
*Number of runs*:::
This is the number of runs of residuals of the same sign following the
regression fit for (RTC error) versus (RTC time). A value which is small
indicates that the measurements are not well approximated by a linear model,
and that the algorithm will tend to delete the older measurements to improve
the fit.
*Sample span period*:::
This is the period that the measurements span (from the oldest to the
newest). Without a unit the value is in seconds; suffixes _m_ for minutes,
_h_ for hours, _d_ for days or _y_ for years can be used.
*RTC is fast by*:::
This is the estimate of how many seconds fast the RTC when it thought
the time was at the reference time (above). If this value is large, you
might (or might not) want to use the <<trimrtc,*trimrtc*>> command to bring the
RTC into line with the system clock. (Note, a large error will not affect
*chronyd*'s operation, unless it becomes so big as to start causing rounding
errors.)
*RTC gains time at*:::
This is the amount of time gained (positive) or lost (negative) by the real
time clock for each second that it ticks. It is measured in parts per
million. So if the value shown was +1, suppose the RTC was exactly right when
it crosses a particular second boundary. Then it would be 1 microsecond fast
when it crosses its next second boundary.

[[trimrtc]]*trimrtc*::
The *trimrtc* command is used to correct the system's real-time clock (RTC) to
the main system clock. It has no effect if the error between the two clocks is
currently estimated at less than a second.
+
The command takes no arguments. It performs the following steps (if the RTC is
more than 1 second away from the system clock):
+
. Remember the currently estimated gain or loss rate of the RTC and flush the
  previous measurements.
. Step the real-time clock to bring it within a second of the system clock.
. Make several measurements to accurately determine the new offset between
  the RTC and the system clock (i.e. the remaining fraction of a second
  error).
. Save the RTC parameters to the RTC file (specified with the
  <<chrony.conf.adoc#rtcfile,*rtcfile*>> directive in the configuration file).
::
+
The last step is done as a precaution against the computer suffering a power
failure before either the daemon exits or the <<writertc,*writertc*>> command
is issued.
+
*chronyd* will still work perfectly well both whilst operating and across
machine reboots even if the *trimrtc* command is never used (and the RTC is
allowed to drift away from true time). The *trimrtc* command is provided as a
method by which it can be corrected, in a manner compatible with *chronyd*
using it to maintain accurate time across machine reboots.
+
The *trimrtc* command can be executed automatically by *chronyd* with the
<<chrony.conf.adoc#rtcautotrim,*rtcautotrim*>> directive in the configuration
file.

[[writertc]]*writertc*::
The *writertc* command writes the currently estimated error and gain or loss rate
parameters for the RTC to the RTC file (specified with the
<<chrony.conf.adoc#rtcfile,*rtcfile*>> directive). This information is also
written automatically when *chronyd* is killed (by the SIGHUP, SIGINT, SIGQUIT
or SIGTERM signals) or when the <<trimrtc,*trimrtc*>> command is issued.

=== Other daemon commands

[[cyclelogs]]*cyclelogs*::
The *cyclelogs* command causes all of *chronyd*'s open log files to be closed
and re-opened. This allows them to be renamed so that they can be periodically
purged. An example of how to do this is shown below.
+
----
# mv /var/log/chrony/measurements.log /var/log/chrony/measurements1.log
# chronyc cyclelogs
# ls -l /var/log/chrony
-rw-r--r--   1 root     root            0 Jun  8 18:17 measurements.log
-rw-r--r--   1 root     root        12345 Jun  8 18:17 measurements1.log
# rm -f measurements1.log
----

[[dump]]*dump*::
The *dump* command causes *chronyd* to write its current history of
measurements for each of its sources to dump files in the directory specified
in the configuration file by the <<chrony.conf.adoc#dumpdir,*dumpdir*>>
directive. Note that *chronyd* does this automatically when it exits. This
command is mainly useful for inspection of the history whilst *chronyd* is
running.

[[rekey]]*rekey*::
The *rekey* command causes *chronyd* to re-read the key file specified in the
configuration file by the <<chrony.conf.adoc#keyfile,*keyfile*>> directive.

=== Client commands

[[dns]]*dns* _option_::
The *dns* command configures how hostnames and IP addresses are resolved in
*chronyc*. IP addresses can be resolved to hostnames when printing results of
<<sources,*sources*>>, <<sourcestats,*sourcestats*>>, <<tracking,*tracking*>>
and <<clients,*clients*>> commands. Hostnames are resolved in commands that
take an address as argument.
+
There are five options:
+
*dns -n*:::
Disables resolving IP addresses to hostnames. Raw IP addresses will be
displayed.
*dns +n*:::
Enables resolving IP addresses to hostnames. This is the default unless
*chronyc* was started with *-n* option.
*dns -4*:::
Resolves hostnames only to IPv4 addresses.
*dns -6*:::
Resolves hostnames only to IPv6 addresses.
*dns -46*:::
Resolves hostnames to both address families. This is the default behaviour
unless *chronyc* was started with the *-4* or *-6* option.

[[timeout]]*timeout* _timeout_::
The *timeout* command sets the initial timeout for *chronyc* requests in
milliseconds. If no response is received from *chronyd*, the timeout is doubled
and the request is resent. The maximum number of retries is configured with the
<<retries,*retries*>> command.
+
By default, the timeout is 1000 milliseconds.

[[retries]]*retries* _retries_::
The *retries* command sets the maximum number of retries for *chronyc* requests
before giving up. The response timeout is controlled by the
<<timeout,*timeout*>> command.
+
The default is 2.

[[keygen]]*keygen* [_id_ [_type_ [_bits_]]]::
The *keygen* command generates a key that can be added to the
key file (specified with the <<chrony.conf.adoc#keyfile,*keyfile*>> directive)
to allow NTP authentication between server and client, or peers. The key is
generated from the _/dev/urandom_ device and it is printed to standard output.
+
The command has three optional arguments. The first argument is the key number
(by default 1), which will be specified with the *key* option of the *server*
or *peer* directives in the configuration file. The second argument is the hash
function (by default SHA1 or MD5 if SHA1 is not available) and the third
argument is the number of bits the key should have, between 80 and 4096 bits
(by default 160 bits).
+
An example is:
+
----
keygen 73 SHA1 256
----
+
which generates a 256-bit SHA1 key with number 73. The printed line should
then be securely transferred and added to the key files on both server and
client, or peers.

[[exit]]*exit*::
[[quit]]*quit*::
The *exit* and *quit* commands exit from *chronyc* and return the user to the shell.

[[help]]*help*::
The *help* command displays a summary of the commands and their arguments.

== SEE ALSO

<<chrony.conf.adoc#,*chrony.conf(5)*>>, <<chronyd.adoc#,*chronyd(8)*>>

== BUGS

For instructions on how to report bugs, please visit
https://chrony.tuxfamily.org/.

== AUTHORS

chrony was written by Richard Curnow, Miroslav Lichvar, and others.
",12500,False,2469.8843399283687,median
"/**
 *    Copyright (C) 2013 10gen Inc.
 *
 *    This program is free software: you can redistribute it and/or  modify
 *    it under the terms of the GNU Affero General Public License, version 3,
 *    as published by the Free Software Foundation.
 *
 *    This program is distributed in the hope that it will be useful,
 *    but WITHOUT ANY WARRANTY; without even the implied warranty of
 *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *    GNU Affero General Public License for more details.
 *
 *    You should have received a copy of the GNU Affero General Public License
 *    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 *    As a special exception, the copyright holders give permission to link the
 *    code of portions of this program with the OpenSSL library under certain
 *    conditions as described in each individual source file and distribute
 *    linked combinations including the program with the OpenSSL library. You
 *    must comply with the GNU Affero General Public License in all respects
 *    for all of the code used other than as permitted herein. If you modify
 *    file(s) with this exception, you may extend this exception to your
 *    version of the file(s), but you are not obligated to do so. If you do not
 *    wish to do so, delete this exception statement from your version. If you
 *    delete this exception statement from all source files in the program,
 *    then also delete it in the license file.
 */

#define MONGO_LOG_DEFAULT_COMPONENT ::mongo::logger::LogComponent::kQuery

#include ""mongo/db/query/plan_enumerator.h""

#include <set>

#include ""mongo/db/query/index_tag.h""
#include ""mongo/db/query/indexability.h""
#include ""mongo/util/log.h""
#include ""mongo/util/string_map.h""

namespace {

using namespace mongo;
using std::unique_ptr;
using std::endl;
using std::set;
using std::string;
using std::vector;

std::string getPathPrefix(std::string path) {
    if (mongoutils::str::contains(path, '.')) {
        return mongoutils::str::before(path, '.');
    } else {
        return path;
    }
}

/**
 * Returns true if either 'node' or a descendent of 'node'
 * is a predicate that is required to use an index.
 */
bool expressionRequiresIndex(const MatchExpression* node) {
    return CanonicalQuery::countNodes(node, MatchExpression::GEO_NEAR) > 0 ||
        CanonicalQuery::countNodes(node, MatchExpression::TEXT) > 0;
}

size_t getPathLength(const MatchExpression* expr) {
    return FieldRef{expr->path()}.numParts();
}

/**
 * Returns true if 'component' refers to a part of 'rt->path' outside the innermost $elemMatch
 * expression, and returns false otherwise. In particular, this function returns false if an
 * expression isn't contained in an $elemMatch.
 *
 * For example, consider the expression {a: {$elemMatch: {b: {$gte: 0, $lt: 10}}}. The path ""a.b""
 * (component=1) is inside the $elemMatch expression, whereas the path ""a"" (component=0) is outside
 * the $elemMatch expression.
 */
bool isPathOutsideElemMatch(const RelevantTag* rt, size_t component) {
    if (rt->elemMatchExpr == nullptr) {
        return false;
    }

    const size_t elemMatchRootLength = getPathLength(rt->elemMatchExpr);
    invariant(elemMatchRootLength > 0);
    return component < elemMatchRootLength;
}

using PossibleFirstAssignment = std::vector<MatchExpression*>;

void getPossibleFirstAssignments(const IndexEntry& thisIndex,
                                 const vector<MatchExpression*>& predsOverLeadingField,
                                 std::vector<PossibleFirstAssignment>* possibleFirstAssignments) {
    invariant(thisIndex.multikey && !thisIndex.multikeyPaths.empty());

    if (thisIndex.multikeyPaths[0].empty()) {
        // No prefix of the leading index field causes the index to be multikey. In other words, the
        // index isn't multikey as a result of the leading index field. We can then safely assign
        // all predicates on it to the index and the access planner will intersect the bounds.
        *possibleFirstAssignments = {predsOverLeadingField};
        return;
    }

    // At least one prefix of the leading index field causes the index to be multikey. We can't
    // intersect bounds on the leading index field unless the predicates are joined by an
    // $elemMatch.
    std::map<MatchExpression*, std::vector<MatchExpression*>> predsByElemMatchExpr;
    for (auto* pred : predsOverLeadingField) {
        invariant(pred->getTag());
        RelevantTag* rt = static_cast<RelevantTag*>(pred->getTag());

        if (rt->elemMatchExpr == nullptr) {
            // 'pred' isn't part of an $elemMatch, so we can't assign any other predicates on the
            // leading index field to the index.
            possibleFirstAssignments->push_back({pred});
        } else {
            // 'pred' is part of an $elemMatch, so we group it together with any other leaf
            // expressions in the same $elemMatch context.
            predsByElemMatchExpr[rt->elemMatchExpr].push_back(pred);
        }
    }

    // We can only assign all of the leaf expressions in the $elemMatch to the index if no prefix of
    // the leading index field that is longer than the root of the $elemMatch causes the index to be
    // multikey. For example, consider the index {'a.b': 1} and the query
    // {a: $elemMatch: {b: {$gte: 0, $lt: 10}}}. If 'a.b' refers to an array value, then the two
    // leaf expressions inside the $elemMatch can match distinct elements. We are therefore unable
    // to assign both to the index and intersect the bounds.
    for (const auto& elemMatchExprIt : predsByElemMatchExpr) {
        invariant(!elemMatchExprIt.second.empty());
        const auto* pred = elemMatchExprIt.second.front();

        invariant(pred->getTag());
        RelevantTag* rt = static_cast<RelevantTag*>(pred->getTag());
        invariant(rt->elemMatchExpr != nullptr);

        const size_t elemMatchRootLength = getPathLength(elemMatchExprIt.first);
        invariant(elemMatchRootLength > 0);

        // Since the multikey path components are 0-indexed, 'elemMatchRootLength' actually
        // corresponds to the path component immediately following the root of the $elemMatch.
        if (thisIndex.multikeyPaths[0].lower_bound(elemMatchRootLength) ==
            thisIndex.multikeyPaths[0].end()) {
            // The root of the $elemMatch is the longest prefix of the leading index field that
            // causes the index to be multikey, so we can assign all of the leaf expressions in the
            // $elemMatch to the index.
            possibleFirstAssignments->push_back(elemMatchExprIt.second);
        } else {
            // There is a path longer than the root of the $elemMatch that causes the index to be
            // multikey, so we can only assign one of the leaf expressions in the $elemMatch to the
            // index. Since we don't know which one is the most selective, we generate a plan for
            // each predicate and rank them against each other.
            for (auto* predCannotIntersect : elemMatchExprIt.second) {
                possibleFirstAssignments->push_back({predCannotIntersect});
            }
        }
    }
}

/**
 * Returns true if the leaf expression associated with 'rt' can be assigned to the index given the
 * path prefixes of the queried field that cause the index to be multikey and the predicates already
 * assigned to the index. Otherwise, this function returns false if the leaf expression associated
 * with 'rt' can't be assigned to the index.
 *
 * This function modifies 'used' under the assumption that if it returns true, then the predicate
 * will be assigned to the index.
 */
bool canAssignPredToIndex(const RelevantTag* rt,
                          const std::set<size_t>& multikeyComponents,
                          StringMap<MatchExpression*>* used) {
    invariant(used);
    const FieldRef path(rt->path);

    // We start by checking with the shortest prefix of the queried path to avoid needing to undo
    // any changes we make to 'used' as we go.
    for (const auto multikeyComponent : multikeyComponents) {
        // 'pathPrefix' is a prefix of a queried path that causes the index to be multikey.
        StringData pathPrefix = path.dottedSubstring(0, multikeyComponent + 1);

        auto search = used->find(pathPrefix);
        if (search == used->end()) {
            // 'pathPrefix' is a prefix of a queried path that we haven't seen before.
            if (isPathOutsideElemMatch(rt, multikeyComponent)) {
                // 'pathPrefix' is outside the innermost $elemMatch, so we record its $elemMatch
                // context to ensure that we don't assign another predicate to 'thisIndex' along
                // this path unless they are part of the same $elemMatch.
                invariant(rt->elemMatchExpr != nullptr);
                (*used)[pathPrefix] = rt->elemMatchExpr;
            } else {
                // 'pathPrefix' is either inside the innermost $elemMatch or not inside an
                // $elemMatch at all. We record that we can't assign another predicate to
                // 'thisIndex' either at or beyond 'pathPrefix' without violating the intersecting
                // and compounding rules for multikey indexes.
                (*used)[pathPrefix] = nullptr;

                // Since we check starting with the shortest prefixes of the queried path that cause
                // 'thisIndex' to be multikey, marking 'used' with nullptr here means that there
                // will be no further attempts to intersect or compound bounds by assigning a
                // different predicate at or beyond 'pathPrefix'.
                break;
            }
        } else {
            // 'pathPrefix' is a prefix of a queried path that we've already assigned to
            // 'thisIndex'. We can only intersect or compound bounds by assigning 'couldAssignPred'
            // to 'thisIndex' if the leaf expressions are joined by the same $elemMatch context.
            const bool cannotAssignPred =
                (search->second == nullptr || search->second != rt->elemMatchExpr);
            if (cannotAssignPred) {
                return false;
            }
        }
    }
    return true;
}

/**
 * Tags each node of the tree with the lowest numbered index that the sub-tree rooted at that
 * node uses.
 *
 * Nodes that satisfy Indexability::nodeCanUseIndexOnOwnField are already tagged if there
 * exists an index that that node can use.
 */
void tagForSort(MatchExpression* tree) {
    if (!Indexability::nodeCanUseIndexOnOwnField(tree)) {
        size_t myTagValue = IndexTag::kNoIndex;
        for (size_t i = 0; i < tree->numChildren(); ++i) {
            MatchExpression* child = tree->getChild(i);
            tagForSort(child);
            if (child->getTag() &&
                child->getTag()->getType() == MatchExpression::TagData::Type::IndexTag) {
                IndexTag* childTag = static_cast<IndexTag*>(child->getTag());
                myTagValue = std::min(myTagValue, childTag->index);
            } else if (child->getTag() &&
                       child->getTag()->getType() ==
                           MatchExpression::TagData::Type::OrPushdownTag) {
                OrPushdownTag* childTag = static_cast<OrPushdownTag*>(child->getTag());
                if (childTag->getIndexTag()) {
                    const IndexTag* indexTag =
                        static_cast<const IndexTag*>(childTag->getIndexTag());
                    myTagValue = std::min(myTagValue, indexTag->index);
                }
            }
        }
        if (myTagValue != IndexTag::kNoIndex) {
            tree->setTag(new IndexTag(myTagValue));
        }
    }
}

}  // namespace


namespace mongo {

PlanEnumerator::PlanEnumerator(const PlanEnumeratorParams& params)
    : _root(params.root),
      _indices(params.indices),
      _ixisect(params.intersect),
      _orLimit(params.maxSolutionsPerOr),
      _intersectLimit(params.maxIntersectPerAnd) {}

PlanEnumerator::~PlanEnumerator() {
    typedef unordered_map<MemoID, NodeAssignment*> MemoMap;
    for (MemoMap::iterator it = _memo.begin(); it != _memo.end(); ++it) {
        delete it->second;
    }
}

Status PlanEnumerator::init() {
    // Fill out our memo structure from the tagged _root.
    _done = !prepMemo(_root, PrepMemoContext());

    // Dump the tags.  We replace them with IndexTag instances.
    _root->resetTag();

    return Status::OK();
}

std::string PlanEnumerator::dumpMemo() {
    mongoutils::str::stream ss;

    // Note that this needs to be kept in sync with allocateAssignment which assigns memo IDs.
    for (size_t i = 1; i < _memo.size(); ++i) {
        ss << ""[Node #"" << i << ""]: "" << _memo[i]->toString() << ""\\n"";
    }
    return ss;
}

string PlanEnumerator::NodeAssignment::toString() const {
    if (NULL != andAssignment) {
        mongoutils::str::stream ss;
        ss << ""AND enumstate counter "" << andAssignment->counter;
        for (size_t i = 0; i < andAssignment->choices.size(); ++i) {
            ss << ""\\n\\tchoice "" << i << "":\\n"";
            const AndEnumerableState& state = andAssignment->choices[i];
            ss << ""\\t\\tsubnodes: "";
            for (size_t j = 0; j < state.subnodesToIndex.size(); ++j) {
                ss << state.subnodesToIndex[j] << "" "";
            }
            ss << '\\n';
            for (size_t j = 0; j < state.assignments.size(); ++j) {
                const OneIndexAssignment& oie = state.assignments[j];
                ss << ""\\t\\tidx["" << oie.index << ""]\\n"";

                for (size_t k = 0; k < oie.preds.size(); ++k) {
                    ss << ""\\t\\t\\tpos "" << oie.positions[k] << "" pred "" << oie.preds[k]->toString();
                }
            }
        }
        return ss;
    } else if (NULL != arrayAssignment) {
        mongoutils::str::stream ss;
        ss << ""ARRAY SUBNODES enumstate "" << arrayAssignment->counter << ""/ ONE OF: [ "";
        for (size_t i = 0; i < arrayAssignment->subnodes.size(); ++i) {
            ss << arrayAssignment->subnodes[i] << "" "";
        }
        ss << ""]"";
        return ss;
    } else {
        verify(NULL != orAssignment);
        mongoutils::str::stream ss;
        ss << ""ALL OF: [ "";
        for (size_t i = 0; i < orAssignment->subnodes.size(); ++i) {
            ss << orAssignment->subnodes[i] << "" "";
        }
        ss << ""]"";
        return ss;
    }
}

PlanEnumerator::MemoID PlanEnumerator::memoIDForNode(MatchExpression* node) {
    unordered_map<MatchExpression*, MemoID>::iterator it = _nodeToId.find(node);

    if (_nodeToId.end() == it) {
        error() << ""Trying to look up memo entry for node, none found."";
        invariant(0);
    }

    return it->second;
}

bool PlanEnumerator::getNext(MatchExpression** tree) {
    if (_done) {
        return false;
    }

    // Tag with our first solution.
    tagMemo(memoIDForNode(_root));

    *tree = _root->shallowClone().release();
    tagForSort(*tree);

    _root->resetTag();
    LOG(5) << ""Enumerator: memo just before moving:"" << endl << dumpMemo();
    _done = nextMemo(memoIDForNode(_root));
    return true;
}

//
// Structure creation
//

void PlanEnumerator::allocateAssignment(MatchExpression* expr,
                                        NodeAssignment** assign,
                                        MemoID* id) {
    // We start at 1 so that the lookup of any entries not explicitly allocated
    // will refer to an invalid memo slot.
    size_t newID = _memo.size() + 1;

    // Shouldn't be anything there already.
    verify(_nodeToId.end() == _nodeToId.find(expr));
    _nodeToId[expr] = newID;
    verify(_memo.end() == _memo.find(newID));
    NodeAssignment* newAssignment = new NodeAssignment();
    _memo[newID] = newAssignment;
    *assign = newAssignment;
    *id = newID;
}

bool PlanEnumerator::prepMemo(MatchExpression* node, PrepMemoContext context) {
    PrepMemoContext childContext;
    childContext.elemMatchExpr = context.elemMatchExpr;
    childContext.outsidePreds = context.outsidePreds;

    if (MatchExpression::OR == node->matchType()) {
        // For an OR to be indexed, all its children must be indexed.
        for (size_t i = 0; i < node->numChildren(); ++i) {

            // Extend the path through the indexed ORs of each outside predicate.
            auto childContextCopy = childContext;
            for (auto& pred : childContextCopy.outsidePreds) {
                pred.second.push_back(i);
            }

            if (!prepMemo(node->getChild(i), childContextCopy)) {
                return false;
            }
        }

        // If we're here we're fully indexed and can be in the memo.
        size_t myMemoID;
        NodeAssignment* assign;
        allocateAssignment(node, &assign, &myMemoID);

        OrAssignment* orAssignment = new OrAssignment();
        for (size_t i = 0; i < node->numChildren(); ++i) {
            orAssignment->subnodes.push_back(memoIDForNode(node->getChild(i)));
        }
        assign->orAssignment.reset(orAssignment);
        return true;
    } else if (Indexability::arrayUsesIndexOnChildren(node)) {
        // Add each of our children as a subnode.  We enumerate through each subnode one at a
        // time until it's exhausted then we move on.
        unique_ptr<ArrayAssignment> aa(new ArrayAssignment());

        if (MatchExpression::ELEM_MATCH_OBJECT == node->matchType()) {
            childContext.elemMatchExpr = node;
        }

        // For an OR to be indexed, all its children must be indexed.
        for (size_t i = 0; i < node->numChildren(); ++i) {
            if (prepMemo(node->getChild(i), childContext)) {
                aa->subnodes.push_back(memoIDForNode(node->getChild(i)));
            }
        }

        if (0 == aa->subnodes.size()) {
            return false;
        }

        size_t myMemoID;
        NodeAssignment* assign;
        allocateAssignment(node, &assign, &myMemoID);

        assign->arrayAssignment.reset(aa.release());
        return true;
    } else if (Indexability::nodeCanUseIndexOnOwnField(node) ||
               Indexability::isBoundsGeneratingNot(node) ||
               (MatchExpression::AND == node->matchType())) {
        // Map from idx id to children that have a pred over it.

        // TODO: The index intersection logic could be simplified if we could iterate over these
        // maps in a known order. Currently when iterating over these maps we have to impose an
        // ordering on each individual pair of indices in order to make sure that the
        // enumeration results are order-independent. See SERVER-12196.
        IndexToPredMap idxToFirst;
        IndexToPredMap idxToNotFirst;

        // Children that aren't predicates, and which do not necessarily need
        // to use an index.
        vector<MemoID> subnodes;

        // Children that aren't predicates, but which *must* use an index.
        // (e.g. an OR which contains a TEXT child).
        vector<MemoID> mandatorySubnodes;

        // A list of predicates contained in the subtree rooted at 'node'
        // obtained by traversing deeply through $and and $elemMatch children.
        vector<MatchExpression*> indexedPreds;

        // Partition the childen into the children that aren't predicates which may or may
        // not be indexed ('subnodes'), children that aren't predicates which must use the
        // index ('mandatorySubnodes'). and children that are predicates ('indexedPreds').
        //
        // We have to get the subnodes with mandatory assignments rather than adding the
        // mandatory preds to 'indexedPreds'. Adding the mandatory preds directly to
        // 'indexedPreds' would lead to problems such as pulling a predicate beneath an OR
        // into a set joined by an AND.
        getIndexedPreds(node, childContext, &indexedPreds);
        // Pass in the indexed predicates as outside predicates when prepping the subnodes.
        auto childContextCopy = childContext;
        for (auto pred : indexedPreds) {
            childContextCopy.outsidePreds[pred] = std::deque<size_t>();
        }
        if (!prepSubNodes(node, childContextCopy, &subnodes, &mandatorySubnodes)) {
            return false;
        }

        if (mandatorySubnodes.size() > 1) {
            return false;
        }

        // There can only be one mandatory predicate (at most one $text, at most one
        // $geoNear, can't combine $text/$geoNear).
        MatchExpression* mandatoryPred = NULL;

        // There could be multiple indices which we could use to satisfy the mandatory
        // predicate. Keep the set of such indices. Currently only one text index is
        // allowed per collection, but there could be multiple 2d or 2dsphere indices
        // available to answer a $geoNear predicate.
        set<IndexID> mandatoryIndices;

        // Go through 'indexedPreds' and add the predicates to the
        // 'idxToFirst' and 'idxToNotFirst' maps.
        for (size_t i = 0; i < indexedPreds.size(); ++i) {
            MatchExpression* child = indexedPreds[i];

            invariant(Indexability::nodeCanUseIndexOnOwnField(child));

            RelevantTag* rt = static_cast<RelevantTag*>(child->getTag());

            if (expressionRequiresIndex(child)) {
                // 'child' is a predicate which *must* be tagged with an index.
                // This should include only TEXT and GEO_NEAR preds.

                // We expect either 0 or 1 mandatory predicates.
                invariant(NULL == mandatoryPred);

                // Mandatory predicates are TEXT or GEO_NEAR.
                invariant(MatchExpression::TEXT == child->matchType() ||
                          MatchExpression::GEO_NEAR == child->matchType());

                // The mandatory predicate must have a corresponding ""mandatory index"".
                invariant(rt->first.size() != 0 || rt->notFirst.size() != 0);

                mandatoryPred = child;

                // Find all of the indices that could be used to satisfy the pred,
                // and add them to the 'mandatoryIndices' set.
                mandatoryIndices.insert(rt->first.begin(), rt->first.end());
                mandatoryIndices.insert(rt->notFirst.begin(), rt->notFirst.end());
            }

            for (size_t j = 0; j < rt->first.size(); ++j) {
                idxToFirst[rt->first[j]].push_back(child);
            }

            for (size_t j = 0; j < rt->notFirst.size(); ++j) {
                idxToNotFirst[rt->notFirst[j]].push_back(child);
            }
        }

        // If none of our children can use indices, bail out.
        if (idxToFirst.empty() && idxToNotFirst.empty() && (subnodes.size() == 0) &&
            (mandatorySubnodes.size() == 0)) {
            return false;
        }

        AndAssignment* andAssignment = new AndAssignment();

        size_t myMemoID;
        NodeAssignment* nodeAssignment;
        allocateAssignment(node, &nodeAssignment, &myMemoID);
        // Takes ownership.
        nodeAssignment->andAssignment.reset(andAssignment);

        // Predicates which must use an index might be buried inside
        // a subnode. Handle that case here.
        if (1 == mandatorySubnodes.size()) {
            AndEnumerableState aes;
            aes.subnodesToIndex.push_back(mandatorySubnodes[0]);
            andAssignment->choices.push_back(std::move(aes));
            return true;
        }

        if (NULL != mandatoryPred) {
            // We must have at least one index which can be used to answer 'mandatoryPred'.
            invariant(!mandatoryIndices.empty());
            return enumerateMandatoryIndex(
                idxToFirst, idxToNotFirst, mandatoryPred, mandatoryIndices, andAssignment);
        }

        enumerateOneIndex(
            idxToFirst, idxToNotFirst, subnodes, childContext.outsidePreds, andAssignment);

        if (_ixisect) {
            enumerateAndIntersect(idxToFirst, idxToNotFirst, subnodes, andAssignment);
        }

        return !andAssignment->choices.empty();
    }

    // Don't know what the node is at this point.
    return false;
}

bool PlanEnumerator::enumerateMandatoryIndex(const IndexToPredMap& idxToFirst,
                                             const IndexToPredMap& idxToNotFirst,
                                             MatchExpression* mandatoryPred,
                                             const set<IndexID>& mandatoryIndices,
                                             AndAssignment* andAssignment) {
    // Generate index assignments for each index in 'mandatoryIndices'. We
    // must assign 'mandatoryPred' to one of these indices, but we try all
    // possibilities in 'mandatoryIndices' because some might be better than
    // others for this query.
    for (set<IndexID>::const_iterator indexIt = mandatoryIndices.begin();
         indexIt != mandatoryIndices.end();
         ++indexIt) {
        // We have a predicate which *must* be tagged to use an index.
        // Get the index entry for the index it should use.
        const IndexEntry& thisIndex = (*_indices)[*indexIt];

        // Only text, 2d, and 2dsphere index types should be able to satisfy
        // mandatory predicates.
        invariant(INDEX_TEXT == thisIndex.type || INDEX_2D == thisIndex.type ||
                  INDEX_2DSPHERE == thisIndex.type);

        OneIndexAssignment indexAssign;
        indexAssign.index = *indexIt;

        IndexToPredMap::const_iterator it = idxToFirst.find(*indexIt);
        if (idxToFirst.end() == it) {
            // We don't have any predicate to assign to the leading field of this index.
            // This means that we cannot generate a solution using this index, so we
            // just move on to the next index.
            continue;
        }

        const vector<MatchExpression*>& predsOverLeadingField = it->second;

        if (thisIndex.multikey && !thisIndex.multikeyPaths.empty()) {
            // 2dsphere indexes are the only special index type that should ever have path-level
            // multikey information.
            invariant(INDEX_2DSPHERE == thisIndex.type);

            if (predsOverLeadingField.end() != std::find(predsOverLeadingField.begin(),
                                                         predsOverLeadingField.end(),
                                                         mandatoryPred)) {
                // The mandatory predicate is on the leading field of 'thisIndex'. We assign it to
                // 'thisIndex' and skip assigning any other predicates on the leading field to
                // 'thisIndex' because no additional predicate on the leading field will generate a
                // more efficient data access plan.
                indexAssign.preds.push_back(mandatoryPred);
                indexAssign.positions.push_back(0);

                auto compIt = idxToNotFirst.find(indexAssign.index);
                if (compIt != idxToNotFirst.end()) {
                    // Assign any predicates on the non-leading index fields to 'indexAssign' that
                    // don't violate the intersecting or compounding rules for multikey indexes.
                    // We do not currently try to assign outside predicates to mandatory indexes.
                    const unordered_map<MatchExpression*, std::deque<size_t>> outsidePreds{};
                    assignMultikeySafePredicates(compIt->second, outsidePreds, &indexAssign);
                }
            } else {
                // Assign any predicates on the leading index field to 'indexAssign' that don't
                // violate the intersecting rules for multikey indexes.
                // We do not currently try to assign outside predicates to mandatory indexes.
                const unordered_map<MatchExpression*, std::deque<size_t>> outsidePreds{};
                assignMultikeySafePredicates(predsOverLeadingField, outsidePreds, &indexAssign);

                // Assign the mandatory predicate to 'thisIndex'. Due to how keys are generated for
                // 2dsphere indexes, it is always safe to assign a predicate on a distinct path to
                // 'thisIndex' and compound bounds; an index entry is produced for each combination
                // of unique values along all of the indexed fields, even if they are in separate
                // array elements. See SERVER-23533 for more details.
                compound({mandatoryPred}, thisIndex, &indexAssign);

                auto compIt = idxToNotFirst.find(indexAssign.index);
                if (compIt != idxToNotFirst.end()) {
                    // Copy the predicates on the non-leading index fields and remove
                    // 'mandatoryPred' to avoid assigning it twice to 'thisIndex'.
                    vector<MatchExpression*> predsOverNonLeadingFields = compIt->second;

                    auto mandIt = std::find(predsOverNonLeadingFields.begin(),
                                            predsOverNonLeadingFields.end(),
                                            mandatoryPred);
                    invariant(mandIt != predsOverNonLeadingFields.end());

                    predsOverNonLeadingFields.erase(mandIt);

                    // Assign any predicates on the non-leading index fields to 'indexAssign' that
                    // don't violate the intersecting or compounding rules for multikey indexes.
                    // We do not currently try to assign outside predicates to mandatory indexes.
                    assignMultikeySafePredicates(
                        predsOverNonLeadingFields, outsidePreds, &indexAssign);
                }
            }
        } else if (thisIndex.multikey) {
            // Special handling for multikey mandatory indices.
            if (predsOverLeadingField.end() != std::find(predsOverLeadingField.begin(),
                                                         predsOverLeadingField.end(),
                                                         mandatoryPred)) {
                // The mandatory predicate is over the first field of the index. Assign
                // it now.
                indexAssign.preds.push_back(mandatoryPred);
                indexAssign.positions.push_back(0);
            } else {
                // The mandatory pred is notFirst. Assign an arbitrary predicate
                // over the first position.
                invariant(!predsOverLeadingField.empty());
                indexAssign.preds.push_back(predsOverLeadingField[0]);
                indexAssign.positions.push_back(0);

                // Assign the mandatory predicate at the matching position in the compound
                // index. We do this in order to ensure that the mandatory predicate (and not
                // some other predicate over the same position in the compound index) gets
                // assigned.
                //
                // The bad thing that could happen otherwise: A non-mandatory predicate gets
                // chosen by getMultikeyCompoundablePreds(...) instead of 'mandatoryPred'.
                // We would then fail to assign the mandatory predicate, and hence generate
                // a bad data access plan.
                //
                // The mandatory predicate is assigned by calling compound(...) because
                // compound(...) has logic for matching up a predicate with the proper
                // position in the compound index.
                vector<MatchExpression*> mandatoryToCompound;
                mandatoryToCompound.push_back(mandatoryPred);
                compound(mandatoryToCompound, thisIndex, &indexAssign);

                // At this point we have assigned a predicate over the leading field and
                // we have assigned the mandatory predicate to a trailing field.
                //
                // Ex:
                //   Say we have index {a: 1, b: 1, c: ""2dsphere"", d: 1}. Also suppose that
                //   there is a $near predicate over ""c"", with additional predicates over
                //   ""a"", ""b"", ""c"", and ""d"". We will have assigned the $near predicate at
                //   position 2 and a predicate with path ""a"" at position 0.
            }

            // Compound remaining predicates in a multikey-safe way.
            IndexToPredMap::const_iterator compIt = idxToNotFirst.find(indexAssign.index);
            if (compIt != idxToNotFirst.end()) {
                const vector<MatchExpression*>& couldCompound = compIt->second;
                vector<MatchExpression*> tryCompound;

                getMultikeyCompoundablePreds(indexAssign.preds, couldCompound, &tryCompound);
                if (tryCompound.size()) {
                    compound(tryCompound, thisIndex, &indexAssign);
                }
            }
        } else {
            // For non-multikey, we don't have to do anything too special.
            // Just assign all ""first"" predicates and try to compound like usual.
            indexAssign.preds = it->second;

            // Since everything in assign.preds prefixes the index, they all go
            // at position '0' in the index, the first position.
            indexAssign.positions.resize(indexAssign.preds.size(), 0);

            // And now we begin compound analysis.

            // Find everything that could use assign.index but isn't a pred over
            // the first field of that index.
            IndexToPredMap::const_iterator compIt = idxToNotFirst.find(indexAssign.index);
            if (compIt != idxToNotFirst.end()) {
                compound(compIt->second, thisIndex, &indexAssign);
            }
        }

        // The mandatory predicate must be assigned.
        invariant(indexAssign.preds.end() !=
                  std::find(indexAssign.preds.begin(), indexAssign.preds.end(), mandatoryPred));

        // Output the assignments for this index.
        AndEnumerableState state;
        state.assignments.push_back(std::move(indexAssign));
        andAssignment->choices.push_back(std::move(state));
    }

    return andAssignment->choices.size() > 0;
}

void PlanEnumerator::assignPredicate(
    const unordered_map<MatchExpression*, std::deque<size_t>>& outsidePreds,
    MatchExpression* pred,
    size_t position,
    OneIndexAssignment* indexAssignment) {
    if (outsidePreds.find(pred) != outsidePreds.end()) {
        OrPushdownTag::Destination dest;
        dest.route = outsidePreds.at(pred);

        // This method should only be called if we can combine bounds.
        const bool canCombineBounds = true;
        dest.tagData =
            stdx::make_unique<IndexTag>(indexAssignment->index, position, canCombineBounds);
        indexAssignment->orPushdowns.emplace_back(pred, std::move(dest));
    } else {
        indexAssignment->preds.push_back(pred);
        indexAssignment->positions.push_back(position);
    }
}

void PlanEnumerator::enumerateOneIndex(
    IndexToPredMap idxToFirst,
    IndexToPredMap idxToNotFirst,
    const vector<MemoID>& subnodes,
    const unordered_map<MatchExpression*, std::deque<size_t>>& outsidePreds,
    AndAssignment* andAssignment) {
    // Each choice in the 'andAssignment' will consist of a single subnode to index (an OR or array
    // operator) or a OneIndexAssignment. When creating a OneIndexAssignment, we ensure that at
    // least one predicate can fulfill the first position in the key pattern, then we assign all
    // predicates that can use the key pattern to the index. However, if the index is multikey,
    // certain predicates cannot be combined/compounded. We determine which predicates can be
    // combined/compounded using path-level multikey info, if available.

    // First, add the state of using each subnode.
    for (size_t i = 0; i < subnodes.size(); ++i) {
        AndEnumerableState aes;
        aes.subnodesToIndex.push_back(subnodes[i]);
        andAssignment->choices.push_back(std::move(aes));
    }

    // Next we create OneIndexAssignments.

    // If there are any 'outsidePreds', then we are in a contained OR, and the 'outsidePreds' are
    // AND-related to the contained OR and can be pushed inside of it. Add all of the 'outsidePreds'
    // to 'idxToFirst' and 'idxToNotFirst'. We will treat them as normal predicates that can be
    // assigned to the index, but we will ensure that any OneIndexAssignment contains some
    // predicates from the current node.
    for (const auto& pred : outsidePreds) {
        invariant(pred.first->getTag());
        RelevantTag* relevantTag = static_cast<RelevantTag*>(pred.first->getTag());
        for (auto index : relevantTag->first) {
            if (idxToFirst.find(index) != idxToFirst.end() ||
                idxToNotFirst.find(index) != idxToNotFirst.end()) {
                idxToFirst[index].push_back(pred.first);
            }
        }
        for (auto index : relevantTag->notFirst) {
            if (idxToFirst.find(index) != idxToFirst.end() ||
                idxToNotFirst.find(index) != idxToNotFirst.end()) {
                idxToNotFirst[index].push_back(pred.first);
            }
        }
    }

    // For each FIRST, we assign predicates to it.
    for (IndexToPredMap::const_iterator it = idxToFirst.begin(); it != idxToFirst.end(); ++it) {
        const IndexEntry& thisIndex = (*_indices)[it->first];

        if (thisIndex.multikey && !thisIndex.multikeyPaths.empty()) {
            // We have path-level information about what causes 'thisIndex' to be multikey and can
            // use this information to get tighter bounds by assigning additional predicates to the
            // index.
            //
            // Depending on the predicates specified and what parts of the leading index field cause
            // the index to be multikey, we may not be able to assign all of predicates to the
            // index. Since we don't know which set of predicates is the most selective, we generate
            // multiple plans and rank them against each other.
            std::vector<PossibleFirstAssignment> possibleFirstAssignments;
            getPossibleFirstAssignments(thisIndex, it->second, &possibleFirstAssignments);

            // Output an assignment for each of the possible assignments on the leading index field.
            for (const auto& firstAssignment : possibleFirstAssignments) {
                OneIndexAssignment indexAssign;
                indexAssign.index = it->first;

                for (auto pred : firstAssignment) {
                    assignPredicate(outsidePreds, pred, 0, &indexAssign);
                }

                auto compIt = idxToNotFirst.find(indexAssign.index);
                if (compIt != idxToNotFirst.end()) {
                    // Assign any predicates on the non-leading index fields to 'indexAssign' that
                    // don't violate the intersecting and compounding rules for multikey indexes.
                    assignMultikeySafePredicates(compIt->second, outsidePreds, &indexAssign);
                }

                // Do not output this assignment if it consists only of outside predicates.
                if (!indexAssign.preds.empty()) {
                    AndEnumerableState state;
                    state.assignments.push_back(std::move(indexAssign));
                    andAssignment->choices.push_back(std::move(state));
                }
            }
        } else if (thisIndex.multikey) {
            // We don't have path-level information about what causes 'thisIndex' to be multikey.
            // We therefore must assume the worst-case scenario: all prefixes of all indexed fields
            // cause the index to be multikey. We therefore can only assign one of the predicates on
            // the leading index field to the index. Since we don't know which one is the most
            // selective, we generate a plan for each predicate and rank them against each other.
            for (auto pred : it->second) {
                OneIndexAssignment indexAssign;
                indexAssign.index = it->first;

                assignPredicate(outsidePreds, pred, 0, &indexAssign);

                // If there are any preds that could possibly be compounded with this
                // index...
                IndexToPredMap::const_iterator compIt = idxToNotFirst.find(indexAssign.index);
                if (compIt != idxToNotFirst.end()) {
                    const vector<MatchExpression*>& couldCompound = compIt->second;
                    vector<MatchExpression*> toCompound;
                    vector<MatchExpression*> assigned = indexAssign.preds;
                    for (const auto& orPushdown : indexAssign.orPushdowns) {
                        assigned.push_back(orPushdown.first);
                    }

                    // ...select the predicates that are safe to compound and compound them.
                    getMultikeyCompoundablePreds(assigned, couldCompound, &toCompound);

                    for (auto pred : toCompound) {
                        assignPredicate(
                            outsidePreds, pred, getPosition(thisIndex, pred), &indexAssign);
                    }
                }

                // Do not output this assignment if it consists only of outside predicates.
                if (!indexAssign.preds.empty()) {
                    AndEnumerableState state;
                    state.assignments.push_back(std::move(indexAssign));
                    andAssignment->choices.push_back(std::move(state));
                }
            }
        } else {
            // The assignment we're filling out.
            OneIndexAssignment indexAssign;

            // This is the index we assign to.
            indexAssign.index = it->first;

            // The index isn't multikey.  Assign all preds to it.  The planner will
            // intersect the bounds.
            for (auto pred : it->second) {
                assignPredicate(outsidePreds, pred, 0, &indexAssign);
            }

            // Find everything that could use assign.index but isn't a pred over
            // the first field of that index.
            IndexToPredMap::const_iterator compIt = idxToNotFirst.find(indexAssign.index);
            if (compIt != idxToNotFirst.end()) {
                for (auto pred : compIt->second) {
                    assignPredicate(outsidePreds, pred, getPosition(thisIndex, pred), &indexAssign);
                }
            }

            // Output the assignment.
            invariant(!indexAssign.preds.empty());
            AndEnumerableState state;
            state.assignments.push_back(std::move(indexAssign));
            andAssignment->choices.push_back(std::move(state));
        }
    }
}

void PlanEnumerator::enumerateAndIntersect(const IndexToPredMap& idxToFirst,
                                           const IndexToPredMap& idxToNotFirst,
                                           const vector<MemoID>& subnodes,
                                           AndAssignment* andAssignment) {
    // Hardcoded ""look at all members of the power set of size 2"" search,
    // a.k.a. ""consider all pairs of indices"".
    //
    // For each unordered pair of indices do the following:
    //   0. Impose an ordering (idx1, idx2) using the key patterns.
    //   (*See note below.)
    //   1. Assign predicates which prefix idx1 to idx1.
    //   2. Add assigned predicates to a set of predicates---the ""already
    //   assigned set"".
    //   3. Assign predicates which prefix idx2 to idx2, as long as they
    //   been assigned to idx1 already. Add newly assigned predicates to
    //   the ""already assigned set"".
    //   4. Try to assign predicates to idx1 by compounding.
    //   5. Add any predicates assigned to idx1 by compounding to the
    //   ""already assigned set"",
    //   6. Try to assign predicates to idx2 by compounding.
    //   7. Determine if we have already assigned all predicates in
    //   the ""already assigned set"" to a single index. If so, then
    //   don't generate an ixisect solution, as compounding will
    //   be better. Otherwise, output the ixisect assignments.
    //
    // *NOTE on ordering. Suppose we have two indices A and B, and a
    // predicate P1 which is over the prefix of both indices A and B.
    // If we order the indices (A, B) then P1 will get assigned to A,
    // but if we order the indices (B, A) then P1 will get assigned to
    // B. In order to make sure that we get the same result for the unordered
    // pair {A, B} we have to begin by imposing an ordering. As a more concrete
    // example, if we have indices {x: 1, y: 1} and {x: 1, z: 1} with predicate
    // {x: 3}, we want to make sure that {x: 3} gets assigned to the same index
    // irrespective of ordering.

    size_t sizeBefore = andAssignment->choices.size();

    for (IndexToPredMap::const_iterator firstIt = idxToFirst.begin(); firstIt != idxToFirst.end();
         ++firstIt) {
        const IndexEntry& oneIndex = (*_indices)[firstIt->first];

        // 'oneAssign' is used to assign indices and subnodes or to
        // make assignments for the first index when it's multikey.
        // It is NOT used in the inner loop that considers pairs of
        // indices.
        OneIndexAssignment oneAssign;
        oneAssign.index = firstIt->first;
        oneAssign.preds = firstIt->second;
        // Since everything in assign.preds prefixes the index, they all go
        // at position '0' in the index, the first position.
        oneAssign.positions.resize(oneAssign.preds.size(), 0);

        // We create a scan per predicate so if we have >1 predicate we'll already
        // have at least 2 scans (one predicate per scan as the planner can't
        // intersect bounds when the index is multikey), so we stop here.
        if (oneIndex.multikey && oneAssign.preds.size() > 1) {
            oneAssign.canCombineBounds = false;
            // One could imagine an enormous auto-generated $all query with too many clauses to
            // have an ixscan per clause.
            static const size_t kMaxSelfIntersections = 10;
            if (oneAssign.preds.size() > kMaxSelfIntersections) {
                // Only take the first kMaxSelfIntersections preds.
                oneAssign.preds.resize(kMaxSelfIntersections);
                oneAssign.positions.resize(kMaxSelfIntersections);
            }
            AndEnumerableState state;
            state.assignments.push_back(std::move(oneAssign));
            andAssignment->choices.push_back(std::move(state));
            continue;
        }

        // Output (subnode, firstAssign) pairs.
        for (size_t i = 0; i < subnodes.size(); ++i) {
            AndEnumerableState indexAndSubnode;
            indexAndSubnode.assignments.push_back(std::move(oneAssign));
            indexAndSubnode.subnodesToIndex.push_back(subnodes[i]);
            andAssignment->choices.push_back(std::move(indexAndSubnode));
            // Limit n^2.
            if (andAssignment->choices.size() - sizeBefore > _intersectLimit) {
                return;
            }
        }

        // Start looking at all other indices to find one that we want to bundle
        // with firstAssign.
        IndexToPredMap::const_iterator secondIt = firstIt;
        secondIt++;
        for (; secondIt != idxToFirst.end(); secondIt++) {
            const IndexEntry& firstIndex = (*_indices)[secondIt->first];
            const IndexEntry& secondIndex = (*_indices)[secondIt->first];

            // Limit n^2.
            if (andAssignment->choices.size() - sizeBefore > _intersectLimit) {
                return;
            }

            // If the other index we're considering is multikey with >1 pred, we don't
            // want to have it as an additional assignment.  Eventually, it1 will be
            // equal to the current value of secondIt and we'll assign every pred for
            // this mapping to the index.
            if (secondIndex.multikey && secondIt->second.size() > 1) {
                continue;
            }

            //
            // Step #0:
            // Impose an ordering (idx1, idx2) using the key patterns.
            //
            IndexToPredMap::const_iterator it1, it2;
            int ordering = firstIndex.keyPattern.woCompare(secondIndex.keyPattern);
            it1 = (ordering > 0) ? firstIt : secondIt;
            it2 = (ordering > 0) ? secondIt : firstIt;
            const IndexEntry& ie1 = (*_indices)[it1->first];
            const IndexEntry& ie2 = (*_indices)[it2->first];

            //
            // Step #1:
            // Assign predicates which prefix firstIndex to firstAssign.
            //
            OneIndexAssignment firstAssign;
            firstAssign.index = it1->first;
            firstAssign.preds = it1->second;
            // Since everything in assign.preds prefixes the index, they all go
            // at position '0' in the index, the first position.
            firstAssign.positions.resize(firstAssign.preds.size(), 0);

            // We keep track of what preds are assigned to indices either because they
            // prefix the index or have been assigned through compounding. We make sure
            // that these predicates DO NOT become additional index assignments.
            // Example: what if firstAssign is the index (x, y) and we're trying to
            // compound? We want to make sure not to compound if the predicate is
            // already assigned to index y.
            set<MatchExpression*> predsAssigned;

            //
            // Step #2:
            // Add indices assigned in 'firstAssign' to 'predsAssigned'.
            //
            for (size_t i = 0; i < firstAssign.preds.size(); ++i) {
                predsAssigned.insert(firstAssign.preds[i]);
            }

            //
            // Step #3:
            // Assign predicates which prefix secondIndex to secondAssign and
            // have not already been assigned to firstAssign. Any newly
            // assigned predicates are added to 'predsAssigned'.
            //
            OneIndexAssignment secondAssign;
            secondAssign.index = it2->first;
            const vector<MatchExpression*>& preds = it2->second;
            for (size_t i = 0; i < preds.size(); ++i) {
                if (predsAssigned.end() == predsAssigned.find(preds[i])) {
                    secondAssign.preds.push_back(preds[i]);
                    secondAssign.positions.push_back(0);
                    predsAssigned.insert(preds[i]);
                }
            }

            // Every predicate that would use this index is already assigned in
            // firstAssign.
            if (0 == secondAssign.preds.size()) {
                continue;
            }

            //
            // Step #4:
            // Compound on firstAssign, if applicable.
            //
            IndexToPredMap::const_iterator firstIndexCompound =
                idxToNotFirst.find(firstAssign.index);

            // Can't compound with multikey indices.
            if (!ie1.multikey && firstIndexCompound != idxToNotFirst.end()) {
                // We must remove any elements of 'predsAssigned' from consideration.
                vector<MatchExpression*> tryCompound;
                const vector<MatchExpression*>& couldCompound = firstIndexCompound->second;
                for (size_t i = 0; i < couldCompound.size(); ++i) {
                    if (predsAssigned.end() == predsAssigned.find(couldCompound[i])) {
                        tryCompound.push_back(couldCompound[i]);
                    }
                }
                if (tryCompound.size()) {
                    compound(tryCompound, ie1, &firstAssign);
                }
            }

            //
            // Step #5:
            // Make sure predicates assigned by compounding in step #4 do not get
            // assigned again.
            //
            for (size_t i = 0; i < firstAssign.preds.size(); ++i) {
                if (predsAssigned.end() == predsAssigned.find(firstAssign.preds[i])) {
                    predsAssigned.insert(firstAssign.preds[i]);
                }
            }

            //
            // Step #6:
            // Compound on firstAssign, if applicable.
            //
            IndexToPredMap::const_iterator secondIndexCompound =
                idxToNotFirst.find(secondAssign.index);

            if (!ie2.multikey && secondIndexCompound != idxToNotFirst.end()) {
                // We must remove any elements of 'predsAssigned' from consideration.
                vector<MatchExpression*> tryCompound;
                const vector<MatchExpression*>& couldCompound = secondIndexCompound->second;
                for (size_t i = 0; i < couldCompound.size(); ++i) {
                    if (predsAssigned.end() == predsAssigned.find(couldCompound[i])) {
                        tryCompound.push_back(couldCompound[i]);
                    }
                }
                if (tryCompound.size()) {
                    compound(tryCompound, ie2, &secondAssign);
                }
            }

            // Add predicates in 'secondAssign' to the set of all assigned predicates.
            for (size_t i = 0; i < secondAssign.preds.size(); ++i) {
                if (predsAssigned.end() == predsAssigned.find(secondAssign.preds[i])) {
                    predsAssigned.insert(secondAssign.preds[i]);
                }
            }

            //
            // Step #7:
            // Make sure we haven't already assigned this set of predicates by compounding.
            // If we have, then bail out for this pair of indices.
            //
            if (alreadyCompounded(predsAssigned, andAssignment)) {
                // There is no need to add either 'firstAssign' or 'secondAssign'
                // to 'andAssignment' in this case because we have already performed
                // assignments to single indices in enumerateOneIndex(...).
                continue;
            }

            // We're done with this particular pair of indices; output
            // the resulting assignments.
            AndEnumerableState state;
            state.assignments.push_back(std::move(firstAssign));
            state.assignments.push_back(std::move(secondAssign));
            andAssignment->choices.push_back(std::move(state));
        }
    }

    // TODO: Do we just want one subnode at a time?  We can use far more than 2 indices at once
    // doing this very easily.  If we want to restrict the # of indices the children use, when
    // we memoize the subtree above we can restrict it to 1 index at a time.  This can get
    // tricky if we want both an intersection and a 1-index memo entry, since our state change
    // is simple and we don't traverse the memo in any targeted way.  Should also verify that
    // having a one-to-many mapping of MatchExpression to MemoID doesn't break anything.  This
    // approach errors on the side of ""too much indexing.""
    for (size_t i = 0; i < subnodes.size(); ++i) {
        for (size_t j = i + 1; j < subnodes.size(); ++j) {
            AndEnumerableState state;
            state.subnodesToIndex.push_back(subnodes[i]);
            state.subnodesToIndex.push_back(subnodes[j]);
            andAssignment->choices.push_back(std::move(state));
        }
    }
}

void PlanEnumerator::getIndexedPreds(MatchExpression* node,
                                     PrepMemoContext context,
                                     vector<MatchExpression*>* indexedPreds) {
    if (Indexability::nodeCanUseIndexOnOwnField(node)) {
        RelevantTag* rt = static_cast<RelevantTag*>(node->getTag());
        if (context.elemMatchExpr) {
            // If we're in an $elemMatch context, store the
            // innermost parent $elemMatch, as well as the
            // inner path prefix.
            rt->elemMatchExpr = context.elemMatchExpr;
            rt->pathPrefix = getPathPrefix(node->path().toString());
        } else {
            // We're not an $elemMatch context, so we should store
            // the prefix of the full path.
            rt->pathPrefix = getPathPrefix(rt->path);
        }

        // Output this as a pred that can use the index.
        indexedPreds->push_back(node);
    } else if (Indexability::isBoundsGeneratingNot(node)) {
        getIndexedPreds(node->getChild(0), context, indexedPreds);
    } else if (MatchExpression::ELEM_MATCH_OBJECT == node->matchType()) {
        PrepMemoContext childContext;
        childContext.elemMatchExpr = node;
        for (size_t i = 0; i < node->numChildren(); ++i) {
            getIndexedPreds(node->getChild(i), childContext, indexedPreds);
        }
    } else if (MatchExpression::AND == node->matchType()) {
        for (size_t i = 0; i < node->numChildren(); ++i) {
            getIndexedPreds(node->getChild(i), context, indexedPreds);
        }
    }
}

bool PlanEnumerator::prepSubNodes(MatchExpression* node,
                                  PrepMemoContext context,
                                  vector<MemoID>* subnodesOut,
                                  vector<MemoID>* mandatorySubnodes) {
    for (size_t i = 0; i < node->numChildren(); ++i) {
        MatchExpression* child = node->getChild(i);
        if (MatchExpression::OR == child->matchType()) {
            bool mandatory = expressionRequiresIndex(child);
            if (prepMemo(child, context)) {
                size_t childID = memoIDForNode(child);

                // Output the subnode.
                if (mandatory) {
                    mandatorySubnodes->push_back(childID);
                } else {
                    subnodesOut->push_back(childID);
                }
            } else if (mandatory) {
                // The subnode is mandatory but cannot be indexed. This means
                // that the entire AND cannot be indexed either.
                return false;
            }
        } else if (MatchExpression::ELEM_MATCH_OBJECT == child->matchType()) {
            PrepMemoContext childContext;
            childContext.elemMatchExpr = child;
            childContext.outsidePreds = context.outsidePreds;
            prepSubNodes(child, childContext, subnodesOut, mandatorySubnodes);
        } else if (MatchExpression::AND == child->matchType()) {
            prepSubNodes(child, context, subnodesOut, mandatorySubnodes);
        }
    }

    return true;
}

void PlanEnumerator::getMultikeyCompoundablePreds(const vector<MatchExpression*>& assigned,
                                                  const vector<MatchExpression*>& couldCompound,
                                                  vector<MatchExpression*>* out) {
    // Map from a particular $elemMatch expression to the set of prefixes
    // used so far by the predicates inside the $elemMatch. For example,
    // {a: {$elemMatch: {b: 1, c: 2}}} would map to the set {'b', 'c'} at
    // the end of this function's execution.
    //
    // NULL maps to the set of prefixes used so far outside of an $elemMatch
    // context.
    //
    // As we iterate over the available indexed predicates, we keep track
    // of the used prefixes both inside and outside of an $elemMatch context.
    unordered_map<MatchExpression*, set<string>> used;

    // Initialize 'used' with the starting predicates in 'assigned'. Begin by
    // initializing the top-level scope with the prefix of the full path.
    for (size_t i = 0; i < assigned.size(); i++) {
        const MatchExpression* assignedPred = assigned[i];
        invariant(NULL != assignedPred->getTag());
        RelevantTag* usedRt = static_cast<RelevantTag*>(assignedPred->getTag());
        set<string> usedPrefixes;
        usedPrefixes.insert(getPathPrefix(usedRt->path));
        used[NULL] = usedPrefixes;

        // If 'assigned' is a predicate inside an $elemMatch, we have to
        // add the prefix not only to the top-level context, but also to the
        // the $elemMatch context. For example, if 'assigned' is {a: {$elemMatch: {b: 1}}},
        // then we will have already added ""a"" to the set for NULL. We now
        // also need to add ""b"" to the set for the $elemMatch.
        if (NULL != usedRt->elemMatchExpr) {
            set<string> elemMatchUsed;
            // Whereas getPathPrefix(usedRt->path) is the prefix of the full path,
            // usedRt->pathPrefix contains the prefix of the portion of the
            // path that is inside the $elemMatch. These two prefixes are the same
            // in the top-level context, but here must be different because 'usedRt'
            // is in an $elemMatch context.
            elemMatchUsed.insert(usedRt->pathPrefix);
            used[usedRt->elemMatchExpr] = elemMatchUsed;
        }
    }

    for (size_t i = 0; i < couldCompound.size(); ++i) {
        invariant(Indexability::nodeCanUseIndexOnOwnField(couldCompound[i]));
        RelevantTag* rt = static_cast<RelevantTag*>(couldCompound[i]->getTag());

        if (used.end() == used.find(rt->elemMatchExpr)) {
            // This is a new $elemMatch that we haven't seen before.
            invariant(used.end() != used.find(NULL));
            set<string>& topLevelUsed = used.find(NULL)->second;

            // If the top-level path prefix of the $elemMatch hasn't been
            // used yet, couldCompound[i] is safe to compound.
            if (topLevelUsed.end() == topLevelUsed.find(getPathPrefix(rt->path))) {
                topLevelUsed.insert(getPathPrefix(rt->path));
                set<string> usedPrefixes;
                usedPrefixes.insert(rt->pathPrefix);
                used[rt->elemMatchExpr] = usedPrefixes;

                // Output the predicate.
                out->push_back(couldCompound[i]);
            }

        } else {
            // We've seen this $elemMatch before, or the predicate is
            // top-level (not in an $elemMatch context). If the prefix stored
            // in the tag has not been used yet, then couldCompound[i] is
            // safe to compound.
            set<string>& usedPrefixes = used.find(rt->elemMatchExpr)->second;
            if (usedPrefixes.end() == usedPrefixes.find(rt->pathPrefix)) {
                usedPrefixes.insert(rt->pathPrefix);

                // Output the predicate.
                out->push_back(couldCompound[i]);
            }
        }
    }
}

void PlanEnumerator::assignMultikeySafePredicates(
    const std::vector<MatchExpression*>& couldAssign,
    const unordered_map<MatchExpression*, std::deque<size_t>>& outsidePreds,
    OneIndexAssignment* indexAssignment) {
    invariant(indexAssignment);
    invariant(indexAssignment->preds.size() == indexAssignment->positions.size());

    const IndexEntry& thisIndex = (*_indices)[indexAssignment->index];
    invariant(!thisIndex.multikeyPaths.empty());

    // 'used' is a map from each prefix of a queried path that causes 'thisIndex' to be multikey to
    // the 'elemMatchExpr' of the associated leaf expression's RelevantTag. We use it to ensure that
    // leaf expressions sharing a prefix of their queried paths are only both assigned to
    // 'thisIndex' if they are joined by the same $elemMatch context.
    StringMap<MatchExpression*> used;

    // Initialize 'used' with the predicates already assigned to 'thisIndex'.
    for (size_t i = 0; i < indexAssignment->preds.size(); ++i) {
        const auto* assignedPred = indexAssignment->preds[i];
        const auto posInIdx = indexAssignment->positions[i];

        invariant(assignedPred->getTag());
        RelevantTag* rt = static_cast<RelevantTag*>(assignedPred->getTag());

        // 'assignedPred' has already been assigned to 'thisIndex', so canAssignPredToIndex() ought
        // to return true.
        const bool shouldHaveAssigned =
            canAssignPredToIndex(rt, thisIndex.multikeyPaths[posInIdx], &used);
        if (!shouldHaveAssigned) {
            // However, there are cases with multikey 2dsphere indexes where the mandatory predicate
            // is still safe to compound with, even though a prefix of it that causes the index to
            // be multikey can be shared with the leading index field. The predicates cannot
            // possibly be joined by an $elemMatch because $near predicates must be specified at the
            // top-level of the query.
            invariant(assignedPred->matchType() == MatchExpression::GEO_NEAR);
        }
    }

    // Update 'used' with all outside predicates already assigned to 'thisIndex';
    for (const auto& orPushdown : indexAssignment->orPushdowns) {
        invariant(orPushdown.first->getTag());
        RelevantTag* rt = static_cast<RelevantTag*>(orPushdown.first->getTag());

        // Any outside predicates already assigned to 'thisIndex' were assigned in the first
        // position.
        const size_t position = 0;
        const bool shouldHaveAssigned =
            canAssignPredToIndex(rt, thisIndex.multikeyPaths[position], &used);
        invariant(shouldHaveAssigned);
    }

    size_t posInIdx = 0;

    for (const auto keyElem : thisIndex.keyPattern) {
        // Attempt to assign the predicates to 'thisIndex' according to their position in the index
        // key pattern.
        for (auto* couldAssignPred : couldAssign) {
            invariant(Indexability::nodeCanUseIndexOnOwnField(couldAssignPred));
            RelevantTag* rt = static_cast<RelevantTag*>(couldAssignPred->getTag());

            if (keyElem.fieldNameStringData() != rt->path) {
                continue;
            }

            if (thisIndex.multikeyPaths[posInIdx].empty()) {
                // We can always intersect or compound the bounds when no prefix of the queried path
                // causes the index to be multikey.
                assignPredicate(outsidePreds, couldAssignPred, posInIdx, indexAssignment);
                continue;
            }

            // See if any of the predicates that are already assigned to 'thisIndex' prevent us from
            // assigning 'couldAssignPred' as well.
            const bool shouldAssign =
                canAssignPredToIndex(rt, thisIndex.multikeyPaths[posInIdx], &used);

            if (shouldAssign) {
                assignPredicate(outsidePreds, couldAssignPred, posInIdx, indexAssignment);
            }
        }

        ++posInIdx;
    }
}

bool PlanEnumerator::alreadyCompounded(const set<MatchExpression*>& ixisectAssigned,
                                       const AndAssignment* andAssignment) {
    for (size_t i = 0; i < andAssignment->choices.size(); ++i) {
        const AndEnumerableState& state = andAssignment->choices[i];

        // We cannot have assigned this set of predicates already by
        // compounding unless this is an assignment to a single index.
        if (state.assignments.size() != 1) {
            continue;
        }

        // If the set of preds in 'ixisectAssigned' is a subset of 'oneAssign.preds',
        // then all the preds can be used by compounding on a single index.
        const OneIndexAssignment& oneAssign = state.assignments[0];

        // If 'ixisectAssigned' is larger than 'oneAssign.preds', then
        // it can't be a subset.
        if (ixisectAssigned.size() > oneAssign.preds.size()) {
            continue;
        }

        // Check for subset by counting the number of elements in 'oneAssign.preds'
        // that are contained in 'ixisectAssigned'. The elements of both 'oneAssign.preds'
        // and 'ixisectAssigned' are unique (no repeated elements).
        size_t count = 0;
        for (size_t j = 0; j < oneAssign.preds.size(); ++j) {
            if (ixisectAssigned.end() != ixisectAssigned.find(oneAssign.preds[j])) {
                ++count;
            }
        }

        if (ixisectAssigned.size() == count) {
            return true;
        }

        // We cannot assign the preds by compounding on 'oneAssign'.
        // Move on to the next index.
    }

    return false;
}

size_t PlanEnumerator::getPosition(const IndexEntry& indexEntry, MatchExpression* predicate) {
    invariant(predicate->getTag());
    RelevantTag* relevantTag = static_cast<RelevantTag*>(predicate->getTag());
    size_t position = 0;
    for (auto&& element : indexEntry.keyPattern) {
        if (element.fieldName() == relevantTag->path) {
            return position;
        }
        ++position;
    }
    MONGO_UNREACHABLE;
}

void PlanEnumerator::compound(const vector<MatchExpression*>& tryCompound,
                              const IndexEntry& thisIndex,
                              OneIndexAssignment* assign) {
    // Let's try to match up the expressions in 'compExprs' with the
    // fields in the index key pattern.
    BSONObjIterator kpIt(thisIndex.keyPattern);

    // Skip the first elt as it's already assigned.
    kpIt.next();

    // When we compound we store the field number that the predicate
    // goes over in order to avoid having to iterate again and compare
    // field names.
    size_t posInIdx = 0;

    while (kpIt.more()) {
        BSONElement keyElt = kpIt.next();
        ++posInIdx;

        // Go through 'tryCompound' to see if there is a compoundable
        // predicate for 'keyElt'. If there is nothing to compound, then
        // simply move on to the next field in the compound index. We
        // do not enforce that fields are assigned contiguously from
        // right to left, i.e. for compound index {a: 1, b: 1, c: 1}
        // it is okay to compound predicates over ""a"" and ""c"", skipping ""b"".
        for (size_t j = 0; j < tryCompound.size(); ++j) {
            MatchExpression* maybe = tryCompound[j];
            // Sigh we grab the full path from the relevant tag.
            RelevantTag* rt = static_cast<RelevantTag*>(maybe->getTag());
            if (keyElt.fieldName() == rt->path) {
                // preds and positions are parallel arrays.
                assign->preds.push_back(maybe);
                assign->positions.push_back(posInIdx);
            }
        }
    }
}

//
// Structure navigation
//

void PlanEnumerator::tagMemo(size_t id) {
    LOG(5) << ""Tagging memoID "" << id;
    NodeAssignment* assign = _memo[id];
    verify(NULL != assign);

    if (NULL != assign->orAssignment) {
        OrAssignment* oa = assign->orAssignment.get();
        for (size_t i = 0; i < oa->subnodes.size(); ++i) {
            tagMemo(oa->subnodes[i]);
        }
    } else if (NULL != assign->arrayAssignment) {
        ArrayAssignment* aa = assign->arrayAssignment.get();
        tagMemo(aa->subnodes[aa->counter]);
    } else if (NULL != assign->andAssignment) {
        AndAssignment* aa = assign->andAssignment.get();
        verify(aa->counter < aa->choices.size());

        const AndEnumerableState& aes = aa->choices[aa->counter];

        for (size_t j = 0; j < aes.subnodesToIndex.size(); ++j) {
            tagMemo(aes.subnodesToIndex[j]);
        }

        for (size_t i = 0; i < aes.assignments.size(); ++i) {
            const OneIndexAssignment& assign = aes.assignments[i];

            for (size_t j = 0; j < assign.preds.size(); ++j) {
                MatchExpression* pred = assign.preds[j];
                if (pred->getTag()) {
                    OrPushdownTag* orPushdownTag = static_cast<OrPushdownTag*>(pred->getTag());
                    orPushdownTag->setIndexTag(
                        new IndexTag(assign.index, assign.positions[j], assign.canCombineBounds));
                } else {
                    pred->setTag(
                        new IndexTag(assign.index, assign.positions[j], assign.canCombineBounds));
                }
            }

            // Add all OrPushdownTags for this index assignment.
            for (const auto& orPushdown : assign.orPushdowns) {
                auto expr = orPushdown.first;
                if (!expr->getTag()) {
                    expr->setTag(new OrPushdownTag());
                }
                OrPushdownTag* orPushdownTag = static_cast<OrPushdownTag*>(expr->getTag());
                orPushdownTag->addDestination(orPushdown.second.clone());
            }
        }
    } else {
        verify(0);
    }
}

bool PlanEnumerator::nextMemo(size_t id) {
    NodeAssignment* assign = _memo[id];
    verify(NULL != assign);

    if (NULL != assign->orAssignment) {
        OrAssignment* oa = assign->orAssignment.get();

        // Limit the number of OR enumerations
        oa->counter++;
        if (oa->counter >= _orLimit) {
            return true;
        }

        // OR just walks through telling its children to
        // move forward.
        for (size_t i = 0; i < oa->subnodes.size(); ++i) {
            // If there's no carry, we just stop.  If there's a carry, we move the next child
            // forward.
            if (!nextMemo(oa->subnodes[i])) {
                return false;
            }
        }
        // If we're here, the last subnode had a carry, therefore the OR has a carry.
        return true;
    } else if (NULL != assign->arrayAssignment) {
        ArrayAssignment* aa = assign->arrayAssignment.get();
        // moving to next on current subnode is OK
        if (!nextMemo(aa->subnodes[aa->counter])) {
            return false;
        }
        // Move to next subnode.
        ++aa->counter;
        if (aa->counter < aa->subnodes.size()) {
            return false;
        }
        aa->counter = 0;
        return true;
    } else if (NULL != assign->andAssignment) {
        AndAssignment* aa = assign->andAssignment.get();

        // One of our subnodes might have to move on to its next enumeration state.
        const AndEnumerableState& aes = aa->choices[aa->counter];
        for (size_t i = 0; i < aes.subnodesToIndex.size(); ++i) {
            if (!nextMemo(aes.subnodesToIndex[i])) {
                return false;
            }
        }

        // None of the subnodes had another enumeration state, so we move on to the
        // next top-level choice.
        ++aa->counter;
        if (aa->counter < aa->choices.size()) {
            return false;
        }
        aa->counter = 0;
        return true;
    }

    // This shouldn't happen.
    verify(0);
    return false;
}

}  // namespace mongo
",16302,True,3262.248721080659,median