text,length,is_long_context,metric_val,label_metric
"----

Integer               Integer               FP

funct3                funct3                funct3
OPIVV  V              OPMVV  V              OPFVV  V
OPIVX   X             OPMVX   X             OPFVF   F
OPIVI    I

funct6                funct6                funct6
000000 VXI vadd       000000 V  vredsum     000000 VF vfadd
000001                000001 V  vredand     000001 V  vfredsum
000010 VX  vsub       000010 V  vredor      000010 VF vfsub
000011  XI vrsub      000011 V  vredxor     000011 V  vfredosum
000100 VX  vminu      000100 V  vredminu    000100 VF vfmin
000101 VX  vmin       000101 V  vredmin     000101 V  vfredmin
000110 VX  vmaxu      000110 V  vredmaxu    000110 VF vfmax
000111 VX  vmax       000111 V  vredmax     000111 V  vfredmax
001000                001000                001000 VF vfsgnj
001001 VXI vand       001001                001001 VF vfsgnn
001010 VXI vor        001010                001010 VF vfsgnx
001011 VXI vxor       001011                001011
001100 VXI vrgather   001100 V  vext.x.v    001100 V  vfmv.f.s
001101                001101  X vmv.s.x     001101  F vfmv.s.f
001110  XI vslideup   001110  X vslide1up   001110
001111  XI vslidedown 001111  X vslide1down 001111

010000 VXI vadc       010000                010000 
010001                010001                010001 
010010 VX  vsbc       010010                010010 
010011                010011                010011
010100                010100 V  vmpopc      010100
010101                010101 V  vmfirst     010101
010110                010110 V  VMUNARY0    010110
010111 VXI vmerge     010111 V  vcompress   010111  F vfmerge.vf
011000 VXI vseq       011000 V  vmandnot    011000 VF vfeq
011001 VXI vsne       011001 V  vmand       011001 VF vflte
011010 VX  vsltu      011010 V  vmor        011010 VF vford
011011 VX  vslt       011011 V  vmxor       011011 VF vflt
011100 VXI vsleu      011100 V  vmornot     011100 VF vfne
011101 VXI vsle       011101 V  vmnand      011101  F vfgt
011110  XI vsgtu      011110 V  vmnor       011110
011111  XI vsgt       011111 V  vmxnor      011111  F vfgte

100000 VXI vsaddu     100000 VX vdivu       100000 VF vfdiv   
100001 VXI vsadd      100001 VX vdiv        100001  F vfrdiv  
100010 VX  vssubu     100010 VX vremu       100010 V  VFUNARY0
100011 VX  vssub      100011 VX vrem        100011 V  VFUNARY1
100100 VXI vaadd      100100 VX vmulhu      100100 VF vfmul
100101 VXI vsll       100101 VX vmul        100101 
100110 VX  vasub      100110 VX vmulhsu     100110 
100111 VX  vsmul      100111 VX vmulh       100111 
101000 VXI vsrl       101000                101000 VF vfmadd
101001 VXI vsra       101001 VX vmadd       101001 VF vfnmadd
101010 VXI vssrl      101010                101010 VF vfmsub
101011 VXI vssra      101011 VX vmsub       101011 VF vfnmsub
101100 VXI vnsrl      101100                101100 VF vfmacc
101101 VXI vnsra      101101 VX vmacc       101101 VF vfnmacc
101110 VXI vnclipu    101110                101110 VF vfmsac
101111 VXI vnclip     101111 VX vmsac       101111 VF vfnmsac

110000 V  vwredsumu   110000 VX vwaddu      110000 VF vfwadd
110001 V  vwredsum    110001 VX vwadd       110001 V  vfwredsum
110010                110010 VX vwsubu      110010 VF vfwsub
110011                110011 VX vwsub       110011 V  vfwredosum
110100                110100 VX vwaddu.w    110100 VF vfwadd.w
110101                110101 VX vwadd.w     110101
110110                110110 VX vwsubu.w    110110 VF vfwsub.w
110111                110111 VX vwsub.w     110111
111000 V  vdotu       111000 VX vwmulu      111000 VF vfwmul
111001 V  vdot        111001                111001 V  vfdot
111010                111010 VX vwmulsu     111010
111011                111011 VX vwmul       111011
111100 VX vwsmaccu    111100 VX vwmaccu     111100 VF vfwmacc
111101 VX vwsmacc     111101 VX vwmacc      111101 VF vfwnmacc
111110 VX vwsmsacu    111110 VX vwmsacu     111110 VF vfwmsac
111111 VX vwsmsac     111111 VX vwmsac      111111 VF vfwnmsac
----

----
VFUNARY0 encoding space
 vs1
 single-width converts
00000 vfcvt.xu.f.v
00001 vfcvt.x.f.v
00010 vfcvt.f.xu.v
00011 vfcvt.f.x.v

 widening converts
01000 vfwcvt.xu.f.v
01001 vfwcvt.x.f.v
01010 vfwcvt.f.xu.v
01011 vfwcvt.f.x.v
01100 vfwcvt.f.f.v

 narrowing converts
10000 vfncvt.xu.f.v
10001 vfncvt.x.f.v
10010 vfncvt.f.xu.v
10011 vfncvt.f.x.v
10100 vfncvt.f.f.v
----

----
VFUNARY1 encoding space
 vs1
00000 vfsqrt.v
10000 vfclass.v
----

----
VMUNARY0 encoding space
 vs1
00001 vmsbf
00010 vmsof
00011 vmsif
10000 vmiota
10001 vid
----


////
.Vector Unit-Stride Load/Store Instruction Listing
[width=""100%"",cols=""^3,^3,^3,^4,^4,^3,^3,^3,^7,<10""]
|========================
|31 30 |29 27 |26 25 |24  20 |19    15 |14  12 |11 10 |9 7 |6  0 |Opcode

|off[1:0]|000|vm|00000|rs1|000 2+|vd|0000111|VLBU.V
|off[1:0]|000|vm|00000|rs1|101 2+|vd|0000111|VLHU.V
|off[1:0]|000|vm|00000|rs1|110 2+|vd|0000111|VLWU.V
|off[1:0]|000|vm|00000|rs1|111 2+|vd|0000111|VLE.V
|off[1:0]|100|vm|00000|rs1|000 2+|vd|0000111|VLB.V
|off[1:0]|100|vm|00000|rs1|101 2+|vd|0000111|VLH.V
|off[1:0]|100|vm|00000|rs1|110 2+|vd|0000111|VLW.V
2+|vs3|vm|00000|rs1|000|off[1:0]|000|0100111|VSB.V
2+|vs3|vm|00000|rs1|101|off[1:0]|000|0100111|VSH.V
2+|vs3|vm|00000|rs1|110|off[1:0]|000|0100111|VSW.V
2+|vs3|vm|00000|rs1|111|off[1:0]|000|0100111|VSE.V
|========================


.Vector Unit-Stride Fault-First Load Instruction Listing
[width=""100%"",cols=""^3,^3,^3,^4,^4,^3,^3,^3,^7,<10""]
|========================
|31 30 |29 27 |26 25 |24  20 |19    15 |14  12 |11 10 |9 7 |6  0 |Opcode

|off[1:0]|000|vm|10000|rs1|000 2+|vd|0000111|VLBUFF.V
|off[1:0]|000|vm|10000|rs1|101 2+|vd|0000111|VLHUFF.V
|off[1:0]|000|vm|10000|rs1|110 2+|vd|0000111|VLWUFF.V
|off[1:0]|000|vm|10000|rs1|111 2+|vd|0000111|VLEFF.V
|off[1:0]|100|vm|10000|rs1|000 2+|vd|0000111|VLBFF.V
|off[1:0]|100|vm|10000|rs1|101 2+|vd|0000111|VLHFF.V
|off[1:0]|100|vm|10000|rs1|110 2+|vd|0000111|VLWFF.V

|========================

.Vector Strided Load/Store Instruction Listing
[width=""100%"",cols=""^3,^3,^3,^4,^4,^3,^3,^3,^7,<10""]
|========================
|31 30 |29 27 |26 25 |24  20 |19    15 |14  12 |11 10 |9 7 |6  0 |Opcode

|off[1:0]|010|vm|rs2|rs1|000 2+|vd|0000111|VLSBU.V
|off[1:0]|010|vm|rs2|rs1|101 2+|vd|0000111|VLSHU.V
|off[1:0]|010|vm|rs2|rs1|110 2+|vd|0000111|VLSWU.V
|off[1:0]|010|vm|rs2|rs1|111 2+|vd|0000111|VLSE.V
|off[1:0]|110|vm|rs2|rs1|000 2+|vd|0000111|VLSB.V
|off[1:0]|110|vm|rs2|rs1|101 2+|vd|0000111|VLSH.V
|off[1:0]|110|vm|rs2|rs1|110 2+|vd|0000111|VLSW.V
2+|vs3|vm|rs2|rs1|000|off[1:0]|010|0100111|VSSB.V
2+|vs3|vm|rs2|rs1|101|off[1:0]|010|0100111|VSSH.V
2+|vs3|vm|rs2|rs1|110|off[1:0]|010|0100111|VSSW.V
2+|vs3|vm|rs2|rs1|111|off[1:0]|010|0100111|VSSE.V

|========================


.Vector Indexed Load/Store Instruction Listing
[width=""100%"",cols=""^3,^3,^3,^4,^4,^3,^3,^3,^7,<10""]
|========================
|31 30 |29 27 |26 25 |24  20 |19    15 |14  12 |11 10 |9 7 |6  0 |Opcode

|off[1:0]|011|vm|vs2|rs1|000 2+|vd|0000111|VLXBU.V
|off[1:0]|011|vm|vs2|rs1|101 2+|vd|0000111|VLXHU.V
|off[1:0]|011|vm|vs2|rs1|110 2+|vd|0000111|VLXWU.V
|off[1:0]|011|vm|vs2|rs1|111 2+|vd|0000111|VLXE.V
|off[1:0]|111|vm|vs2|rs1|000 2+|vd|0000111|VLXB.V
|off[1:0]|111|vm|vs2|rs1|101 2+|vd|0000111|VLXH.V
|off[1:0]|111|vm|vs2|rs1|110 2+|vd|0000111|VLXW.V
2+|vs3|vm|vs2|rs1|000|off[1:0]|011|0100111|VSXB.V
2+|vs3|vm|vs2|rs1|101|off[1:0]|011|0100111|VSXH.V
2+|vs3|vm|vs2|rs1|110|off[1:0]|011|0100111|VSXW.V
2+|vs3|vm|vs2|rs1|111|off[1:0]|011|0100111|VSXE.V
2+|vs3|vm|vs2|rs1|000|off[1:0]|111|0100111|VSUXB.V
2+|vs3|vm|vs2|rs1|101|off[1:0]|111|0100111|VSUXH.V
2+|vs3|vm|vs2|rs1|110|off[1:0]|111|0100111|VSUXW.V
2+|vs3|vm|vs2|rs1|111|off[1:0]|111|0100111|VSUXE.V

|========================
////



////

X  vsgteu
  X  vsgte


vx4muladd
vx4mulsub


.Vector Table
[width=""100%"",cols=""^3,^3,^3,^4,^4,^3,^3,^3,^7,<10""]
|========================
2+|31 27|26 25 |24   20 |19    15 |14  12 2+|11  7 |6  0   |Opcode

2+|00000|vm    |vs2     |vs1      |001    2+|vd    |1010111|VADD.VV
2+|00000|vm    |vs2     |vs1      |000    2+|vd    |1010111|VADD.VS
2+|00000|vm    |vs2     |rs1      |010    2+|vd    |1010111|VADD.VX
2+|00000|vm    |vs2     |simm[4:0]|011    2+|vd    |1010111|VADD.VI
|========================

.Vector Table
[width=""100%"",cols=""^3,^3,^3,^4,^4,^3,^3,^3,^7,<10""]
|========================
|31 30 |29 27 |26 25 |24  20 |19    15 |14  12 |11 10 |9 7 |6  0 |Opcode

2+|00000|vm|vs2|vs1|000 2+|vd|1010111|VADD.VV
2+|00000|vm|vs2|vs1|100 2+|vd|1010111|VADD.VS
2+|00000|vm|imm[4:0]|vs1|101 2+|vd|1010111|VADD.VI
2+|00000|vm|vs2|vs1|010 2+|vd|1010111|VADDW.VV
2+|00000|vm|vs2|vs1|110 2+|vd|1010111|VADDW.VS
2+|00000|vm|vs2|vs1|011 2+|vd|1010111|VADDW.WV
2+|00000|vm|vs2|vs1|111 2+|vd|1010111|VADDW.WS
2+|00001|vm|vs2|vs1|000 2+|vd|1010111|VSUB.VV
2+|00001|vm|vs2|vs1|100 2+|vd|1010111|VSUB.VS
2+|00001|vm|imm[4:0]|vs1|101 2+|vd|1010111|VSUB.VI
2+|00001|vm|vs2|vs1|000 2+|vd|1010111|VSUB.VV
2+|00001|vm|vs2|vs1|100 2+|vd|1010111|VSUB.VS
2+|00001|vm|vs2|vs1|011 2+|vd|1010111|VSUBW.WV
2+|00001|vm|vs2|vs1|111 2+|vd|1010111|VSUBW.WS
2+|01000|vm|vs2|vs1|000 2+|vd|1010111|VMUL.VV
2+|01000|vm|vs2|vs1|100 2+|vd|1010111|VMUL.VS
2+|01000|vm|imm[4:0]|vs1|101 2+|vd|1010111|VMUL.VI
2+|01000|vm|vs2|vs1|000 2+|vd|1010111|VMUL.VV
2+|01000|vm|vs2|vs1|100 2+|vd|1010111|VMUL.VS
2+|01000|vm|vs2|vs1|011 2+|vd|1010111|VMULW.WV
2+|01000|vm|vs2|vs1|111 2+|vd|1010111|VMULW.WS
2+|01001|vm|vs2|vs1|000 2+|vd|1010111|VMULU.VV
2+|01001|vm|vs2|vs1|100 2+|vd|1010111|VMULU.VS
2+|01001|vm|imm[4:0]|vs1|101 2+|vd|1010111|VMULU.VI
2+|01001|vm|vs2|vs1|000 2+|vd|1010111|VMULU.VV
2+|01001|vm|vs2|vs1|100 2+|vd|1010111|VMULU.VS
2+|01001|vm|vs2|vs1|011 2+|vd|1010111|VMULUW.WV
2+|01001|vm|vs2|vs1|111 2+|vd|1010111|VMULUW.WS
2+|01010|vm|vs2|vs1|000 2+|vd|1010111|VMULSU.VV
2+|01010|vm|vs2|vs1|100 2+|vd|1010111|VMULSU.VS
2+|01010|vm|imm[4:0]|vs1|101 2+|vd|1010111|VMULSU.VI
2+|01010|vm|vs2|vs1|000 2+|vd|1010111|VMULSU.VV
2+|01010|vm|vs2|vs1|100 2+|vd|1010111|VMULSU.VS
2+|01010|vm|vs2|vs1|011 2+|vd|1010111|VMULSUW.WV
2+|01010|vm|vs2|vs1|111 2+|vd|1010111|VMULSUW.WS

|========================


.Vector Table
[width=""100%"",cols=""^3,^3,^3,^4,^4,^3,^3,^3,^7,<10""]
|========================
|31 30 |29 27 |26 25 |24  20 |19    15 |14  12 |11 10 |9 7 |6  0 |Opcode

2+|00100|vm|vs2|vs1|000 2+|vd|1010111|VSRLN.VV
2+|00100|vm|vs2|vs1|100 2+|vd|1010111|VSRLN.VS
2+|00100|vm|imm[4:0]|vs1|101 2+|vd|1010111|VSRLN.VI
2+|00100|vm|vs2|vs1|010 2+|vd|1010111|VSRLN.WV
2+|00100|vm|vs2|vs1|110 2+|vd|1010111|VSRLN.WS
2+|00100|vm|vs2|vs1|111 2+|vd|1010111|VSRLN.WI
2+|00101|vm|vs2|vs1|000 2+|vd|1010111|VSRAN.VV
2+|00101|vm|vs2|vs1|100 2+|vd|1010111|VSRAN.VS
2+|00101|vm|imm[4:0]|vs1|101 2+|vd|1010111|VSRAN.VI
2+|00101|vm|vs2|vs1|010 2+|vd|1010111|VSRAN.WV
2+|00101|vm|vs2|vs1|110 2+|vd|1010111|VSRAN.WS
2+|00101|vm|vs2|vs1|111 2+|vd|1010111|VSRAN.WI
2+|00110|vm|vs2|vs1|000 2+|vd|1010111|VCLIPN.VV
2+|00110|vm|vs2|vs1|100 2+|vd|1010111|VCLIPN.VS
2+|00110|vm|imm[4:0]|vs1|101 2+|vd|1010111|VCLIPN.VI
2+|00110|vm|vs2|vs1|010 2+|vd|1010111|VCLIPN.WV
2+|00110|vm|vs2|vs1|110 2+|vd|1010111|VCLIPN.WS
2+|00110|vm|vs2|vs1|111 2+|vd|1010111|VCLIPN.WI
2+|00111|vm|vs2|vs1|000 2+|vd|1010111|VCLIPUN.VV
2+|00111|vm|vs2|vs1|100 2+|vd|1010111|VCLIPUN.VS
2+|00111|vm|imm[4:0]|vs1|101 2+|vd|1010111|VCLIPUN.VI
2+|00111|vm|vs2|vs1|010 2+|vd|1010111|VCLIPUN.WV
2+|00111|vm|vs2|vs1|110 2+|vd|1010111|VCLIPUN.WS
2+|00111|vm|vs2|vs1|111 2+|vd|1010111|VCLIPUN.WI
2+|10000|vm|vs2|vs1|000 2+|vd|1010111|VAND.VV
2+|10000|vm|vs2|vs1|100 2+|vd|1010111|VAND.VS
2+|10000|vm|imm[4:0]|vs1|101 2+|vd|1010111|VAND.VI
2+|10000|vm|vs2|vs1|010 2+|vd|1010111|VOR.VV
2+|10000|vm|vs2|vs1|110 2+|vd|1010111|VOR.VS
2+|10000|vm|imm[4:0]|vs1|111 2+|vd|1010111|VOR.VI
2+|10001|vm|vs2|vs1|000 2+|vd|1010111|VXOR.VV
2+|10001|vm|vs2|vs1|100 2+|vd|1010111|VXOR.VS
2+|10001|vm|imm[4:0]|vs1|101 2+|vd|1010111|VXOR.VI
2+|10010|vm|vs2|vs1|000 2+|vd|1010111|VSLL.VV
2+|10010|vm|vs2|vs1|100 2+|vd|1010111|VSLL.VS
2+|10010|vm|imm[4:0]|vs1|101 2+|vd|1010111|VSLL.VI
2+|10011|vm|vs2|vs1|000 2+|vd|1010111|VSRL.VV
2+|10011|vm|vs2|vs1|100 2+|vd|1010111|VSRL.VS
2+|10011|vm|imm[4:0]|vs1|101 2+|vd|1010111|VSRL.VI
2+|10011|vm|vs2|vs1|010 2+|vd|1010111|VSRA.VV
2+|10011|vm|vs2|vs1|110 2+|vd|1010111|VSRA.VS
2+|10011|vm|imm[4:0]|vs1|111 2+|vd|1010111|VSRA.VI
2+|10100|vm|vs2|vs1|000 2+|vd|1010111|VSEQ.VV
2+|10100|vm|vs2|vs1|100 2+|vd|1010111|VSEQ.VS
2+|10100|vm|imm[4:0]|vs1|101 2+|vd|1010111|VSEQ.VI
2+|10100|vm|vs2|vs1|010 2+|vd|1010111|VSNE.VV
2+|10100|vm|vs2|vs1|110 2+|vd|1010111|VSNE.VS
2+|10100|vm|imm[4:0]|vs1|111 2+|vd|1010111|VSNE.VI
2+|10101|vm|vs2|vs1|000 2+|vd|1010111|VSLT.VV
2+|10101|vm|vs2|vs1|100 2+|vd|1010111|VSLT.VS
2+|10101|vm|imm[4:0]|vs1|101 2+|vd|1010111|VSLT.VI
2+|10101|vm|vs2|vs1|010 2+|vd|1010111|VSLTU.VV
2+|10101|vm|vs2|vs1|110 2+|vd|1010111|VSLTU.VS
2+|10101|vm|imm[4:0]|vs1|111 2+|vd|1010111|VSLTU.VI
2+|10110|vm|vs2|vs1|000 2+|vd|1010111|VSLE.VV
2+|10110|vm|vs2|vs1|100 2+|vd|1010111|VSLE.VS
2+|10110|vm|imm[4:0]|vs1|101 2+|vd|1010111|VSLE.VI
2+|10110|vm|vs2|vs1|010 2+|vd|1010111|VSLEU.VV
2+|10110|vm|vs2|vs1|110 2+|vd|1010111|VSLEU.VS
2+|10110|vm|imm[4:0]|vs1|111 2+|vd|1010111|VSLEU.VI
2+|11000|vm|vs2|vs1|000 2+|vd|1010111|VMULH.VV
2+|11000|vm|vs2|vs1|100 2+|vd|1010111|VMULH.VS
2+|11000|vm|imm[4:0]|vs1|101 2+|vd|1010111|VMULH.VI
2+|11001|vm|vs2|vs1|000 2+|vd|1010111|VDIV.VV
2+|11001|vm|vs2|vs1|100 2+|vd|1010111|VDIV.VS
2+|11001|vm|imm[4:0]|vs1|101 2+|vd|1010111|VDIV.VI
2+|11001|vm|vs2|vs1|010 2+|vd|1010111|VDIVU.VV
2+|11001|vm|vs2|vs1|110 2+|vd|1010111|VDIVU.VS
2+|11001|vm|imm[4:0]|vs1|111 2+|vd|1010111|VDIVU.VI
2+|11010|vm|vs2|vs1|000 2+|vd|1010111|VREM.VV
2+|11010|vm|vs2|vs1|100 2+|vd|1010111|VREM.VS
2+|11010|vm|imm[4:0]|vs1|101 2+|vd|1010111|VREM.VI
2+|11010|vm|vs2|vs1|010 2+|vd|1010111|VREMU.VV
2+|11010|vm|vs2|vs1|110 2+|vd|1010111|VREMU.VS
2+|11010|vm|imm[4:0]|vs1|111 2+|vd|1010111|VREMU.VI
2+|11011|vm|00000|vs1|000 2+|vd|1010111|VSQRT.VV
2+|11011|vm|00000|vs1|100 2+|vd|1010111|VSQRT.VS
2+|11011|vm|00000|vs1|101 2+|vd|1010111|VSQRT.VI
2+|11011|vm|00001|vs1|000 2+|vd|1010111|VFCLASS.VV
2+|11011|vm|00001|vs1|100 2+|vd|1010111|VFCLASS.VS
2+|11011|vm|00001|vs1|101 2+|vd|1010111|VFCLASS.VI
2+|11100|vm|vs2|vs1|000 2+|vd|1010111|VFSGNJ.VV
2+|11100|vm|vs2|vs1|100 2+|vd|1010111|VFSGNJ.VS
2+|11100|vm|imm[4:0]|vs1|101 2+|vd|1010111|VFSGNJ.VI
2+|11100|vm|vs2|vs1|010 2+|vd|1010111|VFSGNJN.VV
2+|11100|vm|vs2|vs1|110 2+|vd|1010111|VFSGNJN.VS
2+|11100|vm|imm[4:0]|vs1|111 2+|vd|1010111|VFSGNJN.VI
2+|11101|vm|vs2|vs1|000 2+|vd|1010111|VFSGNJX.VV
2+|11101|vm|vs2|vs1|100 2+|vd|1010111|VFSGNJX.VS
2+|11101|vm|imm[4:0]|vs1|101 2+|vd|1010111|VFSGNJX.VI
2+|11110|vm|vs2|vs1|000 2+|vd|1010111|VFMIN.VV
2+|11110|vm|vs2|vs1|100 2+|vd|1010111|VFMIN.VS
2+|11110|vm|imm[4:0]|vs1|101 2+|vd|1010111|VFMIN.VI
2+|11110|vm|vs2|vs1|010 2+|vd|1010111|VFMAX.VV
2+|11110|vm|vs2|vs1|110 2+|vd|1010111|VFMAX.VS
2+|11110|vm|imm[4:0]|vs1|111 2+|vd|1010111|VFMAX.VI

|========================


.Vector Table
[width=""100%"",cols=""^3,^3,^3,^4,^4,^3,^3,^3,^7,<10""]
|========================
|31 30 |29 27 |26 25 |24  20 |19    15 |14  12 |11 10 |9 7 |6  0 |Opcode

2+|11011|vm|00000|vs1|010 2+|rd|1010111|VMPOPC
2+|11011|vm|00001|vs1|010 2+|rd|1010111|VMFIRST
2+|11011|vm|00000|vs1|011 2+|vd|1010111|VMSBF.V
2+|11011|vm|00001|vs1|011 2+|vd|1010111|VMSIF.V
2+|11011|vm|00010|vs1|011 2+|vd|1010111|VMSOF.V
2+|11011|vm|11111|00000|000 2+|vd|1010111|VIOTA.V
2+|11111|vm|vs2|vs1|000 2+|vd|1010111|VMERGE.VV
2+|11111|vm|vs2|vs1|100 2+|vd|1010111|VMERGE.VS
2+|11111|vm|imm[4:0]|vs1|101 2+|vd|1010111|VMERGE.VI
2+|01101|00|rs2|vs1|000 2+|rd|1010111|VMV.X.V
2+|01101|01|rs2|rs1|000 2+|vd|1010111|VMV.V.X
2+|01101|10|rs2|vs1|000 2+|vd|1010111|VMV.S.V
2+|01101|11|rs2|vs1|000 2+|vd|1010111|VMV.V.S
2+|01101|vm|vs2|vs1|011 2+|vd|1010111|VRGATHER.VV
2+|01101|vm|vs2|vs1|100 2+|vd|1010111|VSLIDEUP.VS
2+|01101|vm|imm[4:0]|00000|101 2+|vd|1010111|VSLIDEUP.VI
2+|01101|vm|vs2|vs1|110 2+|vd|1010111|VSLIDEDOWN.VS
2+|01101|vm|imm[4:0]|vs1|111 2+|vd|1010111|VSLIDEDOWN.VI
2+|01110|vm|vs2|vs1|000 2+|vd|1010111|VREDSUM.V
2+|01110|vm|vs2|vs1|010 2+|vd|1010111|VREDSUMW.V
2+|01110|vm|vs2|vs1|001 2+|vd|1010111|VREDMAX.V
2+|01110|vm|vs2|vs1|011 2+|vd|1010111|VREDMAXU.V
2+|01110|vm|vs2|vs1|100 2+|vd|1010111|VREDMIN.V
2+|01110|vm|vs2|vs1|110 2+|vd|1010111|VREDMINU.V
2+|01111|vm|vs2|vs1|000 2+|vd|1010111|VREDAND.V
2+|01111|vm|vs2|vs1|001 2+|vd|1010111|VREDOR.V
2+|01111|vm|vs2|vs1|010 2+|vd|1010111|VREDXOR.V
2+|vs3|vm|vs2|vs1|101 2+|vd|1000011|VMADD.VVV
2+|vs3|vm|vs2|vs1|110 2+|vd|1000011|VMADD.VVS
2+|vs3|vm|vs2|vs1|101 2+|vd|1000111|VMSUB.VVV
2+|vs3|vm|vs2|vs1|110 2+|vd|1000111|VMSUB.VVS
2+|vs3|vm|vs2|vs1|101 2+|vd|1001011|VMADDW.VVV
2+|vs3|vm|vs2|vs1|110 2+|vd|1001011|VMADDW.VVS
2+|vs3|vm|vs2|vs1|101 2+|vd|1001111|VMSUBW.VVV
2+|vs3|vm|vs2|vs1|110 2+|vd|1001111|VMSUBW.VVS

|========================
////
",12122,True,2962.4384085451757,median
"// Copyright (c) 2014 The Bitcoin Core developers
// Copyright (c) 2019 The quirkyturtcoin developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.

#include ""crypto/aes.h""
#include ""crypto/rfc6979_hmac_sha256.h""
#include ""crypto/chacha20.h""
#include ""crypto/ripemd160.h""
#include ""crypto/sha1.h""
#include ""crypto/sha256.h""
#include ""crypto/sha512.h""
#include ""crypto/hmac_sha256.h""
#include ""crypto/hmac_sha512.h""
#include ""random.h""
#include ""utilstrencodings.h""
#include ""test/test_quirkyturtcoin.h""

#include <vector>

#include <boost/test/unit_test.hpp>

BOOST_FIXTURE_TEST_SUITE(crypto_tests, BasicTestingSetup)

template<typename Hasher, typename In, typename Out>
void TestVector(const Hasher &h, const In &in, const Out &out) {
    Out hash;
    BOOST_CHECK(out.size() == h.OUTPUT_SIZE);
    hash.resize(out.size());
    {
        // Test that writing the whole input string at once works.
        Hasher(h).Write((unsigned char*)&in[0], in.size()).Finalize(&hash[0]);
        BOOST_CHECK(hash == out);
    }
    for (int i=0; i<32; i++) {
        // Test that writing the string broken up in random pieces works.
        Hasher hasher(h);
        size_t pos = 0;
        while (pos < in.size()) {
            size_t len = InsecureRandRange((in.size() - pos + 1) / 2 + 1);
            hasher.Write((unsigned char*)&in[pos], len);
            pos += len;
            if (pos > 0 && pos + 2 * out.size() > in.size() && pos < in.size()) {
                // Test that writing the rest at once to a copy of a hasher works.
                Hasher(hasher).Write((unsigned char*)&in[pos], in.size() - pos).Finalize(&hash[0]);
                BOOST_CHECK(hash == out);
            }
        }
        hasher.Finalize(&hash[0]);
        BOOST_CHECK(hash == out);
    }
}

void TestSHA1(const std::string &in, const std::string &hexout) { TestVector(CSHA1(), in, ParseHex(hexout));}
void TestSHA256(const std::string &in, const std::string &hexout) { TestVector(CSHA256(), in, ParseHex(hexout));}
void TestSHA512(const std::string &in, const std::string &hexout) { TestVector(CSHA512(), in, ParseHex(hexout));}
void TestRIPEMD160(const std::string &in, const std::string &hexout) { TestVector(CRIPEMD160(), in, ParseHex(hexout));}

void TestHMACSHA256(const std::string &hexkey, const std::string &hexin, const std::string &hexout) {
    std::vector<unsigned char> key = ParseHex(hexkey);
    TestVector(CHMAC_SHA256(&key[0], key.size()), ParseHex(hexin), ParseHex(hexout));
}

void TestHMACSHA512(const std::string &hexkey, const std::string &hexin, const std::string &hexout) {
    std::vector<unsigned char> key = ParseHex(hexkey);
    TestVector(CHMAC_SHA512(&key[0], key.size()), ParseHex(hexin), ParseHex(hexout));
}

void TestChaCha20(const std::string &hex_message, const std::string &hexkey, uint64_t nonce, uint64_t seek, const std::string& hexout)
{
    std::vector<unsigned char> key = ParseHex(hexkey);
    std::vector<unsigned char> m = ParseHex(hex_message);
    ChaCha20 rng(key.data(), key.size());
    rng.SetIV(nonce);
    rng.Seek(seek);
    std::vector<unsigned char> out = ParseHex(hexout);
    std::vector<unsigned char> outres;
    outres.resize(out.size());
    assert(hex_message.empty() || m.size() == out.size());

    // perform the ChaCha20 round(s), if message is provided it will output the encrypted ciphertext otherwise the keystream
    if (!hex_message.empty()) {
        rng.Crypt(m.data(), outres.data(), outres.size());
    } else {
        rng.Keystream(outres.data(), outres.size());
    }
    BOOST_CHECK(out == outres);
    if (!hex_message.empty()) {
        // Manually XOR with the keystream and compare the output
        rng.SetIV(nonce);
        rng.Seek(seek);
        std::vector<unsigned char> only_keystream(outres.size());
        rng.Keystream(only_keystream.data(), only_keystream.size());
        for (size_t i = 0; i != m.size(); i++) {
            outres[i] = m[i] ^ only_keystream[i];
        }
        BOOST_CHECK(out == outres);
    }
}

void TestAES128(const std::string &hexkey, const std::string &hexin, const std::string &hexout)
{
    std::vector<unsigned char> key = ParseHex(hexkey);
    std::vector<unsigned char> in = ParseHex(hexin);
    std::vector<unsigned char> correctout = ParseHex(hexout);
    std::vector<unsigned char> buf, buf2;

    assert(key.size() == 16);
    assert(in.size() == 16);
    assert(correctout.size() == 16);
    AES128Encrypt enc(&key[0]);
    buf.resize(correctout.size());
    buf2.resize(correctout.size());
    enc.Encrypt(&buf[0], &in[0]);
    BOOST_CHECK_EQUAL(HexStr(buf), HexStr(correctout));
    AES128Decrypt dec(&key[0]);
    dec.Decrypt(&buf2[0], &buf[0]);
    BOOST_CHECK_EQUAL(HexStr(buf2), HexStr(in));
}

void TestAES256(const std::string &hexkey, const std::string &hexin, const std::string &hexout)
{
    std::vector<unsigned char> key = ParseHex(hexkey);
    std::vector<unsigned char> in = ParseHex(hexin);
    std::vector<unsigned char> correctout = ParseHex(hexout);
    std::vector<unsigned char> buf;

    assert(key.size() == 32);
    assert(in.size() == 16);
    assert(correctout.size() == 16);
    AES256Encrypt enc(&key[0]);
    buf.resize(correctout.size());
    enc.Encrypt(&buf[0], &in[0]);
    BOOST_CHECK(buf == correctout);
    AES256Decrypt dec(&key[0]);
    dec.Decrypt(&buf[0], &buf[0]);
    BOOST_CHECK(buf == in);
}

void TestAES128CBC(const std::string &hexkey, const std::string &hexiv, bool pad, const std::string &hexin, const std::string &hexout)
{
    std::vector<unsigned char> key = ParseHex(hexkey);
    std::vector<unsigned char> iv = ParseHex(hexiv);
    std::vector<unsigned char> in = ParseHex(hexin);
    std::vector<unsigned char> correctout = ParseHex(hexout);
    std::vector<unsigned char> realout(in.size() + AES_BLOCKSIZE);

    // Encrypt the plaintext and verify that it equals the cipher
    AES128CBCEncrypt enc(&key[0], &iv[0], pad);
    int size = enc.Encrypt(&in[0], in.size(), &realout[0]);
    realout.resize(size);
    BOOST_CHECK(realout.size() == correctout.size());
    BOOST_CHECK_MESSAGE(realout == correctout, HexStr(realout) + std::string("" != "") + hexout);

    // Decrypt the cipher and verify that it equals the plaintext
    std::vector<unsigned char> decrypted(correctout.size());
    AES128CBCDecrypt dec(&key[0], &iv[0], pad);
    size = dec.Decrypt(&correctout[0], correctout.size(), &decrypted[0]);
    decrypted.resize(size);
    BOOST_CHECK(decrypted.size() == in.size());
    BOOST_CHECK_MESSAGE(decrypted == in, HexStr(decrypted) + std::string("" != "") + hexin);

    // Encrypt and re-decrypt substrings of the plaintext and verify that they equal each-other
    for(std::vector<unsigned char>::iterator i(in.begin()); i != in.end(); ++i)
    {
        std::vector<unsigned char> sub(i, in.end());
        std::vector<unsigned char> subout(sub.size() + AES_BLOCKSIZE);
        int size = enc.Encrypt(&sub[0], sub.size(), &subout[0]);
        if (size != 0)
        {
            subout.resize(size);
            std::vector<unsigned char> subdecrypted(subout.size());
            size = dec.Decrypt(&subout[0], subout.size(), &subdecrypted[0]);
            subdecrypted.resize(size);
            BOOST_CHECK(decrypted.size() == in.size());
            BOOST_CHECK_MESSAGE(subdecrypted == sub, HexStr(subdecrypted) + std::string("" != "") + HexStr(sub));
        }
    }
}

void TestAES256CBC(const std::string &hexkey, const std::string &hexiv, bool pad, const std::string &hexin, const std::string &hexout)
{
    std::vector<unsigned char> key = ParseHex(hexkey);
    std::vector<unsigned char> iv = ParseHex(hexiv);
    std::vector<unsigned char> in = ParseHex(hexin);
    std::vector<unsigned char> correctout = ParseHex(hexout);
    std::vector<unsigned char> realout(in.size() + AES_BLOCKSIZE);

    // Encrypt the plaintext and verify that it equals the cipher
    AES256CBCEncrypt enc(&key[0], &iv[0], pad);
    int size = enc.Encrypt(&in[0], in.size(), &realout[0]);
    realout.resize(size);
    BOOST_CHECK(realout.size() == correctout.size());
    BOOST_CHECK_MESSAGE(realout == correctout, HexStr(realout) + std::string("" != "") + hexout);

    // Decrypt the cipher and verify that it equals the plaintext
    std::vector<unsigned char> decrypted(correctout.size());
    AES256CBCDecrypt dec(&key[0], &iv[0], pad);
    size = dec.Decrypt(&correctout[0], correctout.size(), &decrypted[0]);
    decrypted.resize(size);
    BOOST_CHECK(decrypted.size() == in.size());
    BOOST_CHECK_MESSAGE(decrypted == in, HexStr(decrypted) + std::string("" != "") + hexin);

    // Encrypt and re-decrypt substrings of the plaintext and verify that they equal each-other
    for(std::vector<unsigned char>::iterator i(in.begin()); i != in.end(); ++i)
    {
        std::vector<unsigned char> sub(i, in.end());
        std::vector<unsigned char> subout(sub.size() + AES_BLOCKSIZE);
        int size = enc.Encrypt(&sub[0], sub.size(), &subout[0]);
        if (size != 0)
        {
            subout.resize(size);
            std::vector<unsigned char> subdecrypted(subout.size());
            size = dec.Decrypt(&subout[0], subout.size(), &subdecrypted[0]);
            subdecrypted.resize(size);
            BOOST_CHECK(decrypted.size() == in.size());
            BOOST_CHECK_MESSAGE(subdecrypted == sub, HexStr(subdecrypted) + std::string("" != "") + HexStr(sub));
        }
    }
}

std::string LongTestString(void) {
    std::string ret;
    for (int i=0; i<200000; i++) {
        ret += (unsigned char)(i);
        ret += (unsigned char)(i >> 4);
        ret += (unsigned char)(i >> 8);
        ret += (unsigned char)(i >> 12);
        ret += (unsigned char)(i >> 16);
    }
    return ret;
}

const std::string test1 = LongTestString();

BOOST_AUTO_TEST_CASE(ripemd160_testvectors) {
    TestRIPEMD160("""", ""9c1185a5c5e9fc54612808977ee8f548b2258d31"");
    TestRIPEMD160(""abc"", ""8eb208f7e05d987a9b044a8e98c6b087f15a0bfc"");
    TestRIPEMD160(""message digest"", ""5d0689ef49d2fae572b881b123a85ffa21595f36"");
    TestRIPEMD160(""secure hash algorithm"", ""20397528223b6a5f4cbc2808aba0464e645544f9"");
    TestRIPEMD160(""RIPEMD160 is considered to be safe"", ""a7d78608c7af8a8e728778e81576870734122b66"");
    TestRIPEMD160(""abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"",
                  ""12a053384a9c0c88e405a06c27dcf49ada62eb2b"");
    TestRIPEMD160(""For this sample, this 63-byte string will be used as input data"",
                  ""de90dbfee14b63fb5abf27c2ad4a82aaa5f27a11"");
    TestRIPEMD160(""This is exactly 64 bytes long, not counting the terminating byte"",
                  ""eda31d51d3a623b81e19eb02e24ff65d27d67b37"");
    TestRIPEMD160(std::string(1000000, 'a'), ""52783243c1697bdbe16d37f97f68f08325dc1528"");
    TestRIPEMD160(test1, ""464243587bd146ea835cdf57bdae582f25ec45f1"");
}

BOOST_AUTO_TEST_CASE(sha1_testvectors) {
    TestSHA1("""", ""da39a3ee5e6b4b0d3255bfef95601890afd80709"");
    TestSHA1(""abc"", ""a9993e364706816aba3e25717850c26c9cd0d89d"");
    TestSHA1(""message digest"", ""c12252ceda8be8994d5fa0290a47231c1d16aae3"");
    TestSHA1(""secure hash algorithm"", ""d4d6d2f0ebe317513bbd8d967d89bac5819c2f60"");
    TestSHA1(""SHA1 is considered to be safe"", ""f2b6650569ad3a8720348dd6ea6c497dee3a842a"");
    TestSHA1(""abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"",
             ""84983e441c3bd26ebaae4aa1f95129e5e54670f1"");
    TestSHA1(""For this sample, this 63-byte string will be used as input data"",
             ""4f0ea5cd0585a23d028abdc1a6684e5a8094dc49"");
    TestSHA1(""This is exactly 64 bytes long, not counting the terminating byte"",
             ""fb679f23e7d1ce053313e66e127ab1b444397057"");
    TestSHA1(std::string(1000000, 'a'), ""34aa973cd4c4daa4f61eeb2bdbad27316534016f"");
    TestSHA1(test1, ""b7755760681cbfd971451668f32af5774f4656b5"");
}

BOOST_AUTO_TEST_CASE(sha256_testvectors) {
    TestSHA256("""", ""e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"");
    TestSHA256(""abc"", ""ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad"");
    TestSHA256(""message digest"",
               ""f7846f55cf23e14eebeab5b4e1550cad5b509e3348fbc4efa3a1413d393cb650"");
    TestSHA256(""secure hash algorithm"",
               ""f30ceb2bb2829e79e4ca9753d35a8ecc00262d164cc077080295381cbd643f0d"");
    TestSHA256(""SHA256 is considered to be safe"",
               ""6819d915c73f4d1e77e4e1b52d1fa0f9cf9beaead3939f15874bd988e2a23630"");
    TestSHA256(""abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"",
               ""248d6a61d20638b8e5c026930c3e6039a33ce45964ff2167f6ecedd419db06c1"");
    TestSHA256(""For this sample, this 63-byte string will be used as input data"",
               ""f08a78cbbaee082b052ae0708f32fa1e50c5c421aa772ba5dbb406a2ea6be342"");
    TestSHA256(""This is exactly 64 bytes long, not counting the terminating byte"",
               ""ab64eff7e88e2e46165e29f2bce41826bd4c7b3552f6b382a9e7d3af47c245f8"");
    TestSHA256(""As Bitcoin relies on 80 byte header hashes, we want to have an example for that."",
               ""7406e8de7d6e4fffc573daef05aefb8806e7790f55eab5576f31349743cca743"");
    TestSHA256(std::string(1000000, 'a'),
               ""cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0"");
    TestSHA256(test1, ""a316d55510b49662420f49d145d42fb83f31ef8dc016aa4e32df049991a91e26"");
}

BOOST_AUTO_TEST_CASE(sha512_testvectors) {
    TestSHA512("""",
               ""cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce""
               ""47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e"");
    TestSHA512(""abc"",
               ""ddaf35a193617abacc417349ae20413112e6fa4e89a97ea20a9eeee64b55d39a""
               ""2192992a274fc1a836ba3c23a3feebbd454d4423643ce80e2a9ac94fa54ca49f"");
    TestSHA512(""message digest"",
               ""107dbf389d9e9f71a3a95f6c055b9251bc5268c2be16d6c13492ea45b0199f33""
               ""09e16455ab1e96118e8a905d5597b72038ddb372a89826046de66687bb420e7c"");
    TestSHA512(""secure hash algorithm"",
               ""7746d91f3de30c68cec0dd693120a7e8b04d8073cb699bdce1a3f64127bca7a3""
               ""d5db502e814bb63c063a7a5043b2df87c61133395f4ad1edca7fcf4b30c3236e"");
    TestSHA512(""SHA512 is considered to be safe"",
               ""099e6468d889e1c79092a89ae925a9499b5408e01b66cb5b0a3bd0dfa51a9964""
               ""6b4a3901caab1318189f74cd8cf2e941829012f2449df52067d3dd5b978456c2"");
    TestSHA512(""abcdbcdecdefdefgefghfghighijhijkijkljklmklmnlmnomnopnopq"",
               ""204a8fc6dda82f0a0ced7beb8e08a41657c16ef468b228a8279be331a703c335""
               ""96fd15c13b1b07f9aa1d3bea57789ca031ad85c7a71dd70354ec631238ca3445"");
    TestSHA512(""For this sample, this 63-byte string will be used as input data"",
               ""b3de4afbc516d2478fe9b518d063bda6c8dd65fc38402dd81d1eb7364e72fb6e""
               ""6663cf6d2771c8f5a6da09601712fb3d2a36c6ffea3e28b0818b05b0a8660766"");
    TestSHA512(""This is exactly 64 bytes long, not counting the terminating byte"",
               ""70aefeaa0e7ac4f8fe17532d7185a289bee3b428d950c14fa8b713ca09814a38""
               ""7d245870e007a80ad97c369d193e41701aa07f3221d15f0e65a1ff970cedf030"");
    TestSHA512(""abcdefghbcdefghicdefghijdefghijkefghijklfghijklmghijklmnhijklmno""
               ""ijklmnopjklmnopqklmnopqrlmnopqrsmnopqrstnopqrstu"",
               ""8e959b75dae313da8cf4f72814fc143f8f7779c6eb9f7fa17299aeadb6889018""
               ""501d289e4900f7e4331b99dec4b5433ac7d329eeb6dd26545e96e55b874be909"");
    TestSHA512(std::string(1000000, 'a'),
               ""e718483d0ce769644e2e42c7bc15b4638e1f98b13b2044285632a803afa973eb""
               ""de0ff244877ea60a4cb0432ce577c31beb009c5c2c49aa2e4eadb217ad8cc09b"");
    TestSHA512(test1,
               ""40cac46c147e6131c5193dd5f34e9d8bb4951395f27b08c558c65ff4ba2de594""
               ""37de8c3ef5459d76a52cedc02dc499a3c9ed9dedbfb3281afd9653b8a112fafc"");
}

BOOST_AUTO_TEST_CASE(hmac_sha256_testvectors) {
    // test cases 1, 2, 3, 4, 6 and 7 of RFC 4231
    TestHMACSHA256(""0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b"",
                   ""4869205468657265"",
                   ""b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7"");
    TestHMACSHA256(""4a656665"",
                   ""7768617420646f2079612077616e7420666f72206e6f7468696e673f"",
                   ""5bdcc146bf60754e6a042426089575c75a003f089d2739839dec58b964ec3843"");
    TestHMACSHA256(""aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"",
                   ""dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd""
                   ""dddddddddddddddddddddddddddddddddddd"",
                   ""773ea91e36800e46854db8ebd09181a72959098b3ef8c122d9635514ced565fe"");
    TestHMACSHA256(""0102030405060708090a0b0c0d0e0f10111213141516171819"",
                   ""cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd""
                   ""cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd"",
                   ""82558a389a443c0ea4cc819899f2083a85f0faa3e578f8077a2e3ff46729665b"");
    TestHMACSHA256(""aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa""
                   ""aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa""
                   ""aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa""
                   ""aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa""
                   ""aaaaaa"",
                   ""54657374205573696e67204c6172676572205468616e20426c6f636b2d53697a""
                   ""65204b6579202d2048617368204b6579204669727374"",
                   ""60e431591ee0b67f0d8a26aacbf5b77f8e0bc6213728c5140546040f0ee37f54"");
    TestHMACSHA256(""aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa""
                   ""aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa""
                   ""aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa""
                   ""aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa""
                   ""aaaaaa"",
                   ""5468697320697320612074657374207573696e672061206c6172676572207468""
                   ""616e20626c6f636b2d73697a65206b657920616e642061206c61726765722074""
                   ""68616e20626c6f636b2d73697a6520646174612e20546865206b6579206e6565""
                   ""647320746f20626520686173686564206265666f7265206265696e6720757365""
                   ""642062792074686520484d414320616c676f726974686d2e"",
                   ""9b09ffa71b942fcb27635fbcd5b0e944bfdc63644f0713938a7f51535c3a35e2"");
}

BOOST_AUTO_TEST_CASE(hmac_sha512_testvectors) {
    // test cases 1, 2, 3, 4, 6 and 7 of RFC 4231
    TestHMACSHA512(""0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b0b"",
                   ""4869205468657265"",
                   ""87aa7cdea5ef619d4ff0b4241a1d6cb02379f4e2ce4ec2787ad0b30545e17cde""
                   ""daa833b7d6b8a702038b274eaea3f4e4be9d914eeb61f1702e696c203a126854"");
    TestHMACSHA512(""4a656665"",
                   ""7768617420646f2079612077616e7420666f72206e6f7468696e673f"",
                   ""164b7a7bfcf819e2e395fbe73b56e0a387bd64222e831fd610270cd7ea250554""
                   ""9758bf75c05a994a6d034f65f8f0e6fdcaeab1a34d4a6b4b636e070a38bce737"");
    TestHMACSHA512(""aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"",
                   ""dddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd""
                   ""dddddddddddddddddddddddddddddddddddd"",
                   ""fa73b0089d56a284efb0f0756c890be9b1b5dbdd8ee81a3655f83e33b2279d39""
                   ""bf3e848279a722c806b485a47e67c807b946a337bee8942674278859e13292fb"");
    TestHMACSHA512(""0102030405060708090a0b0c0d0e0f10111213141516171819"",
                   ""cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd""
                   ""cdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcdcd"",
                   ""b0ba465637458c6990e5a8c5f61d4af7e576d97ff94b872de76f8050361ee3db""
                   ""a91ca5c11aa25eb4d679275cc5788063a5f19741120c4f2de2adebeb10a298dd"");
    TestHMACSHA512(""aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa""
                   ""aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa""
                   ""aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa""
                   ""aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa""
                   ""aaaaaa"",
                   ""54657374205573696e67204c6172676572205468616e20426c6f636b2d53697a""
                   ""65204b6579202d2048617368204b6579204669727374"",
                   ""80b24263c7c1a3ebb71493c1dd7be8b49b46d1f41b4aeec1121b013783f8f352""
                   ""6b56d037e05f2598bd0fd2215d6a1e5295e64f73f63f0aec8b915a985d786598"");
    TestHMACSHA512(""aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa""
                   ""aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa""
                   ""aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa""
                   ""aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa""
                   ""aaaaaa"",
                   ""5468697320697320612074657374207573696e672061206c6172676572207468""
                   ""616e20626c6f636b2d73697a65206b657920616e642061206c61726765722074""
                   ""68616e20626c6f636b2d73697a6520646174612e20546865206b6579206e6565""
                   ""647320746f20626520686173686564206265666f7265206265696e6720757365""
                   ""642062792074686520484d414320616c676f726974686d2e"",
                   ""e37b6a775dc87dbaa4dfa9f96e5e3ffddebd71f8867289865df5a32d20cdc944""
                   ""b6022cac3c4982b10d5eeb55c3e4de15134676fb6de0446065c97440fa8c6a58"");
}

void TestRFC6979(const std::string& hexkey, const std::string& hexmsg, const std::vector<std::string>& hexout)
{
    std::vector<unsigned char> key = ParseHex(hexkey);
    std::vector<unsigned char> msg = ParseHex(hexmsg);
    RFC6979_HMAC_SHA256 rng(&key[0], key.size(), &msg[0], msg.size());

    for (unsigned int i = 0; i < hexout.size(); i++) {
        std::vector<unsigned char> out = ParseHex(hexout[i]);
        std::vector<unsigned char> gen;
        gen.resize(out.size());
        rng.Generate(&gen[0], gen.size());
        BOOST_CHECK(out == gen);
    }
}

BOOST_AUTO_TEST_CASE(rfc6979_hmac_sha256)
{
    TestRFC6979(
        ""0102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f00"",
        ""4bf5122f344554c53bde2ebb8cd2b7e3d1600ad631c385a5d7cce23c7785459a"",
        {""4fe29525b2086809159acdf0506efb86b0ec932c7ba44256ab321e421e67e9fb"",
            ""2bf0fff1d3c378a22dc5de1d856522325c65b504491a0cbd01cb8f3aa67ffd4a"",
            ""f528b410cb541f77000d7afb6c5b53c5c471eab43e466d9ac5190c39c82fd82e""});

    TestRFC6979(
        ""FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"",
        ""e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"",
        {""9c236c165b82ae0cd590659e100b6bab3036e7ba8b06749baf6981e16f1a2b95"",
            ""df471061625bc0ea14b682feee2c9c02f235da04204c1d62a1536c6e17aed7a9"",
            ""7597887cbd76321f32e30440679a22cf7f8d9d2eac390e581fea091ce202ba94""});
}


BOOST_AUTO_TEST_CASE(chacha20_testvector)
{
    // Test vector from RFC 7539

    // test encryption
    TestChaCha20(""4c616469657320616e642047656e746c656d656e206f662074686520636c617373206f66202739393a204966204920636f756""
                 ""c64206f6666657220796f75206f6e6c79206f6e652074697020666f7220746865206675747572652c2073756e73637265656e""
                 ""20776f756c642062652069742e"",
                 ""000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"", 0x4a000000UL, 1,
                 ""6e2e359a2568f98041ba0728dd0d6981e97e7aec1d4360c20a27afccfd9fae0bf91b65c5524733ab8f593dabcd62b3571639d""
                 ""624e65152ab8f530c359f0861d807ca0dbf500d6a6156a38e088a22b65e52bc514d16ccf806818ce91ab77937365af90bbf74""
                 ""a35be6b40b8eedf2785e42874d""
    );

    // test keystream output
    TestChaCha20("""", ""000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"", 0x4a000000UL, 1,
                 ""224f51f3401bd9e12fde276fb8631ded8c131f823d2c06e27e4fcaec9ef3cf788a3b0aa372600a92b57974cded2b9334794cb""
                 ""a40c63e34cdea212c4cf07d41b769a6749f3f630f4122cafe28ec4dc47e26d4346d70b98c73f3e9c53ac40c5945398b6eda1a""
                 ""832c89c167eacd901d7e2bf363"");

    // Test vectors from https://tools.ietf.org/html/draft-agl-tls-chacha20poly1305-04#section-7
    TestChaCha20("""", ""0000000000000000000000000000000000000000000000000000000000000000"", 0, 0,
                 ""76b8e0ada0f13d90405d6ae55386bd28bdd219b8a08ded1aa836efcc8b770dc7da41597c5157488d7724e03fb8d84a376a43b""
                 ""8f41518a11cc387b669b2ee6586"");
    TestChaCha20("""", ""0000000000000000000000000000000000000000000000000000000000000001"", 0, 0,
                 ""4540f05a9f1fb296d7736e7b208e3c96eb4fe1834688d2604f450952ed432d41bbe2a0b6ea7566d2a5d1e7e20d42af2c53d79""
                 ""2b1c43fea817e9ad275ae546963"");
    TestChaCha20("""", ""0000000000000000000000000000000000000000000000000000000000000000"", 0x0100000000000000ULL, 0,
                 ""de9cba7bf3d69ef5e786dc63973f653a0b49e015adbff7134fcb7df137821031e85a050278a7084527214f73efc7fa5b52770""
                 ""62eb7a0433e445f41e3"");
    TestChaCha20("""", ""0000000000000000000000000000000000000000000000000000000000000000"", 1, 0,
                 ""ef3fdfd6c61578fbf5cf35bd3dd33b8009631634d21e42ac33960bd138e50d32111e4caf237ee53ca8ad6426194a88545ddc4""
                 ""97a0b466e7d6bbdb0041b2f586b"");
    TestChaCha20("""", ""000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"", 0x0706050403020100ULL, 0,
                 ""f798a189f195e66982105ffb640bb7757f579da31602fc93ec01ac56f85ac3c134a4547b733b46413042c9440049176905d3b""
                 ""e59ea1c53f15916155c2be8241a38008b9a26bc35941e2444177c8ade6689de95264986d95889fb60e84629c9bd9a5acb1cc1""
                 ""18be563eb9b3a4a472f82e09a7e778492b562ef7130e88dfe031c79db9d4f7c7a899151b9a475032b63fc385245fe054e3dd5""
                 ""a97a5f576fe064025d3ce042c566ab2c507b138db853e3d6959660996546cc9c4a6eafdc777c040d70eaf46f76dad3979e5c5""
                 ""360c3317166a1c894c94a371876a94df7628fe4eaaf2ccb27d5aaae0ad7ad0f9d4b6ad3b54098746d4524d38407a6deb3ab78""
                 ""fab78c9"");
}

BOOST_AUTO_TEST_CASE(countbits_tests)
{
    FastRandomContext ctx;
    for (int i = 0; i <= 64; ++i) {
        if (i == 0) {
            // Check handling of zero.
            BOOST_CHECK_EQUAL(CountBits(0), 0);
        } else if (i < 10) {
            for (uint64_t j = 1 << (i - 1); (j >> i) == 0; ++j) {
                // Exhaustively test up to 10 bits
                BOOST_CHECK_EQUAL(CountBits(j), i);
            }
        } else {
            for (int k = 0; k < 1000; k++) {
                // Randomly test 1000 samples of each length above 10 bits.
                uint64_t j = ((uint64_t)1) << (i - 1) | ctx.randbits(i - 1);
                BOOST_CHECK_EQUAL(CountBits(j), i);
            }
        }
    }
}

BOOST_AUTO_TEST_CASE(aes_testvectors) {
        // AES test vectors from FIPS 197.
        TestAES128(""000102030405060708090a0b0c0d0e0f"", ""00112233445566778899aabbccddeeff"", ""69c4e0d86a7b0430d8cdb78070b4c55a"");
        TestAES256(""000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f"", ""00112233445566778899aabbccddeeff"", ""8ea2b7ca516745bfeafc49904b496089"");

        // AES-ECB test vectors from NIST sp800-38a.
        TestAES128(""2b7e151628aed2a6abf7158809cf4f3c"", ""6bc1bee22e409f96e93d7e117393172a"", ""3ad77bb40d7a3660a89ecaf32466ef97"");
        TestAES128(""2b7e151628aed2a6abf7158809cf4f3c"", ""ae2d8a571e03ac9c9eb76fac45af8e51"", ""f5d3d58503b9699de785895a96fdbaaf"");
        TestAES128(""2b7e151628aed2a6abf7158809cf4f3c"", ""30c81c46a35ce411e5fbc1191a0a52ef"", ""43b1cd7f598ece23881b00e3ed030688"");
        TestAES128(""2b7e151628aed2a6abf7158809cf4f3c"", ""f69f2445df4f9b17ad2b417be66c3710"", ""7b0c785e27e8ad3f8223207104725dd4"");
        TestAES256(""603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"", ""6bc1bee22e409f96e93d7e117393172a"", ""f3eed1bdb5d2a03c064b5a7e3db181f8"");
        TestAES256(""603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"", ""ae2d8a571e03ac9c9eb76fac45af8e51"", ""591ccb10d410ed26dc5ba74a31362870"");
        TestAES256(""603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"", ""30c81c46a35ce411e5fbc1191a0a52ef"", ""b6ed21b99ca6f4f9f153e7b1beafed1d"");
        TestAES256(""603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"", ""f69f2445df4f9b17ad2b417be66c3710"", ""23304b7a39f9f3ff067d8d8f9e24ecc7"");
}

BOOST_AUTO_TEST_CASE(aes_cbc_testvectors) {

    // NIST AES CBC 128-bit encryption test-vectors
    TestAES128CBC(""2b7e151628aed2a6abf7158809cf4f3c"", ""000102030405060708090A0B0C0D0E0F"", false, \\
                  ""6bc1bee22e409f96e93d7e117393172a"", ""7649abac8119b246cee98e9b12e9197d"");
    TestAES128CBC(""2b7e151628aed2a6abf7158809cf4f3c"", ""7649ABAC8119B246CEE98E9B12E9197D"", false, \\
                  ""ae2d8a571e03ac9c9eb76fac45af8e51"", ""5086cb9b507219ee95db113a917678b2"");
    TestAES128CBC(""2b7e151628aed2a6abf7158809cf4f3c"", ""5086cb9b507219ee95db113a917678b2"", false, \\
                  ""30c81c46a35ce411e5fbc1191a0a52ef"", ""73bed6b8e3c1743b7116e69e22229516"");
    TestAES128CBC(""2b7e151628aed2a6abf7158809cf4f3c"", ""73bed6b8e3c1743b7116e69e22229516"", false, \\
                  ""f69f2445df4f9b17ad2b417be66c3710"", ""3ff1caa1681fac09120eca307586e1a7"");

    // The same vectors with padding enabled
    TestAES128CBC(""2b7e151628aed2a6abf7158809cf4f3c"", ""000102030405060708090A0B0C0D0E0F"", true, \\
                  ""6bc1bee22e409f96e93d7e117393172a"", ""7649abac8119b246cee98e9b12e9197d8964e0b149c10b7b682e6e39aaeb731c"");
    TestAES128CBC(""2b7e151628aed2a6abf7158809cf4f3c"", ""7649ABAC8119B246CEE98E9B12E9197D"", true, \\
                  ""ae2d8a571e03ac9c9eb76fac45af8e51"", ""5086cb9b507219ee95db113a917678b255e21d7100b988ffec32feeafaf23538"");
    TestAES128CBC(""2b7e151628aed2a6abf7158809cf4f3c"", ""5086cb9b507219ee95db113a917678b2"", true, \\
                  ""30c81c46a35ce411e5fbc1191a0a52ef"", ""73bed6b8e3c1743b7116e69e22229516f6eccda327bf8e5ec43718b0039adceb"");
    TestAES128CBC(""2b7e151628aed2a6abf7158809cf4f3c"", ""73bed6b8e3c1743b7116e69e22229516"", true, \\
                  ""f69f2445df4f9b17ad2b417be66c3710"", ""3ff1caa1681fac09120eca307586e1a78cb82807230e1321d3fae00d18cc2012"");

    // NIST AES CBC 256-bit encryption test-vectors
    TestAES256CBC(""603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"", \\
                  ""000102030405060708090A0B0C0D0E0F"", false, ""6bc1bee22e409f96e93d7e117393172a"", \\
                  ""f58c4c04d6e5f1ba779eabfb5f7bfbd6"");
    TestAES256CBC(""603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"", \\
                  ""F58C4C04D6E5F1BA779EABFB5F7BFBD6"", false, ""ae2d8a571e03ac9c9eb76fac45af8e51"", \\
                  ""9cfc4e967edb808d679f777bc6702c7d"");
    TestAES256CBC(""603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"", \\
                  ""9CFC4E967EDB808D679F777BC6702C7D"", false, ""30c81c46a35ce411e5fbc1191a0a52ef"",
                  ""39f23369a9d9bacfa530e26304231461"");
    TestAES256CBC(""603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"", \\
                  ""39F23369A9D9BACFA530E26304231461"", false, ""f69f2445df4f9b17ad2b417be66c3710"", \\
                  ""b2eb05e2c39be9fcda6c19078c6a9d1b"");

    // The same vectors with padding enabled
    TestAES256CBC(""603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"", \\
                  ""000102030405060708090A0B0C0D0E0F"", true, ""6bc1bee22e409f96e93d7e117393172a"", \\
                  ""f58c4c04d6e5f1ba779eabfb5f7bfbd6485a5c81519cf378fa36d42b8547edc0"");
    TestAES256CBC(""603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"", \\
                  ""F58C4C04D6E5F1BA779EABFB5F7BFBD6"", true, ""ae2d8a571e03ac9c9eb76fac45af8e51"", \\
                  ""9cfc4e967edb808d679f777bc6702c7d3a3aa5e0213db1a9901f9036cf5102d2"");
    TestAES256CBC(""603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"", \\
                  ""9CFC4E967EDB808D679F777BC6702C7D"", true, ""30c81c46a35ce411e5fbc1191a0a52ef"",
                  ""39f23369a9d9bacfa530e263042314612f8da707643c90a6f732b3de1d3f5cee"");
    TestAES256CBC(""603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"", \\
                  ""39F23369A9D9BACFA530E26304231461"", true, ""f69f2445df4f9b17ad2b417be66c3710"", \\
                  ""b2eb05e2c39be9fcda6c19078c6a9d1b3f461796d6b0d6b2e0c2a72b4d80e644"");
}

BOOST_AUTO_TEST_SUITE_END()
",16182,True,3087.206155315729,median
"/*
Bullet Continuous Collision Detection and Physics Library
Copyright (c) 2003-2006 Erwin Coumans  http://continuousphysics.com/Bullet/

This software is provided 'as-is', without any express or implied warranty.
In no event will the authors be held liable for any damages arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it freely,
subject to the following restrictions:

1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/

#include ""btCollisionWorld.h""
#include ""btCollisionDispatcher.h""
#include ""BulletCollision/CollisionDispatch/btCollisionObject.h""
#include ""BulletCollision/CollisionShapes/btCollisionShape.h""
#include ""BulletCollision/CollisionShapes/btConvexShape.h""
#include ""BulletCollision/NarrowPhaseCollision/btGjkEpaPenetrationDepthSolver.h""
#include ""BulletCollision/CollisionShapes/btSphereShape.h""                 //for raycasting
#include ""BulletCollision/CollisionShapes/btBvhTriangleMeshShape.h""        //for raycasting
#include ""BulletCollision/CollisionShapes/btScaledBvhTriangleMeshShape.h""  //for raycasting
#include ""BulletCollision/CollisionShapes/btHeightfieldTerrainShape.h""     //for raycasting
#include ""BulletCollision/NarrowPhaseCollision/btRaycastCallback.h""
#include ""BulletCollision/CollisionShapes/btCompoundShape.h""
#include ""BulletCollision/NarrowPhaseCollision/btSubSimplexConvexCast.h""
#include ""BulletCollision/NarrowPhaseCollision/btGjkConvexCast.h""
#include ""BulletCollision/NarrowPhaseCollision/btContinuousConvexCollision.h""
#include ""BulletCollision/BroadphaseCollision/btCollisionAlgorithm.h""
#include ""BulletCollision/BroadphaseCollision/btBroadphaseInterface.h""
#include ""BulletCollision/BroadphaseCollision/btDbvt.h""
#include ""LinearMath/btAabbUtil2.h""
#include ""LinearMath/btQuickprof.h""
#include ""LinearMath/btSerializer.h""
#include ""BulletCollision/CollisionShapes/btConvexPolyhedron.h""
#include ""BulletCollision/CollisionDispatch/btCollisionObjectWrapper.h""

//#define DISABLE_DBVT_COMPOUNDSHAPE_RAYCAST_ACCELERATION

//#define USE_BRUTEFORCE_RAYBROADPHASE 1
//RECALCULATE_AABB is slower, but benefit is that you don't need to call 'stepSimulation'  or 'updateAabbs' before using a rayTest
//#define RECALCULATE_AABB_RAYCAST 1

//When the user doesn't provide dispatcher or broadphase, create basic versions (and delete them in destructor)
#include ""BulletCollision/CollisionDispatch/btCollisionDispatcher.h""
#include ""BulletCollision/BroadphaseCollision/btSimpleBroadphase.h""
#include ""BulletCollision/CollisionDispatch/btCollisionConfiguration.h""

///for debug drawing

//for debug rendering
#include ""BulletCollision/CollisionShapes/btBoxShape.h""
#include ""BulletCollision/CollisionShapes/btCapsuleShape.h""
#include ""BulletCollision/CollisionShapes/btCompoundShape.h""
#include ""BulletCollision/CollisionShapes/btConeShape.h""
#include ""BulletCollision/CollisionShapes/btConvexTriangleMeshShape.h""
#include ""BulletCollision/CollisionShapes/btCylinderShape.h""
#include ""BulletCollision/CollisionShapes/btMultiSphereShape.h""
#include ""BulletCollision/CollisionShapes/btPolyhedralConvexShape.h""
#include ""BulletCollision/CollisionShapes/btSphereShape.h""
#include ""BulletCollision/CollisionShapes/btTriangleCallback.h""
#include ""BulletCollision/CollisionShapes/btTriangleMeshShape.h""
#include ""BulletCollision/CollisionShapes/btStaticPlaneShape.h""

btCollisionWorld::btCollisionWorld(btDispatcher* dispatcher, btBroadphaseInterface* pairCache, btCollisionConfiguration* collisionConfiguration)
	: m_dispatcher1(dispatcher),
	  m_broadphasePairCache(pairCache),
	  m_debugDrawer(0),
	  m_forceUpdateAllAabbs(true)
{
}

btCollisionWorld::~btCollisionWorld()
{
	//clean up remaining objects
	int i;
	for (i = 0; i < m_collisionObjects.size(); i++)
	{
		btCollisionObject* collisionObject = m_collisionObjects[i];

		btBroadphaseProxy* bp = collisionObject->getBroadphaseHandle();
		if (bp)
		{
			//
			// only clear the cached algorithms
			//
			getBroadphase()->getOverlappingPairCache()->cleanProxyFromPairs(bp, m_dispatcher1);
			getBroadphase()->destroyProxy(bp, m_dispatcher1);
			collisionObject->setBroadphaseHandle(0);
		}
	}
}

void btCollisionWorld::refreshBroadphaseProxy(btCollisionObject* collisionObject)
{
	if (collisionObject->getBroadphaseHandle())
	{
		int collisionFilterGroup = collisionObject->getBroadphaseHandle()->m_collisionFilterGroup;
		int collisionFilterMask = collisionObject->getBroadphaseHandle()->m_collisionFilterMask;

		getBroadphase()->destroyProxy(collisionObject->getBroadphaseHandle(), getDispatcher());

		//calculate new AABB
		btTransform trans = collisionObject->getWorldTransform();

		btVector3 minAabb;
		btVector3 maxAabb;
		collisionObject->getCollisionShape()->getAabb(trans, minAabb, maxAabb);

		int type = collisionObject->getCollisionShape()->getShapeType();
		collisionObject->setBroadphaseHandle(getBroadphase()->createProxy(
			minAabb,
			maxAabb,
			type,
			collisionObject,
			collisionFilterGroup,
			collisionFilterMask,
			m_dispatcher1));
	}
}

void btCollisionWorld::addCollisionObject(btCollisionObject* collisionObject, int collisionFilterGroup, int collisionFilterMask)
{
	btAssert(collisionObject);

	//check that the object isn't already added
	btAssert(m_collisionObjects.findLinearSearch(collisionObject) == m_collisionObjects.size());
	btAssert(collisionObject->getWorldArrayIndex() == -1);  // do not add the same object to more than one collision world

	collisionObject->setWorldArrayIndex(m_collisionObjects.size());
	m_collisionObjects.push_back(collisionObject);

	//calculate new AABB
	btTransform trans = collisionObject->getWorldTransform();

	btVector3 minAabb;
	btVector3 maxAabb;
	collisionObject->getCollisionShape()->getAabb(trans, minAabb, maxAabb);

	int type = collisionObject->getCollisionShape()->getShapeType();
	collisionObject->setBroadphaseHandle(getBroadphase()->createProxy(
		minAabb,
		maxAabb,
		type,
		collisionObject,
		collisionFilterGroup,
		collisionFilterMask,
		m_dispatcher1));
}

void btCollisionWorld::updateSingleAabb(btCollisionObject* colObj)
{
	btVector3 minAabb, maxAabb;
	colObj->getCollisionShape()->getAabb(colObj->getWorldTransform(), minAabb, maxAabb);
	//need to increase the aabb for contact thresholds
	btVector3 contactThreshold(gContactBreakingThreshold, gContactBreakingThreshold, gContactBreakingThreshold);
	minAabb -= contactThreshold;
	maxAabb += contactThreshold;

	if (getDispatchInfo().m_useContinuous && colObj->getInternalType() == btCollisionObject::CO_RIGID_BODY && !colObj->isStaticOrKinematicObject())
	{
		btVector3 minAabb2, maxAabb2;
		colObj->getCollisionShape()->getAabb(colObj->getInterpolationWorldTransform(), minAabb2, maxAabb2);
		minAabb2 -= contactThreshold;
		maxAabb2 += contactThreshold;
		minAabb.setMin(minAabb2);
		maxAabb.setMax(maxAabb2);
	}

	btBroadphaseInterface* bp = (btBroadphaseInterface*)m_broadphasePairCache;

	//moving objects should be moderately sized, probably something wrong if not
	if (colObj->isStaticObject() || ((maxAabb - minAabb).length2() < btScalar(1e12)))
	{
		bp->setAabb(colObj->getBroadphaseHandle(), minAabb, maxAabb, m_dispatcher1);
	}
	else
	{
		//something went wrong, investigate
		//this assert is unwanted in 3D modelers (danger of loosing work)
		colObj->setActivationState(DISABLE_SIMULATION);

		static bool reportMe = true;
		if (reportMe && m_debugDrawer)
		{
			reportMe = false;
			m_debugDrawer->reportErrorWarning(""Overflow in AABB, object removed from simulation"");
			m_debugDrawer->reportErrorWarning(""If you can reproduce this, please email bugs@continuousphysics.com\\n"");
			m_debugDrawer->reportErrorWarning(""Please include above information, your Platform, version of OS.\\n"");
			m_debugDrawer->reportErrorWarning(""Thanks.\\n"");
		}
	}
}

void btCollisionWorld::updateAabbs()
{
	BT_PROFILE(""updateAabbs"");

	btTransform predictedTrans;
	for (int i = 0; i < m_collisionObjects.size(); i++)
	{
		btCollisionObject* colObj = m_collisionObjects[i];
		btAssert(colObj->getWorldArrayIndex() == i);

		//only update aabb of active objects
		if (m_forceUpdateAllAabbs || colObj->isActive())
		{
			updateSingleAabb(colObj);
		}
	}
}

void btCollisionWorld::computeOverlappingPairs()
{
	BT_PROFILE(""calculateOverlappingPairs"");
	m_broadphasePairCache->calculateOverlappingPairs(m_dispatcher1);
}

void btCollisionWorld::performDiscreteCollisionDetection()
{
	BT_PROFILE(""performDiscreteCollisionDetection"");

	btDispatcherInfo& dispatchInfo = getDispatchInfo();

	updateAabbs();

	computeOverlappingPairs();

	btDispatcher* dispatcher = getDispatcher();
	{
		BT_PROFILE(""dispatchAllCollisionPairs"");
		if (dispatcher)
			dispatcher->dispatchAllCollisionPairs(m_broadphasePairCache->getOverlappingPairCache(), dispatchInfo, m_dispatcher1);
	}
}

void btCollisionWorld::removeCollisionObject(btCollisionObject* collisionObject)
{
	//bool removeFromBroadphase = false;

	{
		btBroadphaseProxy* bp = collisionObject->getBroadphaseHandle();
		if (bp)
		{
			//
			// only clear the cached algorithms
			//
			getBroadphase()->getOverlappingPairCache()->cleanProxyFromPairs(bp, m_dispatcher1);
			getBroadphase()->destroyProxy(bp, m_dispatcher1);
			collisionObject->setBroadphaseHandle(0);
		}
	}

	int iObj = collisionObject->getWorldArrayIndex();
	//    btAssert(iObj >= 0 && iObj < m_collisionObjects.size()); // trying to remove an object that was never added or already removed previously?
	if (iObj >= 0 && iObj < m_collisionObjects.size())
	{
		btAssert(collisionObject == m_collisionObjects[iObj]);
		m_collisionObjects.swap(iObj, m_collisionObjects.size() - 1);
		m_collisionObjects.pop_back();
		if (iObj < m_collisionObjects.size())
		{
			m_collisionObjects[iObj]->setWorldArrayIndex(iObj);
		}
	}
	else
	{
		// slow linear search
		//swapremove
		m_collisionObjects.remove(collisionObject);
	}
	collisionObject->setWorldArrayIndex(-1);
}

void btCollisionWorld::rayTestSingle(const btTransform& rayFromTrans, const btTransform& rayToTrans,
									 btCollisionObject* collisionObject,
									 const btCollisionShape* collisionShape,
									 const btTransform& colObjWorldTransform,
									 RayResultCallback& resultCallback)
{
	btCollisionObjectWrapper colObWrap(0, collisionShape, collisionObject, colObjWorldTransform, -1, -1);
	btCollisionWorld::rayTestSingleInternal(rayFromTrans, rayToTrans, &colObWrap, resultCallback);
}

void btCollisionWorld::rayTestSingleInternal(const btTransform& rayFromTrans, const btTransform& rayToTrans,
											 const btCollisionObjectWrapper* collisionObjectWrap,
											 RayResultCallback& resultCallback)
{
	btSphereShape pointShape(btScalar(0.0));
	pointShape.setMargin(0.f);
	const btConvexShape* castShape = &pointShape;
	const btCollisionShape* collisionShape = collisionObjectWrap->getCollisionShape();
	const btTransform& colObjWorldTransform = collisionObjectWrap->getWorldTransform();

	if (collisionShape->isConvex())
	{
		//		BT_PROFILE(""rayTestConvex"");
		btConvexCast::CastResult castResult;
		castResult.m_fraction = resultCallback.m_closestHitFraction;

		btConvexShape* convexShape = (btConvexShape*)collisionShape;
		btVoronoiSimplexSolver simplexSolver;
		btSubsimplexConvexCast subSimplexConvexCaster(castShape, convexShape, &simplexSolver);

		btGjkConvexCast gjkConvexCaster(castShape, convexShape, &simplexSolver);

		//btContinuousConvexCollision convexCaster(castShape,convexShape,&simplexSolver,0);

		btConvexCast* convexCasterPtr = 0;
		//use kF_UseSubSimplexConvexCastRaytest by default
		if (resultCallback.m_flags & btTriangleRaycastCallback::kF_UseGjkConvexCastRaytest)
			convexCasterPtr = &gjkConvexCaster;
		else
			convexCasterPtr = &subSimplexConvexCaster;

		btConvexCast& convexCaster = *convexCasterPtr;

		if (convexCaster.calcTimeOfImpact(rayFromTrans, rayToTrans, colObjWorldTransform, colObjWorldTransform, castResult))
		{
			//add hit
			if (castResult.m_normal.length2() > btScalar(0.0001))
			{
				if (castResult.m_fraction < resultCallback.m_closestHitFraction)
				{
					//todo: figure out what this is about. When is rayFromTest.getBasis() not identity?
#ifdef USE_SUBSIMPLEX_CONVEX_CAST
					//rotate normal into worldspace
					castResult.m_normal = rayFromTrans.getBasis() * castResult.m_normal;
#endif  //USE_SUBSIMPLEX_CONVEX_CAST

					castResult.m_normal.normalize();
					btCollisionWorld::LocalRayResult localRayResult(
						collisionObjectWrap->getCollisionObject(),
						0,
						castResult.m_normal,
						castResult.m_fraction);

					bool normalInWorldSpace = true;
					resultCallback.addSingleResult(localRayResult, normalInWorldSpace);
				}
			}
		}
	}
	else
	{
		if (collisionShape->isConcave())
		{
			//ConvexCast::CastResult
			struct BridgeTriangleRaycastCallback : public btTriangleRaycastCallback
			{
				btCollisionWorld::RayResultCallback* m_resultCallback;
				const btCollisionObject* m_collisionObject;
				const btConcaveShape* m_triangleMesh;

				btTransform m_colObjWorldTransform;

				BridgeTriangleRaycastCallback(const btVector3& from, const btVector3& to,
											  btCollisionWorld::RayResultCallback* resultCallback, const btCollisionObject* collisionObject, const btConcaveShape* triangleMesh, const btTransform& colObjWorldTransform) :  //@BP Mod
																																																							btTriangleRaycastCallback(from, to, resultCallback->m_flags),
																																																							m_resultCallback(resultCallback),
																																																							m_collisionObject(collisionObject),
																																																							m_triangleMesh(triangleMesh),
																																																							m_colObjWorldTransform(colObjWorldTransform)
				{
				}

				virtual btScalar reportHit(const btVector3& hitNormalLocal, btScalar hitFraction, int partId, int triangleIndex)
				{
					btCollisionWorld::LocalShapeInfo shapeInfo;
					shapeInfo.m_shapePart = partId;
					shapeInfo.m_triangleIndex = triangleIndex;

					btVector3 hitNormalWorld = m_colObjWorldTransform.getBasis() * hitNormalLocal;

					btCollisionWorld::LocalRayResult rayResult(m_collisionObject,
															   &shapeInfo,
															   hitNormalWorld,
															   hitFraction);

					bool normalInWorldSpace = true;
					return m_resultCallback->addSingleResult(rayResult, normalInWorldSpace);
				}
			};

			btTransform worldTocollisionObject = colObjWorldTransform.inverse();
			btVector3 rayFromLocal = worldTocollisionObject * rayFromTrans.getOrigin();
			btVector3 rayToLocal = worldTocollisionObject * rayToTrans.getOrigin();

			//			BT_PROFILE(""rayTestConcave"");
			if (collisionShape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE)
			{
				///optimized version for btBvhTriangleMeshShape
				btBvhTriangleMeshShape* triangleMesh = (btBvhTriangleMeshShape*)collisionShape;

				BridgeTriangleRaycastCallback rcb(rayFromLocal, rayToLocal, &resultCallback, collisionObjectWrap->getCollisionObject(), triangleMesh, colObjWorldTransform);
				rcb.m_hitFraction = resultCallback.m_closestHitFraction;
				triangleMesh->performRaycast(&rcb, rayFromLocal, rayToLocal);
			}
			else if (collisionShape->getShapeType() == SCALED_TRIANGLE_MESH_SHAPE_PROXYTYPE)
			{
				///optimized version for btScaledBvhTriangleMeshShape
				btScaledBvhTriangleMeshShape* scaledTriangleMesh = (btScaledBvhTriangleMeshShape*)collisionShape;
				btBvhTriangleMeshShape* triangleMesh = (btBvhTriangleMeshShape*)scaledTriangleMesh->getChildShape();

				//scale the ray positions
				btVector3 scale = scaledTriangleMesh->getLocalScaling();
				btVector3 rayFromLocalScaled = rayFromLocal / scale;
				btVector3 rayToLocalScaled = rayToLocal / scale;

				//perform raycast in the underlying btBvhTriangleMeshShape
				BridgeTriangleRaycastCallback rcb(rayFromLocalScaled, rayToLocalScaled, &resultCallback, collisionObjectWrap->getCollisionObject(), triangleMesh, colObjWorldTransform);
				rcb.m_hitFraction = resultCallback.m_closestHitFraction;
				triangleMesh->performRaycast(&rcb, rayFromLocalScaled, rayToLocalScaled);
			}
			else if (((resultCallback.m_flags&btTriangleRaycastCallback::kF_DisableHeightfieldAccelerator)==0) 
				&& collisionShape->getShapeType() == TERRAIN_SHAPE_PROXYTYPE 
				)
			{
				///optimized version for btHeightfieldTerrainShape
				btHeightfieldTerrainShape* heightField = (btHeightfieldTerrainShape*)collisionShape;
				btTransform worldTocollisionObject = colObjWorldTransform.inverse();
				btVector3 rayFromLocal = worldTocollisionObject * rayFromTrans.getOrigin();
				btVector3 rayToLocal = worldTocollisionObject * rayToTrans.getOrigin();

				BridgeTriangleRaycastCallback rcb(rayFromLocal, rayToLocal, &resultCallback, collisionObjectWrap->getCollisionObject(), heightField, colObjWorldTransform);
				rcb.m_hitFraction = resultCallback.m_closestHitFraction;
				heightField->performRaycast(&rcb, rayFromLocal, rayToLocal);
			}
			else
			{
				//generic (slower) case
				btConcaveShape* concaveShape = (btConcaveShape*)collisionShape;

				btTransform worldTocollisionObject = colObjWorldTransform.inverse();

				btVector3 rayFromLocal = worldTocollisionObject * rayFromTrans.getOrigin();
				btVector3 rayToLocal = worldTocollisionObject * rayToTrans.getOrigin();

				//ConvexCast::CastResult

				struct BridgeTriangleRaycastCallback : public btTriangleRaycastCallback
				{
					btCollisionWorld::RayResultCallback* m_resultCallback;
					const btCollisionObject* m_collisionObject;
					btConcaveShape* m_triangleMesh;

					btTransform m_colObjWorldTransform;

					BridgeTriangleRaycastCallback(const btVector3& from, const btVector3& to,
												  btCollisionWorld::RayResultCallback* resultCallback, const btCollisionObject* collisionObject, btConcaveShape* triangleMesh, const btTransform& colObjWorldTransform) :  //@BP Mod
																																																						  btTriangleRaycastCallback(from, to, resultCallback->m_flags),
																																																						  m_resultCallback(resultCallback),
																																																						  m_collisionObject(collisionObject),
																																																						  m_triangleMesh(triangleMesh),
																																																						  m_colObjWorldTransform(colObjWorldTransform)
					{
					}

					virtual btScalar reportHit(const btVector3& hitNormalLocal, btScalar hitFraction, int partId, int triangleIndex)
					{
						btCollisionWorld::LocalShapeInfo shapeInfo;
						shapeInfo.m_shapePart = partId;
						shapeInfo.m_triangleIndex = triangleIndex;

						btVector3 hitNormalWorld = m_colObjWorldTransform.getBasis() * hitNormalLocal;

						btCollisionWorld::LocalRayResult rayResult(m_collisionObject,
																   &shapeInfo,
																   hitNormalWorld,
																   hitFraction);

						bool normalInWorldSpace = true;
						return m_resultCallback->addSingleResult(rayResult, normalInWorldSpace);
					}
				};

				BridgeTriangleRaycastCallback rcb(rayFromLocal, rayToLocal, &resultCallback, collisionObjectWrap->getCollisionObject(), concaveShape, colObjWorldTransform);
				rcb.m_hitFraction = resultCallback.m_closestHitFraction;

				btVector3 rayAabbMinLocal = rayFromLocal;
				rayAabbMinLocal.setMin(rayToLocal);
				btVector3 rayAabbMaxLocal = rayFromLocal;
				rayAabbMaxLocal.setMax(rayToLocal);

				concaveShape->processAllTriangles(&rcb, rayAabbMinLocal, rayAabbMaxLocal);
			}
		}
		else
		{
			//			BT_PROFILE(""rayTestCompound"");
			if (collisionShape->isCompound())
			{
				struct LocalInfoAdder2 : public RayResultCallback
				{
					RayResultCallback* m_userCallback;
					int m_i;

					LocalInfoAdder2(int i, RayResultCallback* user)
						: m_userCallback(user), m_i(i)
					{
						m_closestHitFraction = m_userCallback->m_closestHitFraction;
						m_flags = m_userCallback->m_flags;
					}
					virtual bool needsCollision(btBroadphaseProxy* p) const
					{
						return m_userCallback->needsCollision(p);
					}

					virtual btScalar addSingleResult(btCollisionWorld::LocalRayResult& r, bool b)
					{
						btCollisionWorld::LocalShapeInfo shapeInfo;
						shapeInfo.m_shapePart = -1;
						shapeInfo.m_triangleIndex = m_i;
						if (r.m_localShapeInfo == NULL)
							r.m_localShapeInfo = &shapeInfo;

						const btScalar result = m_userCallback->addSingleResult(r, b);
						m_closestHitFraction = m_userCallback->m_closestHitFraction;
						return result;
					}
				};

				struct RayTester : btDbvt::ICollide
				{
					const btCollisionObject* m_collisionObject;
					const btCompoundShape* m_compoundShape;
					const btTransform& m_colObjWorldTransform;
					const btTransform& m_rayFromTrans;
					const btTransform& m_rayToTrans;
					RayResultCallback& m_resultCallback;

					RayTester(const btCollisionObject* collisionObject,
							  const btCompoundShape* compoundShape,
							  const btTransform& colObjWorldTransform,
							  const btTransform& rayFromTrans,
							  const btTransform& rayToTrans,
							  RayResultCallback& resultCallback) : m_collisionObject(collisionObject),
																   m_compoundShape(compoundShape),
																   m_colObjWorldTransform(colObjWorldTransform),
																   m_rayFromTrans(rayFromTrans),
																   m_rayToTrans(rayToTrans),
																   m_resultCallback(resultCallback)
					{
					}

					void ProcessLeaf(int i)
					{
						const btCollisionShape* childCollisionShape = m_compoundShape->getChildShape(i);
						const btTransform& childTrans = m_compoundShape->getChildTransform(i);
						btTransform childWorldTrans = m_colObjWorldTransform * childTrans;

						btCollisionObjectWrapper tmpOb(0, childCollisionShape, m_collisionObject, childWorldTrans, -1, i);
						// replace collision shape so that callback can determine the triangle

						LocalInfoAdder2 my_cb(i, &m_resultCallback);

						rayTestSingleInternal(
							m_rayFromTrans,
							m_rayToTrans,
							&tmpOb,
							my_cb);
					}

					void Process(const btDbvtNode* leaf)
					{
						ProcessLeaf(leaf->dataAsInt);
					}
				};

				const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(collisionShape);
				const btDbvt* dbvt = compoundShape->getDynamicAabbTree();

				RayTester rayCB(
					collisionObjectWrap->getCollisionObject(),
					compoundShape,
					colObjWorldTransform,
					rayFromTrans,
					rayToTrans,
					resultCallback);
#ifndef DISABLE_DBVT_COMPOUNDSHAPE_RAYCAST_ACCELERATION
				if (dbvt)
				{
					btVector3 localRayFrom = colObjWorldTransform.inverseTimes(rayFromTrans).getOrigin();
					btVector3 localRayTo = colObjWorldTransform.inverseTimes(rayToTrans).getOrigin();
					btDbvt::rayTest(dbvt->m_root, localRayFrom, localRayTo, rayCB);
				}
				else
#endif  //DISABLE_DBVT_COMPOUNDSHAPE_RAYCAST_ACCELERATION
				{
					for (int i = 0, n = compoundShape->getNumChildShapes(); i < n; ++i)
					{
						rayCB.ProcessLeaf(i);
					}
				}
			}
		}
	}
}

void btCollisionWorld::objectQuerySingle(const btConvexShape* castShape, const btTransform& convexFromTrans, const btTransform& convexToTrans,
										 btCollisionObject* collisionObject,
										 const btCollisionShape* collisionShape,
										 const btTransform& colObjWorldTransform,
										 ConvexResultCallback& resultCallback, btScalar allowedPenetration)
{
	btCollisionObjectWrapper tmpOb(0, collisionShape, collisionObject, colObjWorldTransform, -1, -1);
	btCollisionWorld::objectQuerySingleInternal(castShape, convexFromTrans, convexToTrans, &tmpOb, resultCallback, allowedPenetration);
}

void btCollisionWorld::objectQuerySingleInternal(const btConvexShape* castShape, const btTransform& convexFromTrans, const btTransform& convexToTrans,
												 const btCollisionObjectWrapper* colObjWrap,
												 ConvexResultCallback& resultCallback, btScalar allowedPenetration)
{
	const btCollisionShape* collisionShape = colObjWrap->getCollisionShape();
	const btTransform& colObjWorldTransform = colObjWrap->getWorldTransform();

	if (collisionShape->isConvex())
	{
		//BT_PROFILE(""convexSweepConvex"");
		btConvexCast::CastResult castResult;
		castResult.m_allowedPenetration = allowedPenetration;
		castResult.m_fraction = resultCallback.m_closestHitFraction;  //btScalar(1.);//??

		btConvexShape* convexShape = (btConvexShape*)collisionShape;
		btVoronoiSimplexSolver simplexSolver;
		btGjkEpaPenetrationDepthSolver gjkEpaPenetrationSolver;

		btContinuousConvexCollision convexCaster1(castShape, convexShape, &simplexSolver, &gjkEpaPenetrationSolver);
		//btGjkConvexCast convexCaster2(castShape,convexShape,&simplexSolver);
		//btSubsimplexConvexCast convexCaster3(castShape,convexShape,&simplexSolver);

		btConvexCast* castPtr = &convexCaster1;

		if (castPtr->calcTimeOfImpact(convexFromTrans, convexToTrans, colObjWorldTransform, colObjWorldTransform, castResult))
		{
			//add hit
			if (castResult.m_normal.length2() > btScalar(0.0001))
			{
				if (castResult.m_fraction < resultCallback.m_closestHitFraction)
				{
					castResult.m_normal.normalize();
					btCollisionWorld::LocalConvexResult localConvexResult(
						colObjWrap->getCollisionObject(),
						0,
						castResult.m_normal,
						castResult.m_hitPoint,
						castResult.m_fraction);

					localConvexResult.m_penetrationDepth = castResult.m_penetrationDepth;

					bool normalInWorldSpace = true;
					resultCallback.addSingleResult(localConvexResult, normalInWorldSpace);
				}
			}
		}
	}
	else
	{
		if (collisionShape->isConcave())
		{
			if (collisionShape->getShapeType() == TRIANGLE_MESH_SHAPE_PROXYTYPE)
			{
				//BT_PROFILE(""convexSweepbtBvhTriangleMesh"");
				btBvhTriangleMeshShape* triangleMesh = (btBvhTriangleMeshShape*)collisionShape;
				btTransform worldTocollisionObject = colObjWorldTransform.inverse();
				btVector3 convexFromLocal = worldTocollisionObject * convexFromTrans.getOrigin();
				btVector3 convexToLocal = worldTocollisionObject * convexToTrans.getOrigin();
				// rotation of box in local mesh space = MeshRotation^-1 * ConvexToRotation
				btTransform rotationXform = btTransform(worldTocollisionObject.getBasis() * convexToTrans.getBasis());

				//ConvexCast::CastResult
				struct BridgeTriangleConvexcastCallback : public btTriangleConvexcastCallback
				{
					btCollisionWorld::ConvexResultCallback* m_resultCallback;
					const btCollisionObject* m_collisionObject;
					btTriangleMeshShape* m_triangleMesh;

					BridgeTriangleConvexcastCallback(const btConvexShape* castShape, const btTransform& from, const btTransform& to,
													 btCollisionWorld::ConvexResultCallback* resultCallback, const btCollisionObject* collisionObject, btTriangleMeshShape* triangleMesh, const btTransform& triangleToWorld) : btTriangleConvexcastCallback(castShape, from, to, triangleToWorld, triangleMesh->getMargin()),
																																																								m_resultCallback(resultCallback),
																																																								m_collisionObject(collisionObject),
																																																								m_triangleMesh(triangleMesh)
					{
					}

					virtual btScalar reportHit(const btVector3& hitNormalLocal, const btVector3& hitPointLocal, btScalar hitFraction, int partId, int triangleIndex)
					{
						btCollisionWorld::LocalShapeInfo shapeInfo;
						shapeInfo.m_shapePart = partId;
						shapeInfo.m_triangleIndex = triangleIndex;
						if (hitFraction <= m_resultCallback->m_closestHitFraction)
						{
							btCollisionWorld::LocalConvexResult convexResult(m_collisionObject,
																			 &shapeInfo,
																			 hitNormalLocal,
																			 hitPointLocal,
																			 hitFraction);

							bool normalInWorldSpace = true;

							return m_resultCallback->addSingleResult(convexResult, normalInWorldSpace);
						}
						return hitFraction;
					}
				};

				BridgeTriangleConvexcastCallback tccb(castShape, convexFromTrans, convexToTrans, &resultCallback, colObjWrap->getCollisionObject(), triangleMesh, colObjWorldTransform);
				tccb.m_hitFraction = resultCallback.m_closestHitFraction;
				tccb.m_allowedPenetration = allowedPenetration;
				btVector3 boxMinLocal, boxMaxLocal;
				castShape->getAabb(rotationXform, boxMinLocal, boxMaxLocal);
				triangleMesh->performConvexcast(&tccb, convexFromLocal, convexToLocal, boxMinLocal, boxMaxLocal);
			}
			else
			{
				if (collisionShape->getShapeType() == STATIC_PLANE_PROXYTYPE)
				{
					btConvexCast::CastResult castResult;
					castResult.m_allowedPenetration = allowedPenetration;
					castResult.m_fraction = resultCallback.m_closestHitFraction;
					btStaticPlaneShape* planeShape = (btStaticPlaneShape*)collisionShape;
					btContinuousConvexCollision convexCaster1(castShape, planeShape);
					btConvexCast* castPtr = &convexCaster1;

					if (castPtr->calcTimeOfImpact(convexFromTrans, convexToTrans, colObjWorldTransform, colObjWorldTransform, castResult))
					{
						//add hit
						if (castResult.m_normal.length2() > btScalar(0.0001))
						{
							if (castResult.m_fraction < resultCallback.m_closestHitFraction)
							{
								castResult.m_normal.normalize();
								btCollisionWorld::LocalConvexResult localConvexResult(
									colObjWrap->getCollisionObject(),
									0,
									castResult.m_normal,
									castResult.m_hitPoint,
									castResult.m_fraction);

								bool normalInWorldSpace = true;
								resultCallback.addSingleResult(localConvexResult, normalInWorldSpace);
							}
						}
					}
				}
				else
				{
					//BT_PROFILE(""convexSweepConcave"");
					btConcaveShape* concaveShape = (btConcaveShape*)collisionShape;
					btTransform worldTocollisionObject = colObjWorldTransform.inverse();
					btVector3 convexFromLocal = worldTocollisionObject * convexFromTrans.getOrigin();
					btVector3 convexToLocal = worldTocollisionObject * convexToTrans.getOrigin();
					// rotation of box in local mesh space = MeshRotation^-1 * ConvexToRotation
					btTransform rotationXform = btTransform(worldTocollisionObject.getBasis() * convexToTrans.getBasis());

					//ConvexCast::CastResult
					struct BridgeTriangleConvexcastCallback : public btTriangleConvexcastCallback
					{
						btCollisionWorld::ConvexResultCallback* m_resultCallback;
						const btCollisionObject* m_collisionObject;
						btConcaveShape* m_triangleMesh;

						BridgeTriangleConvexcastCallback(const btConvexShape* castShape, const btTransform& from, const btTransform& to,
														 btCollisionWorld::ConvexResultCallback* resultCallback, const btCollisionObject* collisionObject, btConcaveShape* triangleMesh, const btTransform& triangleToWorld) : btTriangleConvexcastCallback(castShape, from, to, triangleToWorld, triangleMesh->getMargin()),
																																																							   m_resultCallback(resultCallback),
																																																							   m_collisionObject(collisionObject),
																																																							   m_triangleMesh(triangleMesh)
						{
						}

						virtual btScalar reportHit(const btVector3& hitNormalLocal, const btVector3& hitPointLocal, btScalar hitFraction, int partId, int triangleIndex)
						{
							btCollisionWorld::LocalShapeInfo shapeInfo;
							shapeInfo.m_shapePart = partId;
							shapeInfo.m_triangleIndex = triangleIndex;
							if (hitFraction <= m_resultCallback->m_closestHitFraction)
							{
								btCollisionWorld::LocalConvexResult convexResult(m_collisionObject,
																				 &shapeInfo,
																				 hitNormalLocal,
																				 hitPointLocal,
																				 hitFraction);

								bool normalInWorldSpace = true;

								return m_resultCallback->addSingleResult(convexResult, normalInWorldSpace);
							}
							return hitFraction;
						}
					};

					BridgeTriangleConvexcastCallback tccb(castShape, convexFromTrans, convexToTrans, &resultCallback, colObjWrap->getCollisionObject(), concaveShape, colObjWorldTransform);
					tccb.m_hitFraction = resultCallback.m_closestHitFraction;
					tccb.m_allowedPenetration = allowedPenetration;
					btVector3 boxMinLocal, boxMaxLocal;
					castShape->getAabb(rotationXform, boxMinLocal, boxMaxLocal);

					btVector3 rayAabbMinLocal = convexFromLocal;
					rayAabbMinLocal.setMin(convexToLocal);
					btVector3 rayAabbMaxLocal = convexFromLocal;
					rayAabbMaxLocal.setMax(convexToLocal);
					rayAabbMinLocal += boxMinLocal;
					rayAabbMaxLocal += boxMaxLocal;
					concaveShape->processAllTriangles(&tccb, rayAabbMinLocal, rayAabbMaxLocal);
				}
			}
		}
		else
		{
			if (collisionShape->isCompound())
			{
				struct btCompoundLeafCallback : btDbvt::ICollide
				{
					btCompoundLeafCallback(
						const btCollisionObjectWrapper* colObjWrap,
						const btConvexShape* castShape,
						const btTransform& convexFromTrans,
						const btTransform& convexToTrans,
						btScalar allowedPenetration,
						const btCompoundShape* compoundShape,
						const btTransform& colObjWorldTransform,
						ConvexResultCallback& resultCallback)
						: m_colObjWrap(colObjWrap),
						  m_castShape(castShape),
						  m_convexFromTrans(convexFromTrans),
						  m_convexToTrans(convexToTrans),
						  m_allowedPenetration(allowedPenetration),
						  m_compoundShape(compoundShape),
						  m_colObjWorldTransform(colObjWorldTransform),
						  m_resultCallback(resultCallback)
					{
					}

					const btCollisionObjectWrapper* m_colObjWrap;
					const btConvexShape* m_castShape;
					const btTransform& m_convexFromTrans;
					const btTransform& m_convexToTrans;
					btScalar m_allowedPenetration;
					const btCompoundShape* m_compoundShape;
					const btTransform& m_colObjWorldTransform;
					ConvexResultCallback& m_resultCallback;

				public:
					void ProcessChild(int index, const btTransform& childTrans, const btCollisionShape* childCollisionShape)
					{
						btTransform childWorldTrans = m_colObjWorldTransform * childTrans;

						struct LocalInfoAdder : public ConvexResultCallback
						{
							ConvexResultCallback* m_userCallback;
							int m_i;

							LocalInfoAdder(int i, ConvexResultCallback* user)
								: m_userCallback(user), m_i(i)
							{
								m_closestHitFraction = m_userCallback->m_closestHitFraction;
							}
							virtual bool needsCollision(btBroadphaseProxy* p) const
							{
								return m_userCallback->needsCollision(p);
							}
							virtual btScalar addSingleResult(btCollisionWorld::LocalConvexResult& r, bool b)
							{
								btCollisionWorld::LocalShapeInfo shapeInfo;
								shapeInfo.m_shapePart = -1;
								shapeInfo.m_triangleIndex = m_i;
								if (r.m_localShapeInfo == NULL)
									r.m_localShapeInfo = &shapeInfo;
								const btScalar result = m_userCallback->addSingleResult(r, b);
								m_closestHitFraction = m_userCallback->m_closestHitFraction;
								return result;
							}
						};

						LocalInfoAdder my_cb(index, &m_resultCallback);

						btCollisionObjectWrapper tmpObj(m_colObjWrap, childCollisionShape, m_colObjWrap->getCollisionObject(), childWorldTrans, -1, index);

						objectQuerySingleInternal(m_castShape, m_convexFromTrans, m_convexToTrans, &tmpObj, my_cb, m_allowedPenetration);
					}

					void Process(const btDbvtNode* leaf)
					{
						// Processing leaf node
						int index = leaf->dataAsInt;

						btTransform childTrans = m_compoundShape->getChildTransform(index);
						const btCollisionShape* childCollisionShape = m_compoundShape->getChildShape(index);

						ProcessChild(index, childTrans, childCollisionShape);
					}
				};

				BT_PROFILE(""convexSweepCompound"");
				const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(collisionShape);

				btVector3 fromLocalAabbMin, fromLocalAabbMax;
				btVector3 toLocalAabbMin, toLocalAabbMax;

				castShape->getAabb(colObjWorldTransform.inverse() * convexFromTrans, fromLocalAabbMin, fromLocalAabbMax);
				castShape->getAabb(colObjWorldTransform.inverse() * convexToTrans, toLocalAabbMin, toLocalAabbMax);

				fromLocalAabbMin.setMin(toLocalAabbMin);
				fromLocalAabbMax.setMax(toLocalAabbMax);

				btCompoundLeafCallback callback(colObjWrap, castShape, convexFromTrans, convexToTrans,
												allowedPenetration, compoundShape, colObjWorldTransform, resultCallback);

				const btDbvt* tree = compoundShape->getDynamicAabbTree();
				if (tree)
				{
					const ATTRIBUTE_ALIGNED16(btDbvtVolume) bounds = btDbvtVolume::FromMM(fromLocalAabbMin, fromLocalAabbMax);
					tree->collideTV(tree->m_root, bounds, callback);
				}
				else
				{
					int i;
					for (i = 0; i < compoundShape->getNumChildShapes(); i++)
					{
						const btCollisionShape* childCollisionShape = compoundShape->getChildShape(i);
						btTransform childTrans = compoundShape->getChildTransform(i);
						callback.ProcessChild(i, childTrans, childCollisionShape);
					}
				}
			}
		}
	}
}

struct btSingleRayCallback : public btBroadphaseRayCallback
{
	btVector3 m_rayFromWorld;
	btVector3 m_rayToWorld;
	btTransform m_rayFromTrans;
	btTransform m_rayToTrans;
	btVector3 m_hitNormal;

	const btCollisionWorld* m_world;
	btCollisionWorld::RayResultCallback& m_resultCallback;

	btSingleRayCallback(const btVector3& rayFromWorld, const btVector3& rayToWorld, const btCollisionWorld* world, btCollisionWorld::RayResultCallback& resultCallback)
		: m_rayFromWorld(rayFromWorld),
		  m_rayToWorld(rayToWorld),
		  m_world(world),
		  m_resultCallback(resultCallback)
	{
		m_rayFromTrans.setIdentity();
		m_rayFromTrans.setOrigin(m_rayFromWorld);
		m_rayToTrans.setIdentity();
		m_rayToTrans.setOrigin(m_rayToWorld);

		btVector3 rayDir = (rayToWorld - rayFromWorld);

		rayDir.normalize();
		///what about division by zero? --> just set rayDirection[i] to INF/BT_LARGE_FLOAT
		m_rayDirectionInverse[0] = rayDir[0] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[0];
		m_rayDirectionInverse[1] = rayDir[1] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[1];
		m_rayDirectionInverse[2] = rayDir[2] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[2];
		m_signs[0] = m_rayDirectionInverse[0] < 0.0;
		m_signs[1] = m_rayDirectionInverse[1] < 0.0;
		m_signs[2] = m_rayDirectionInverse[2] < 0.0;

		m_lambda_max = rayDir.dot(m_rayToWorld - m_rayFromWorld);
	}

	virtual bool process(const btBroadphaseProxy* proxy)
	{
		///terminate further ray tests, once the closestHitFraction reached zero
		if (m_resultCallback.m_closestHitFraction == btScalar(0.f))
			return false;

		btCollisionObject* collisionObject = (btCollisionObject*)proxy->m_clientObject;

		//only perform raycast if filterMask matches
		if (m_resultCallback.needsCollision(collisionObject->getBroadphaseHandle()))
		{
			//RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
			//btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
#if 0
#ifdef RECALCULATE_AABB
			btVector3 collisionObjectAabbMin,collisionObjectAabbMax;
			collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(),collisionObjectAabbMin,collisionObjectAabbMax);
#else
			//getBroadphase()->getAabb(collisionObject->getBroadphaseHandle(),collisionObjectAabbMin,collisionObjectAabbMax);
			const btVector3& collisionObjectAabbMin = collisionObject->getBroadphaseHandle()->m_aabbMin;
			const btVector3& collisionObjectAabbMax = collisionObject->getBroadphaseHandle()->m_aabbMax;
#endif
#endif
			//btScalar hitLambda = m_resultCallback.m_closestHitFraction;
			//culling already done by broadphase
			//if (btRayAabb(m_rayFromWorld,m_rayToWorld,collisionObjectAabbMin,collisionObjectAabbMax,hitLambda,m_hitNormal))
			{
				m_world->rayTestSingle(m_rayFromTrans, m_rayToTrans,
									   collisionObject,
									   collisionObject->getCollisionShape(),
									   collisionObject->getWorldTransform(),
									   m_resultCallback);
			}
		}
		return true;
	}
};

void btCollisionWorld::rayTest(const btVector3& rayFromWorld, const btVector3& rayToWorld, RayResultCallback& resultCallback) const
{
	//BT_PROFILE(""rayTest"");
	/// use the broadphase to accelerate the search for objects, based on their aabb
	/// and for each object with ray-aabb overlap, perform an exact ray test
	btSingleRayCallback rayCB(rayFromWorld, rayToWorld, this, resultCallback);

#ifndef USE_BRUTEFORCE_RAYBROADPHASE
	m_broadphasePairCache->rayTest(rayFromWorld, rayToWorld, rayCB);
#else
	for (int i = 0; i < this->getNumCollisionObjects(); i++)
	{
		rayCB.process(m_collisionObjects[i]->getBroadphaseHandle());
	}
#endif  //USE_BRUTEFORCE_RAYBROADPHASE
}

struct btSingleSweepCallback : public btBroadphaseRayCallback
{
	btTransform m_convexFromTrans;
	btTransform m_convexToTrans;
	btVector3 m_hitNormal;
	const btCollisionWorld* m_world;
	btCollisionWorld::ConvexResultCallback& m_resultCallback;
	btScalar m_allowedCcdPenetration;
	const btConvexShape* m_castShape;

	btSingleSweepCallback(const btConvexShape* castShape, const btTransform& convexFromTrans, const btTransform& convexToTrans, const btCollisionWorld* world, btCollisionWorld::ConvexResultCallback& resultCallback, btScalar allowedPenetration)
		: m_convexFromTrans(convexFromTrans),
		  m_convexToTrans(convexToTrans),
		  m_world(world),
		  m_resultCallback(resultCallback),
		  m_allowedCcdPenetration(allowedPenetration),
		  m_castShape(castShape)
	{
		btVector3 unnormalizedRayDir = (m_convexToTrans.getOrigin() - m_convexFromTrans.getOrigin());
		btVector3 rayDir = unnormalizedRayDir.normalized();
		///what about division by zero? --> just set rayDirection[i] to INF/BT_LARGE_FLOAT
		m_rayDirectionInverse[0] = rayDir[0] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[0];
		m_rayDirectionInverse[1] = rayDir[1] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[1];
		m_rayDirectionInverse[2] = rayDir[2] == btScalar(0.0) ? btScalar(BT_LARGE_FLOAT) : btScalar(1.0) / rayDir[2];
		m_signs[0] = m_rayDirectionInverse[0] < 0.0;
		m_signs[1] = m_rayDirectionInverse[1] < 0.0;
		m_signs[2] = m_rayDirectionInverse[2] < 0.0;

		m_lambda_max = rayDir.dot(unnormalizedRayDir);
	}

	virtual bool process(const btBroadphaseProxy* proxy)
	{
		///terminate further convex sweep tests, once the closestHitFraction reached zero
		if (m_resultCallback.m_closestHitFraction == btScalar(0.f))
			return false;

		btCollisionObject* collisionObject = (btCollisionObject*)proxy->m_clientObject;

		//only perform raycast if filterMask matches
		if (m_resultCallback.needsCollision(collisionObject->getBroadphaseHandle()))
		{
			//RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
			m_world->objectQuerySingle(m_castShape, m_convexFromTrans, m_convexToTrans,
									   collisionObject,
									   collisionObject->getCollisionShape(),
									   collisionObject->getWorldTransform(),
									   m_resultCallback,
									   m_allowedCcdPenetration);
		}

		return true;
	}
};

void btCollisionWorld::convexSweepTest(const btConvexShape* castShape, const btTransform& convexFromWorld, const btTransform& convexToWorld, ConvexResultCallback& resultCallback, btScalar allowedCcdPenetration) const
{
	BT_PROFILE(""convexSweepTest"");
	/// use the broadphase to accelerate the search for objects, based on their aabb
	/// and for each object with ray-aabb overlap, perform an exact ray test
	/// unfortunately the implementation for rayTest and convexSweepTest duplicated, albeit practically identical

	btTransform convexFromTrans, convexToTrans;
	convexFromTrans = convexFromWorld;
	convexToTrans = convexToWorld;
	btVector3 castShapeAabbMin, castShapeAabbMax;
	/* Compute AABB that encompasses angular movement */
	{
		btVector3 linVel, angVel;
		btTransformUtil::calculateVelocity(convexFromTrans, convexToTrans, 1.0f, linVel, angVel);
		btVector3 zeroLinVel;
		zeroLinVel.setValue(0, 0, 0);
		btTransform R;
		R.setIdentity();
		R.setRotation(convexFromTrans.getRotation());
		castShape->calculateTemporalAabb(R, zeroLinVel, angVel, 1.0f, castShapeAabbMin, castShapeAabbMax);
	}

#ifndef USE_BRUTEFORCE_RAYBROADPHASE

	btSingleSweepCallback convexCB(castShape, convexFromWorld, convexToWorld, this, resultCallback, allowedCcdPenetration);

	m_broadphasePairCache->rayTest(convexFromTrans.getOrigin(), convexToTrans.getOrigin(), convexCB, castShapeAabbMin, castShapeAabbMax);

#else
	/// go over all objects, and if the ray intersects their aabb + cast shape aabb,
	// do a ray-shape query using convexCaster (CCD)
	int i;
	for (i = 0; i < m_collisionObjects.size(); i++)
	{
		btCollisionObject* collisionObject = m_collisionObjects[i];
		//only perform raycast if filterMask matches
		if (resultCallback.needsCollision(collisionObject->getBroadphaseHandle()))
		{
			//RigidcollisionObject* collisionObject = ctrl->GetRigidcollisionObject();
			btVector3 collisionObjectAabbMin, collisionObjectAabbMax;
			collisionObject->getCollisionShape()->getAabb(collisionObject->getWorldTransform(), collisionObjectAabbMin, collisionObjectAabbMax);
			AabbExpand(collisionObjectAabbMin, collisionObjectAabbMax, castShapeAabbMin, castShapeAabbMax);
			btScalar hitLambda = btScalar(1.);  //could use resultCallback.m_closestHitFraction, but needs testing
			btVector3 hitNormal;
			if (btRayAabb(convexFromWorld.getOrigin(), convexToWorld.getOrigin(), collisionObjectAabbMin, collisionObjectAabbMax, hitLambda, hitNormal))
			{
				objectQuerySingle(castShape, convexFromTrans, convexToTrans,
								  collisionObject,
								  collisionObject->getCollisionShape(),
								  collisionObject->getWorldTransform(),
								  resultCallback,
								  allowedCcdPenetration);
			}
		}
	}
#endif  //USE_BRUTEFORCE_RAYBROADPHASE
}

struct btBridgedManifoldResult : public btManifoldResult
{
	btCollisionWorld::ContactResultCallback& m_resultCallback;

	btBridgedManifoldResult(const btCollisionObjectWrapper* obj0Wrap, const btCollisionObjectWrapper* obj1Wrap, btCollisionWorld::ContactResultCallback& resultCallback)
		: btManifoldResult(obj0Wrap, obj1Wrap),
		  m_resultCallback(resultCallback)
	{
	}

	virtual void addContactPoint(const btVector3& normalOnBInWorld, const btVector3& pointInWorld, btScalar depth)
	{
		bool isSwapped = m_manifoldPtr->getBody0() != m_body0Wrap->getCollisionObject();
		btVector3 pointA = pointInWorld + normalOnBInWorld * depth;
		btVector3 localA;
		btVector3 localB;
		if (isSwapped)
		{
			localA = m_body1Wrap->getCollisionObject()->getWorldTransform().invXform(pointA);
			localB = m_body0Wrap->getCollisionObject()->getWorldTransform().invXform(pointInWorld);
		}
		else
		{
			localA = m_body0Wrap->getCollisionObject()->getWorldTransform().invXform(pointA);
			localB = m_body1Wrap->getCollisionObject()->getWorldTransform().invXform(pointInWorld);
		}

		btManifoldPoint newPt(localA, localB, normalOnBInWorld, depth);
		newPt.m_positionWorldOnA = pointA;
		newPt.m_positionWorldOnB = pointInWorld;

		//BP mod, store contact triangles.
		if (isSwapped)
		{
			newPt.m_partId0 = m_partId1;
			newPt.m_partId1 = m_partId0;
			newPt.m_index0 = m_index1;
			newPt.m_index1 = m_index0;
		}
		else
		{
			newPt.m_partId0 = m_partId0;
			newPt.m_partId1 = m_partId1;
			newPt.m_index0 = m_index0;
			newPt.m_index1 = m_index1;
		}

		//experimental feature info, for per-triangle material etc.
		const btCollisionObjectWrapper* obj0Wrap = isSwapped ? m_body1Wrap : m_body0Wrap;
		const btCollisionObjectWrapper* obj1Wrap = isSwapped ? m_body0Wrap : m_body1Wrap;
		m_resultCallback.addSingleResult(newPt, obj0Wrap, newPt.m_partId0, newPt.m_index0, obj1Wrap, newPt.m_partId1, newPt.m_index1);
	}
};

struct btSingleContactCallback : public btBroadphaseAabbCallback
{
	btCollisionObject* m_collisionObject;
	btCollisionWorld* m_world;
	btCollisionWorld::ContactResultCallback& m_resultCallback;

	btSingleContactCallback(btCollisionObject* collisionObject, btCollisionWorld* world, btCollisionWorld::ContactResultCallback& resultCallback)
		: m_collisionObject(collisionObject),
		  m_world(world),
		  m_resultCallback(resultCallback)
	{
	}

	virtual bool process(const btBroadphaseProxy* proxy)
	{
		btCollisionObject* collisionObject = (btCollisionObject*)proxy->m_clientObject;
		if (collisionObject == m_collisionObject)
			return true;

		//only perform raycast if filterMask matches
		if (m_resultCallback.needsCollision(collisionObject->getBroadphaseHandle()))
		{
			btCollisionObjectWrapper ob0(0, m_collisionObject->getCollisionShape(), m_collisionObject, m_collisionObject->getWorldTransform(), -1, -1);
			btCollisionObjectWrapper ob1(0, collisionObject->getCollisionShape(), collisionObject, collisionObject->getWorldTransform(), -1, -1);

			btCollisionAlgorithm* algorithm = m_world->getDispatcher()->findAlgorithm(&ob0, &ob1, 0, BT_CLOSEST_POINT_ALGORITHMS);
			if (algorithm)
			{
				btBridgedManifoldResult contactPointResult(&ob0, &ob1, m_resultCallback);
				//discrete collision detection query

				algorithm->processCollision(&ob0, &ob1, m_world->getDispatchInfo(), &contactPointResult);

				algorithm->~btCollisionAlgorithm();
				m_world->getDispatcher()->freeCollisionAlgorithm(algorithm);
			}
		}
		return true;
	}
};

///contactTest performs a discrete collision test against all objects in the btCollisionWorld, and calls the resultCallback.
///it reports one or more contact points for every overlapping object (including the one with deepest penetration)
void btCollisionWorld::contactTest(btCollisionObject* colObj, ContactResultCallback& resultCallback)
{
	btVector3 aabbMin, aabbMax;
	colObj->getCollisionShape()->getAabb(colObj->getWorldTransform(), aabbMin, aabbMax);
	btSingleContactCallback contactCB(colObj, this, resultCallback);

	m_broadphasePairCache->aabbTest(aabbMin, aabbMax, contactCB);
}

///contactTest performs a discrete collision test between two collision objects and calls the resultCallback if overlap if detected.
///it reports one or more contact points (including the one with deepest penetration)
void btCollisionWorld::contactPairTest(btCollisionObject* colObjA, btCollisionObject* colObjB, ContactResultCallback& resultCallback)
{
	btCollisionObjectWrapper obA(0, colObjA->getCollisionShape(), colObjA, colObjA->getWorldTransform(), -1, -1);
	btCollisionObjectWrapper obB(0, colObjB->getCollisionShape(), colObjB, colObjB->getWorldTransform(), -1, -1);

	btCollisionAlgorithm* algorithm = getDispatcher()->findAlgorithm(&obA, &obB, 0, BT_CLOSEST_POINT_ALGORITHMS);
	if (algorithm)
	{
		btBridgedManifoldResult contactPointResult(&obA, &obB, resultCallback);
		contactPointResult.m_closestPointDistanceThreshold = resultCallback.m_closestDistanceThreshold;
		//discrete collision detection query
		algorithm->processCollision(&obA, &obB, getDispatchInfo(), &contactPointResult);

		algorithm->~btCollisionAlgorithm();
		getDispatcher()->freeCollisionAlgorithm(algorithm);
	}
}

class DebugDrawcallback : public btTriangleCallback, public btInternalTriangleIndexCallback
{
	btIDebugDraw* m_debugDrawer;
	btVector3 m_color;
	btTransform m_worldTrans;

public:
	DebugDrawcallback(btIDebugDraw* debugDrawer, const btTransform& worldTrans, const btVector3& color) : m_debugDrawer(debugDrawer),
																										  m_color(color),
																										  m_worldTrans(worldTrans)
	{
	}

	virtual void internalProcessTriangleIndex(btVector3* triangle, int partId, int triangleIndex)
	{
		processTriangle(triangle, partId, triangleIndex);
	}

	virtual void processTriangle(btVector3* triangle, int partId, int triangleIndex)
	{
		(void)partId;
		(void)triangleIndex;

		btVector3 wv0, wv1, wv2;
		wv0 = m_worldTrans * triangle[0];
		wv1 = m_worldTrans * triangle[1];
		wv2 = m_worldTrans * triangle[2];
		btVector3 center = (wv0 + wv1 + wv2) * btScalar(1. / 3.);

		if (m_debugDrawer->getDebugMode() & btIDebugDraw::DBG_DrawNormals)
		{
			btVector3 normal = (wv1 - wv0).cross(wv2 - wv0);
			normal.normalize();
			btVector3 normalColor(1, 1, 0);
			m_debugDrawer->drawLine(center, center + normal, normalColor);
		}
		m_debugDrawer->drawLine(wv0, wv1, m_color);
		m_debugDrawer->drawLine(wv1, wv2, m_color);
		m_debugDrawer->drawLine(wv2, wv0, m_color);
	}
};

void btCollisionWorld::debugDrawObject(const btTransform& worldTransform, const btCollisionShape* shape, const btVector3& color)
{
	// Draw a small simplex at the center of the object
	if (getDebugDrawer() && getDebugDrawer()->getDebugMode() & btIDebugDraw::DBG_DrawFrames)
	{
		getDebugDrawer()->drawTransform(worldTransform, .1);
	}

	if (shape->getShapeType() == COMPOUND_SHAPE_PROXYTYPE)
	{
		const btCompoundShape* compoundShape = static_cast<const btCompoundShape*>(shape);
		for (int i = compoundShape->getNumChildShapes() - 1; i >= 0; i--)
		{
			btTransform childTrans = compoundShape->getChildTransform(i);
			const btCollisionShape* colShape = compoundShape->getChildShape(i);
			debugDrawObject(worldTransform * childTrans, colShape, color);
		}
	}
	else
	{
		switch (shape->getShapeType())
		{
			case BOX_SHAPE_PROXYTYPE:
			{
				const btBoxShape* boxShape = static_cast<const btBoxShape*>(shape);
				btVector3 halfExtents = boxShape->getHalfExtentsWithMargin();
				getDebugDrawer()->drawBox(-halfExtents, halfExtents, worldTransform, color);
				break;
			}

			case SPHERE_SHAPE_PROXYTYPE:
			{
				const btSphereShape* sphereShape = static_cast<const btSphereShape*>(shape);
				btScalar radius = sphereShape->getMargin();  //radius doesn't include the margin, so draw with margin

				getDebugDrawer()->drawSphere(radius, worldTransform, color);
				break;
			}
			case MULTI_SPHERE_SHAPE_PROXYTYPE:
			{
				const btMultiSphereShape* multiSphereShape = static_cast<const btMultiSphereShape*>(shape);

				btTransform childTransform;
				childTransform.setIdentity();

				for (int i = multiSphereShape->getSphereCount() - 1; i >= 0; i--)
				{
					childTransform.setOrigin(multiSphereShape->getSpherePosition(i));
					getDebugDrawer()->drawSphere(multiSphereShape->getSphereRadius(i), worldTransform * childTransform, color);
				}

				break;
			}
			case CAPSULE_SHAPE_PROXYTYPE:
			{
				const btCapsuleShape* capsuleShape = static_cast<const btCapsuleShape*>(shape);

				btScalar radius = capsuleShape->getRadius();
				btScalar halfHeight = capsuleShape->getHalfHeight();

				int upAxis = capsuleShape->getUpAxis();
				getDebugDrawer()->drawCapsule(radius, halfHeight, upAxis, worldTransform, color);
				break;
			}
			case CONE_SHAPE_PROXYTYPE:
			{
				const btConeShape* coneShape = static_cast<const btConeShape*>(shape);
				btScalar radius = coneShape->getRadius();  //+coneShape->getMargin();
				btScalar height = coneShape->getHeight();  //+coneShape->getMargin();

				int upAxis = coneShape->getConeUpIndex();
				getDebugDrawer()->drawCone(radius, height, upAxis, worldTransform, color);
				break;
			}
			case CYLINDER_SHAPE_PROXYTYPE:
			{
				const btCylinderShape* cylinder = static_cast<const btCylinderShape*>(shape);
				int upAxis = cylinder->getUpAxis();
				btScalar radius = cylinder->getRadius();
				btScalar halfHeight = cylinder->getHalfExtentsWithMargin()[upAxis];
				getDebugDrawer()->drawCylinder(radius, halfHeight, upAxis, worldTransform, color);
				break;
			}

			case STATIC_PLANE_PROXYTYPE:
			{
				const btStaticPlaneShape* staticPlaneShape = static_cast<const btStaticPlaneShape*>(shape);
				btScalar planeConst = staticPlaneShape->getPlaneConstant();
				const btVector3& planeNormal = staticPlaneShape->getPlaneNormal();
				getDebugDrawer()->drawPlane(planeNormal, planeConst, worldTransform, color);
				break;
			}
			default:
			{
				/// for polyhedral shapes
				if (shape->isPolyhedral())
				{
					btPolyhedralConvexShape* polyshape = (btPolyhedralConvexShape*)shape;

					int i;
					if (polyshape->getConvexPolyhedron())
					{
						const btConvexPolyhedron* poly = polyshape->getConvexPolyhedron();
						for (i = 0; i < poly->m_faces.size(); i++)
						{
							btVector3 centroid(0, 0, 0);
							int numVerts = poly->m_faces[i].m_indices.size();
							if (numVerts)
							{
								int lastV = poly->m_faces[i].m_indices[numVerts - 1];
								for (int v = 0; v < poly->m_faces[i].m_indices.size(); v++)
								{
									int curVert = poly->m_faces[i].m_indices[v];
									centroid += poly->m_vertices[curVert];
									getDebugDrawer()->drawLine(worldTransform * poly->m_vertices[lastV], worldTransform * poly->m_vertices[curVert], color);
									lastV = curVert;
								}
							}
							centroid *= btScalar(1.f) / btScalar(numVerts);
							if (getDebugDrawer()->getDebugMode() & btIDebugDraw::DBG_DrawNormals)
							{
								btVector3 normalColor(1, 1, 0);
								btVector3 faceNormal(poly->m_faces[i].m_plane[0], poly->m_faces[i].m_plane[1], poly->m_faces[i].m_plane[2]);
								getDebugDrawer()->drawLine(worldTransform * centroid, worldTransform * (centroid + faceNormal), normalColor);
							}
						}
					}
					else
					{
						for (i = 0; i < polyshape->getNumEdges(); i++)
						{
							btVector3 a, b;
							polyshape->getEdge(i, a, b);
							btVector3 wa = worldTransform * a;
							btVector3 wb = worldTransform * b;
							getDebugDrawer()->drawLine(wa, wb, color);
						}
					}
				}

				if (shape->isConcave())
				{
					btConcaveShape* concaveMesh = (btConcaveShape*)shape;

					///@todo pass camera, for some culling? no -> we are not a graphics lib
					btVector3 aabbMax(btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT));
					btVector3 aabbMin(btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT));

					DebugDrawcallback drawCallback(getDebugDrawer(), worldTransform, color);
					concaveMesh->processAllTriangles(&drawCallback, aabbMin, aabbMax);
				}

				if (shape->getShapeType() == CONVEX_TRIANGLEMESH_SHAPE_PROXYTYPE)
				{
					btConvexTriangleMeshShape* convexMesh = (btConvexTriangleMeshShape*)shape;
					//todo: pass camera for some culling
					btVector3 aabbMax(btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT), btScalar(BT_LARGE_FLOAT));
					btVector3 aabbMin(btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT), btScalar(-BT_LARGE_FLOAT));
					//DebugDrawcallback drawCallback;
					DebugDrawcallback drawCallback(getDebugDrawer(), worldTransform, color);
					convexMesh->getMeshInterface()->InternalProcessAllTriangles(&drawCallback, aabbMin, aabbMax);
				}
			}
		}
	}
}

void btCollisionWorld::debugDrawWorld()
{
	if (getDebugDrawer())
	{
		getDebugDrawer()->clearLines();

		btIDebugDraw::DefaultColors defaultColors = getDebugDrawer()->getDefaultColors();

		if (getDebugDrawer()->getDebugMode() & btIDebugDraw::DBG_DrawContactPoints)
		{
			if (getDispatcher())
			{
				int numManifolds = getDispatcher()->getNumManifolds();

				for (int i = 0; i < numManifolds; i++)
				{
					btPersistentManifold* contactManifold = getDispatcher()->getManifoldByIndexInternal(i);
					//btCollisionObject* obA = static_cast<btCollisionObject*>(contactManifold->getBody0());
					//btCollisionObject* obB = static_cast<btCollisionObject*>(contactManifold->getBody1());

					int numContacts = contactManifold->getNumContacts();
					for (int j = 0; j < numContacts; j++)
					{
						btManifoldPoint& cp = contactManifold->getContactPoint(j);
						getDebugDrawer()->drawContactPoint(cp.m_positionWorldOnB, cp.m_normalWorldOnB, cp.getDistance(), cp.getLifeTime(), defaultColors.m_contactPoint);
					}
				}
			}
		}

		if ((getDebugDrawer()->getDebugMode() & (btIDebugDraw::DBG_DrawWireframe | btIDebugDraw::DBG_DrawAabb)))
		{
			int i;

			for (i = 0; i < m_collisionObjects.size(); i++)
			{
				btCollisionObject* colObj = m_collisionObjects[i];
				if ((colObj->getCollisionFlags() & btCollisionObject::CF_DISABLE_VISUALIZE_OBJECT) == 0)
				{
					if (getDebugDrawer() && (getDebugDrawer()->getDebugMode() & btIDebugDraw::DBG_DrawWireframe))
					{
						btVector3 color(btScalar(0.4), btScalar(0.4), btScalar(0.4));

						switch (colObj->getActivationState())
						{
							case ACTIVE_TAG:
								color = defaultColors.m_activeObject;
								break;
							case ISLAND_SLEEPING:
								color = defaultColors.m_deactivatedObject;
								break;
							case WANTS_DEACTIVATION:
								color = defaultColors.m_wantsDeactivationObject;
								break;
							case DISABLE_DEACTIVATION:
								color = defaultColors.m_disabledDeactivationObject;
								break;
							case DISABLE_SIMULATION:
								color = defaultColors.m_disabledSimulationObject;
								break;
							default:
							{
								color = btVector3(btScalar(.3), btScalar(0.3), btScalar(0.3));
							}
						};

						colObj->getCustomDebugColor(color);

						debugDrawObject(colObj->getWorldTransform(), colObj->getCollisionShape(), color);
					}
					if (m_debugDrawer && (m_debugDrawer->getDebugMode() & btIDebugDraw::DBG_DrawAabb))
					{
						btVector3 minAabb, maxAabb;
						btVector3 colorvec = defaultColors.m_aabb;
						colObj->getCollisionShape()->getAabb(colObj->getWorldTransform(), minAabb, maxAabb);
						btVector3 contactThreshold(gContactBreakingThreshold, gContactBreakingThreshold, gContactBreakingThreshold);
						minAabb -= contactThreshold;
						maxAabb += contactThreshold;

						btVector3 minAabb2, maxAabb2;

						if (getDispatchInfo().m_useContinuous && colObj->getInternalType() == btCollisionObject::CO_RIGID_BODY && !colObj->isStaticOrKinematicObject())
						{
							colObj->getCollisionShape()->getAabb(colObj->getInterpolationWorldTransform(), minAabb2, maxAabb2);
							minAabb2 -= contactThreshold;
							maxAabb2 += contactThreshold;
							minAabb.setMin(minAabb2);
							maxAabb.setMax(maxAabb2);
						}

						m_debugDrawer->drawAabb(minAabb, maxAabb, colorvec);
					}
				}
			}
		}
	}
}

void btCollisionWorld::serializeCollisionObjects(btSerializer* serializer)
{
	int i;

	///keep track of shapes already serialized
	btHashMap<btHashPtr, btCollisionShape*> serializedShapes;

	for (i = 0; i < m_collisionObjects.size(); i++)
	{
		btCollisionObject* colObj = m_collisionObjects[i];
		btCollisionShape* shape = colObj->getCollisionShape();

		if (!serializedShapes.find(shape))
		{
			serializedShapes.insert(shape, shape);
			shape->serializeSingleShape(serializer);
		}
	}

	//serialize all collision objects
	for (i = 0; i < m_collisionObjects.size(); i++)
	{
		btCollisionObject* colObj = m_collisionObjects[i];
		if (colObj->getInternalType() == btCollisionObject::CO_COLLISION_OBJECT)
		{
			colObj->serializeSingleObject(serializer);
		}
	}
}

void btCollisionWorld::serializeContactManifolds(btSerializer* serializer)
{
	if (serializer->getSerializationFlags() & BT_SERIALIZE_CONTACT_MANIFOLDS)
	{
		int numManifolds = getDispatcher()->getNumManifolds();
		for (int i = 0; i < numManifolds; i++)
		{
			const btPersistentManifold* manifold = getDispatcher()->getInternalManifoldPointer()[i];
			//don't serialize empty manifolds, they just take space
			//(may have to do it anyway if it destroys determinism)
			if (manifold->getNumContacts() == 0)
				continue;

			btChunk* chunk = serializer->allocate(manifold->calculateSerializeBufferSize(), 1);
			const char* structType = manifold->serialize(manifold, chunk->m_oldPtr, serializer);
			serializer->finalizeChunk(chunk, structType, BT_CONTACTMANIFOLD_CODE, (void*)manifold);
		}
	}
}

void btCollisionWorld::serialize(btSerializer* serializer)
{
	serializer->startSerialization();

	serializeCollisionObjects(serializer);

	serializeContactManifolds(serializer);

	serializer->finishSerialization();
}
",16352,True,3012.467265965088,median
"#include ""core_includes.h""
#include ""os_core_graphics.h""
#include ""core_includes.h""
#include ""FApp.hpp""
#include ""PlatformGraphicsInterface.hpp""
#include ""FFloatBufferCache.hpp""
#include ""FIndexBufferCache.hpp""
#include ""FFileTable.hpp""
#include ""ShaderProgram.hpp""
#include ""OpenGLEngine.hpp""
#include ""FModelDataPacked.hpp""


#if defined(WIN_32_ENV) || defined(MAC_ENVIRONMENT)
//

//
#endif

#ifndef glOrthof
#define glOrthof glOrtho
#endif

//
#ifndef GL_CLAMP_TO_EDGE
#define GL_CLAMP_TO_EDGE GL_CLAMP
//
#endif


static int                                  cArrayBufferDataOffset = -1;
static int                                  cArrayBufferPositionsOffset = -1;
static int                                  cArrayBufferTextureCoordsOffset = -1;
static int                                  cArrayBufferNormalsOffset = -1;
static int                                  cArrayBufferTangentsOffset = -1;

static int                                  gGraphicsThread = -1;

static int                                  cCurrentRenderPass = -1;

static int                                  cBufferIndexUniforms = 2;
static int                                  cBufferIndexPositions = 0;
static int                                  cBufferIndexTextureCoords = 1;
static int                                  cBufferIndexNormals = -1;
static int                                  cBufferIndexUNormals = -1;
static int                                  cBufferIndexTangents = -1;
static int                                  cBufferIndexData = 0;
static int                                  cBufferIndexTextures = 0;

static float                                cDeviceScale = 1.0f;


static float                                cClipRectBase[4];
static bool                                 cClipEnabled = false;

//static bool                                 cDidTearDown = false;


ShaderProgram                               *cShaderProgram = NULL;

FMatrix                                     cMatrixProjection;
FMatrix                                     cMatrixModelView;

FMatrix                                     cMatrixOrtho;
FTextureRect                                cTileRect;

//When we create buffers, we add them to this thing...
//VideoBuffer

FUniforms                                   cUniform;
FFloatBufferCacheByteAligned256             cVertexCache;
FIndexBufferCache                           cIndexCache;

static FColor                               cColor;
static float                                cRectBuffer[12];


Graphics::Graphics() {
    
}

Graphics::~Graphics() {
    
}

void Graphics::Flush() {
    
}

void Graphics::Initialize() {
    
    //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR );
    //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
    //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE );
    //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE );
    
    BlendEnable();
    BlendSetAlpha();
    
    //Graphics::TextureSetClamp();
#if (CURRENT_ENV == ENV_WIN32)
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T, GL_CLAMP);
#else
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    
#endif
    
    Graphics::TextureSetFilterLinear();
    
    //Graphics::TextureEnable();
    glEnable(GL_TEXTURE_2D);
    
    //Graphics::EnableTextureCoordinateArray();
    //glEnableClientState(GL_TEXTURE_COORD_ARRAY);
    
    //Graphics::EnableVertexArray();
    
    
    
}

void Graphics::SetUp() {
    
    Log(""Graphics::SetUp() => gOpenGLEngine->SetUp();\\n"");
    gOpenGLEngine->SetUp();
    
    
    gTextureCache.ReloadAllTextures();
    gBufferCache.ReloadAllBuffers();
    
    /*
    if (cDidTearDown) {
        cDidTearDown = false;
        gOpenGLEngine->SetUp();
        gTextureCache.ReloadAllTextures();
        gBufferCache.ReloadAllBuffers();
        
        EnumList(FSprite, aSprite, gSpriteList) {
            aSprite->WriteBuffers();
            Log(""Sprite Name: %s\\n"", aSprite->mFileName.c());
        }
        
        //EnumList(FModelDataPacked, aModel, gPackedModelList) {
        //    aModel->WriteBuffers();
        //}
        
        
    }
    */
    
}

//Before we lose out content, we TEAR DOWN.
void Graphics::TearDown() {
    
    Log(""Graphics::TearDown()\\n"");
    
    if (gOpenGLEngine) {
        Log(""Graphics::TearDown() => gOpenGLEngine->SetUp();\\n"");
        gOpenGLEngine->TearDown();
    }
    
    //cDidTearDown = true;
    gTextureCache.UnloadAllTextures();
    gBufferCache.UnloadAllBuffers();
    
}


void Graphics::SetDeviceScale(float pScale) {
    cDeviceScale = pScale;
}

void Graphics::SetDeviceSize(float pWidth, float pHeight) {
    FMatrix aOrtho = FMatrixCreateOrtho(0.0f, pWidth, pHeight, 0.0f, -2048.0f, 2048.0f);
    cMatrixOrtho.Set(aOrtho);
    Graphics::ViewportSet(0.0f, 0.0f, pWidth, pHeight);
    Graphics::ClipSetAppFrame(0.0f, 0.0f, pWidth, pHeight);
    cTileRect.SetRect(0.0f, 0.0f, pWidth, pHeight);
}

void Graphics::PreRender() {
    cVertexCache.Reset();
    cIndexCache.Reset();
    
    cCurrentRenderPass = -1;
    cShaderProgram = NULL;
    
    cArrayBufferDataOffset = -999;
    cArrayBufferPositionsOffset = -999;
    cArrayBufferTextureCoordsOffset = -999;
    cArrayBufferNormalsOffset = -999;
    cArrayBufferTangentsOffset = -999;
}

void Graphics::PostRender() {
    cCurrentRenderPass = -1;
}

void Graphics::DrawQuad(float pX1, float pY1, float pX2, float pY2, float pX3, float pY3, float pX4, float pY4) {
    
    FBuffer *aBufferPosition = gBufferCache.GetArrayBuffer(sizeof(float) * 8);
    
    if (aBufferPosition == NULL) { return; }
    if (aBufferPosition->mBindIndex == -1) { return; }
    
    
    cRectBuffer[0] = pX1;
    cRectBuffer[1] = pY1;
    cRectBuffer[2] = pX2;
    cRectBuffer[3] = pY2;
    cRectBuffer[4] = pX3;
    cRectBuffer[5] = pY3;
    cRectBuffer[6] = pX4;
    cRectBuffer[7] = pY4;
    
    BufferArrayWrite(aBufferPosition, cRectBuffer, 0, sizeof(float) * 8);
    ArrayBufferPositions(aBufferPosition, 0);
    
    UniformBind();
    DrawTriangleStrips(4);
    //
    //
    //
}

void Graphics::DrawQuad(float x1, float y1, float z1, float x2, float y2, float z2,
                        float x3, float y3, float z3, float x4, float y4, float z4) {
    cRectBuffer[0]=x1;
    cRectBuffer[1]=y1;
    cRectBuffer[2]=z1;
    
    cRectBuffer[3]=x2;
    cRectBuffer[4]=y2;
    cRectBuffer[5]=z2;
    
    cRectBuffer[6]=x3;
    cRectBuffer[7]=y3;
    cRectBuffer[8]=z3;
    
    cRectBuffer[9]=x4;
    cRectBuffer[10]=y4;
    cRectBuffer[11]=z4;
    
    
    FBuffer *aPositionsBuffer = gBufferCache.GetArrayBuffer(sizeof(float) * 12);
    if (aPositionsBuffer != NULL && aPositionsBuffer->mBindIndex != -1) {
        BufferArrayWrite(aPositionsBuffer, cRectBuffer, 0, sizeof(float) * 12);
        ArrayBufferPositions(aPositionsBuffer, 0);
        DrawTriangleStrips(4);
    }
    
    
    /*
     cVertexCache.Get(sizeof(float) * 12);
     if (cVertexCache.mResult.mSuccess) {
     FBuffer *aPositionsBuffer = cVertexCache.mResult.mBuffer;
     int aPositionsBufferOffset = cVertexCache.mResult.mBufferOffset;
     BufferArrayWrite(aPositionsBuffer, cRectBuffer, aPositionsBufferOffset, sizeof(float) * 12);
     ArrayBufferPositions(aPositionsBuffer, aPositionsBufferOffset);
     }
     
     //TODO: Bind Uni?
     //This will MESS UP menu ??
     //UniformBind();
     DrawTriangleStrips(4);
     */
}


void Graphics::SetColor(float pRed, float pGreen, float pBlue, float pAlpha) {
    cColor.mRed = pRed;
    cColor.mGreen = pGreen;
    cColor.mBlue = pBlue;
    cColor.mAlpha = pAlpha;
}

void Graphics::SetColor(float pRed, float pGreen, float pBlue){Graphics::SetColor(pRed,pGreen,pBlue,1);}
void Graphics::SetColor(float pIntensity){Graphics::SetColor(1,1,1,pIntensity);}
void Graphics::SetColor(){Graphics::SetColor(1,1,1,1);}
void Graphics::SetColor(FColor pColor){Graphics::SetColor(pColor.mRed,pColor.mGreen,pColor.mBlue,pColor.mAlpha);}




void Graphics::SetColorHex(int pRed, int pGreen, int pBlue, int pAlpha) {
    Graphics::SetColor((float)pRed/255.0f, (float)pGreen/255.0f, (float)pBlue/255.0f, (float)pAlpha/255.0f);
}

void Graphics::SetColorHex(int pRed, int pGreen, int pBlue) {
    SetColorHex(pRed, pGreen, pBlue, 255);
}

void Graphics::SetColorHex(int pAlpha) {
    SetColorHex(255,255,255,pAlpha);
}

void Graphics::DrawTriangle2D(float pX1, float pY1, float pX2, float pY2, float pX3, float pY3) {
    //
    cRectBuffer[0] = pX1;
    cRectBuffer[1] = pY1;
    cRectBuffer[2] = pX2;
    cRectBuffer[3] = pY2;
    cRectBuffer[4] = pX3;
    cRectBuffer[5] = pY3;
    //
    cVertexCache.Get(sizeof(float) * 6);
    if (cVertexCache.mResult.mSuccess) {
        FBuffer *aPositionsBuffer = cVertexCache.mResult.mBuffer;
        int aPositionsBufferOffset = cVertexCache.mResult.mBufferOffset;
        BufferArrayWrite(aPositionsBuffer, cRectBuffer, aPositionsBufferOffset, sizeof(float) * 6);
        ArrayBufferPositions(aPositionsBuffer, aPositionsBufferOffset);
    }
    //
    UniformBind();
    DrawTriangles(3);
}

void Graphics::DrawRect(float pX, float pY, float pWidth, float pHeight) {
    DrawQuad(pX, pY, pX + pWidth, pY, pX, pY + pHeight, pX + pWidth, pY + pHeight);
}

void Graphics::OutlineRect(float pX, float pY, float pWidth, float pHeight, float pThickness) {
    DrawRect(pX-pThickness, pY-pThickness, pWidth + pThickness * 2, pThickness);
    DrawRect(pX-pThickness, pY+pHeight, pWidth + pThickness * 2, pThickness);
    DrawRect(pX-pThickness, pY, pThickness, pHeight);
    DrawRect(pX+pWidth, pY, pThickness, pHeight);
}

void Graphics::OutlineRectInside(float pX, float pY, float pWidth, float pHeight, float pThickness) {
    OutlineRect(pX + pThickness, pY + pThickness, pWidth - pThickness * 2, pHeight - pThickness * 2, pThickness);
}

void Graphics::OutlineRect(FRect pRect, float pThickness) {
    OutlineRect(pRect.mX, pRect.mY, pRect.mWidth, pRect.mHeight, pThickness);
}

void Graphics::OutlineRectInside(FRect pRect, float pThickness) {
    OutlineRectInside(pRect.mX, pRect.mY, pRect.mWidth, pRect.mHeight, pThickness);
}

void Graphics::SetColorSwatch(int pSwatchIndex, float pAlpha) {
    bool aSign = pSwatchIndex < 0;
    
    if (aSign) {
        pSwatchIndex = (-pSwatchIndex);
    }
    
    if (pSwatchIndex >= 8) {
        pSwatchIndex = (pSwatchIndex % 8);
    }
    
    if (aSign) {
        pSwatchIndex = (8 - pSwatchIndex);
    }
    
    if (pSwatchIndex==0) {
        Graphics::SetColor(1,0,0, pAlpha);
    } else if(pSwatchIndex == 1) {
        Graphics::SetColor(0,1,0, pAlpha);
    } else if(pSwatchIndex == 2) {
        Graphics::SetColor(0,0,1, pAlpha);
    } else if(pSwatchIndex == 3) {
        Graphics::SetColor(0.5f,1,1, pAlpha);
    } else if(pSwatchIndex == 4) {
        Graphics::SetColor(1,0.5f,1, pAlpha);
    } else if(pSwatchIndex==5) {
        Graphics::SetColor(1,1,0.5, pAlpha);
    } else if(pSwatchIndex==6) {
        Graphics::SetColor(1,0.5f,0.5, pAlpha);
    } else if(pSwatchIndex==7) {
        Graphics::SetColor(0.5f,1,0.5, pAlpha);
    } else {
        Graphics::SetColor(0.5f,0.5f,1, pAlpha);
    }
}

void Graphics::SetColorSwatch(int pSwatchIndex) {
    SetColorSwatch(pSwatchIndex, 1.0f);
}

void Graphics::DrawLine(float pX1, float pY1, float pX2, float pY2) {
    DrawLine(pX1, pY1, pX2, pY2, 1.0f);
}

void Graphics::DrawLine(float pX1, float pY1, float pX2, float pY2, float pThickness) {
    float aDirX = pX2 - pX1;
    float aDirY = pY2 - pY1;
    float aDist = sqrtf((aDirX * aDirX) + (aDirY * aDirY));
    
    aDirX /= aDist;
    aDirY /= aDist;
    
    float aHold = aDirX;
    
    aDirX=-aDirY;
    aDirY=aHold;
    aDirX*=pThickness;
    aDirY*=pThickness;
    
    DrawQuad(pX2-aDirX, pY2-aDirY, pX2+aDirX, pY2+aDirY, pX1-aDirX, pY1-aDirY, pX1+aDirX, pY1+aDirY);
}

void Graphics::DrawPoint(float pX, float pY, float pSize) {
    DrawRect(pX-pSize/2, pY-pSize/2, pSize, pSize);
}

void Graphics::DrawArrow(float pStartX, float pStartY, float pEndX, float pEndY, float pHeadLength, float pThickness) {
    DrawLine(pStartX, pStartY, pEndX, pEndY, pThickness);
    
    float aDiffX = pStartX - pEndX;
    float aDiffY = pStartY - pEndY;
    
    float aAngle = RADIANS_TO_DEGREES(atan2f(aDiffX, aDiffY));
    
    float aAngle1 = aAngle + 35;
    float aAngle2 = aAngle - 35;
    
    DrawLine(pEndX, pEndY, pEndX + Sin(aAngle1) * pHeadLength, pEndY + Cos(aAngle1) * pHeadLength, pThickness);
    DrawLine(pEndX, pEndY, pEndX + Sin(aAngle2) * pHeadLength, pEndY + Cos(aAngle2) * pHeadLength, pThickness);
}


void Graphics::DrawBox(float x1, float y1, float z1, float x2, float y2, float z2, float pSize, float pRotation) {
    float aDirX = x2 - x1;
    float aDirY = y2 - y1;
    float aDirZ = z2 - z1;
    
    float aLength = aDirX * aDirX + aDirY * aDirY + aDirZ * aDirZ;
    
    if (aLength < SQRT_EPSILON) {
        aDirX = 0.0f;
        aDirY = 0.0f;
        aDirZ = 1.0f;
    } else {
        aLength = (float)sqrtf(aLength);
        aDirX /= aLength;
        aDirY /= aLength;
        aDirZ /= aLength;
    }
    
    Graphics::CullFacesSetDisabled();
    
    
    
    FVec3 aReference = FVec3(aDirX, aDirY, aDirZ);
    FVec3 aAxis = FVec3(aDirX, aDirY, aDirZ);
    
    //Pick the ""optimal"" orthogonal...
    float aFactorX = fabsf(aReference.mX);
    float aFactorY = fabsf(aReference.mY);
    float aFactorZ = fabsf(aReference.mZ);
    
    // (1, 1, 1)
    //   Ortho (-1, 1, 1)
    
    if (aFactorX < 0.00025f) {
        
        if (aFactorY < 0.00025f) {
            
            //Z only, go straight up or left...
            aReference = FVec3(0.0f, 1.0f, 0.0f);
            
        } else {
            //Y and Z only, flip them...
            aReference = FVec3(0.0f, -aReference.mZ, aReference.mY);
        }
        
        //aReference = FVec3(1.0f, 0.0f, 0.0f);
        
        
    } else if (aFactorY < 0.00025f) {
        
        if (aFactorZ < 0.00025f) {
            //X only, go straight up or in...
            aReference = FVec3(0.0f, -1.0f, 0.0f);
        } else {
            //X and Z only, flip them...
            aReference = FVec3(-aReference.mZ, 0.0f, aReference.mX);
        }
    } else if (aFactorZ < 0.00025f) {
        //X and Y only, flip them...
        aReference = FVec3(-aReference.mY, aReference.mX, 0.0f);
    } else {
        aReference = FVec3(1.0f, 1.0f, -((aAxis.mX + aAxis.mY) / aAxis.mZ));
    }
    
    aReference.Normalize();
    
    FVec3 aPerp1 = Rotate3DNormalized(aReference, aAxis, 0.0f + pRotation);
    FVec3 aPerp2 = Rotate3DNormalized(aReference, aAxis, 90.0f + pRotation);
    FVec3 aPerp3 = Rotate3DNormalized(aReference, aAxis, 180.0f + pRotation);
    FVec3 aPerp4 = Rotate3DNormalized(aReference, aAxis, 270.0f + pRotation);
    
    static float aCornerX1[4];
    static float aCornerY1[4];
    static float aCornerZ1[4];
    
    static float aCornerX2[4];
    static float aCornerY2[4];
    static float aCornerZ2[4];
    
    float aSize = (pSize / 2.0f);
    aPerp1 *= aSize; aPerp2 *= aSize; aPerp3 *= aSize; aPerp4 *= aSize;
    
    aCornerX1[0] = x1 + aPerp1.mX; aCornerY1[0] = y1 + aPerp1.mY; aCornerZ1[0] = z1 + aPerp1.mZ;
    aCornerX1[1] = x1 + aPerp2.mX; aCornerY1[1] = y1 + aPerp2.mY; aCornerZ1[1] = z1 + aPerp2.mZ;
    aCornerX1[2] = x1 + aPerp3.mX; aCornerY1[2] = y1 + aPerp3.mY; aCornerZ1[2] = z1 + aPerp3.mZ;
    aCornerX1[3] = x1 + aPerp4.mX; aCornerY1[3] = y1 + aPerp4.mY; aCornerZ1[3] = z1 + aPerp4.mZ;
    //          //
    //          //
    // // // // //
    //          //
    //          //
    aCornerX2[0] = x2 + aPerp1.mX; aCornerY2[0] = y2 + aPerp1.mY; aCornerZ2[0] = z2 + aPerp1.mZ;
    aCornerX2[1] = x2 + aPerp2.mX; aCornerY2[1] = y2 + aPerp2.mY; aCornerZ2[1] = z2 + aPerp2.mZ;
    aCornerX2[2] = x2 + aPerp3.mX; aCornerY2[2] = y2 + aPerp3.mY; aCornerZ2[2] = z2 + aPerp3.mZ;
    aCornerX2[3] = x2 + aPerp4.mX; aCornerY2[3] = y2 + aPerp4.mY; aCornerZ2[3] = z2 + aPerp4.mZ;
    
    //TODO: Do we want this?
    UniformBind();
    
    DrawQuad(aCornerX1[0], aCornerY1[0], aCornerZ1[0], aCornerX2[0], aCornerY2[0], aCornerZ2[0],
             aCornerX1[1], aCornerY1[1], aCornerZ1[1], aCornerX2[1], aCornerY2[1], aCornerZ2[1]);
    DrawQuad(aCornerX1[1], aCornerY1[1], aCornerZ1[1], aCornerX2[1], aCornerY2[1], aCornerZ2[1],
             aCornerX1[2], aCornerY1[2], aCornerZ1[2], aCornerX2[2], aCornerY2[2], aCornerZ2[2]);
    DrawQuad(aCornerX1[2], aCornerY1[2], aCornerZ1[2], aCornerX2[2], aCornerY2[2], aCornerZ2[2],
             aCornerX1[3], aCornerY1[3], aCornerZ1[3], aCornerX2[3], aCornerY2[3], aCornerZ2[3]);
    DrawQuad(aCornerX1[3], aCornerY1[3], aCornerZ1[3], aCornerX2[3], aCornerY2[3], aCornerZ2[3],
             aCornerX1[0], aCornerY1[0], aCornerZ1[0], aCornerX2[0], aCornerY2[0], aCornerZ2[0]);
    
    //
    // Cap ends...
    //
    DrawQuad(aCornerX1[0], aCornerY1[0], aCornerZ1[0], aCornerX1[3], aCornerY1[3], aCornerZ1[3],
             aCornerX1[1], aCornerY1[1], aCornerZ1[1], aCornerX1[2], aCornerY1[2], aCornerZ1[2]);
    DrawQuad(aCornerX2[0], aCornerY2[0], aCornerZ2[0], aCornerX2[1], aCornerY2[1], aCornerZ2[1],
             aCornerX2[3], aCornerY2[3], aCornerZ2[3], aCornerX2[2], aCornerY2[2], aCornerZ2[2]);
    
}

void Graphics::DepthEnable() {
    glEnable(GL_DEPTH_TEST);
    glDepthFunc(GL_LESS);
    glDepthMask(GL_TRUE);
}

void Graphics::DepthDisable() {
    glDisable(GL_DEPTH_TEST);
}

void Graphics::DepthClear() {
    glClear(GL_DEPTH_BUFFER_BIT);
}

void Graphics::Clear(float pRed, float pGreen, float pBlue, float pAlpha) {
    // ... This is handled by Metal
    glClearColor(pRed, pGreen, pBlue, pAlpha);
    glClear(GL_COLOR_BUFFER_BIT);
}

void Graphics::Clear(float pRed, float pGreen, float pBlue) {
    Clear(pRed, pGreen, pBlue, 1.0f);
}

void Graphics::Clear() {
    Clear(0.0f, 0.0f, 0.0f, 1.0f);
}

void Graphics::TextureSetWrap() {
    //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,GL_REPEAT);
    //glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,GL_REPEAT);
    
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    
}

void Graphics::TextureSetClamp() {
    #if (CURRENT_ENV == ENV_WIN32)
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_T, GL_CLAMP);
    #else
        glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_WRAP_S,GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
        
    #endif
}

void Graphics::TextureSetFilterMipMap() {
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR_MIPMAP_LINEAR);
}

void Graphics::TextureSetFilterLinear() {
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
}

void Graphics::ArrayBufferData(FBuffer *pBuffer) {
    ArrayBufferData(pBuffer, 0);
}

void Graphics::ArrayBufferData(FBuffer *pBuffer, int pOffset) {
    if (cShaderProgram == NULL) {
        Log(""ArrayBufferPositionsS Fails...\\n"");
        return;
    }
    cShaderProgram->ArrayBufferData(pBuffer, pOffset);
}

void Graphics::ArrayBufferPositions(FBuffer *pBuffer) {
    ArrayBufferPositions(pBuffer, 0);
}

void Graphics::ArrayBufferPositions(FBuffer *pBuffer, int pOffset) {
    if (cShaderProgram == NULL) {
        Log(""ArrayBufferPositionsS Fails...\\n"");
        return;
    }
    cShaderProgram->ArrayBufferPositions(pBuffer, pOffset);
}

void Graphics::ArrayBufferTextureCoords(FBuffer *pBuffer) {
    ArrayBufferTextureCoords(pBuffer, 0);
}

void Graphics::ArrayBufferTextureCoords(FBuffer *pBuffer, int pOffset) {
    if (cShaderProgram == NULL) {
        Log(""ArrayBufferTextureCoordsS Fails...\\n"");
        return;
    }
    cShaderProgram->ArrayBufferTextureCoords(pBuffer, pOffset);
}


void Graphics::ArrayBufferColors(FBuffer *pBuffer) {
    ArrayBufferColors(pBuffer, 0);
}

void Graphics::ArrayBufferColors(FBuffer *pBuffer, int pOffset) {
    if (cShaderProgram == NULL) {
        Log(""ArrayBufferColorsS Fails...\\n"");
        return;
    }
    cShaderProgram->ArrayBufferColors(pBuffer, pOffset);
}

void Graphics::ArrayBufferNormals(FBuffer *pBuffer) {
    ArrayBufferNormals(pBuffer, 0);
}

void Graphics::ArrayBufferNormals(FBuffer *pBuffer, int pOffset) {
    if (cShaderProgram == NULL) {
        Log(""ArrayBufferNormalsS Fails...\\n"");
        return;
    }
    cShaderProgram->ArrayBufferNormals(pBuffer, pOffset);
}

void Graphics::ArrayBufferTangents(FBuffer *pBuffer) {
    ArrayBufferTangents(pBuffer, 0);
}

void Graphics::ArrayBufferTangents(FBuffer *pBuffer, int pOffset) {
    //ShaderProgram->ArrayBufferTangents(<#int pIndex#>, <#int pOffset#>)
    Log(""ArrayBufferTangents - NOT IMPLEMENTED - EXITING...\\n"");
    exit(0);
}

FBuffer *Graphics::ArrayWriteData(void *pData, int pCount) {
    if (pCount > 0) {
        
        
        FBuffer *aDataBuffer = gBufferCache.GetArrayBuffer(pCount);
        if (aDataBuffer != NULL && aDataBuffer->mBindIndex != -1) {
            BufferArrayWrite(aDataBuffer, pData, pCount);
            ArrayBufferData(aDataBuffer);
            return aDataBuffer;
        }
    }
    return NULL;
}

void Graphics::UniformBind() {
    cUniform.mProjection.Set(cMatrixProjection);
    cUniform.mModelView.Set(cMatrixModelView);
    cUniform.mColor = cColor;
    UniformBind(&cUniform);
}

void Graphics::UniformBind(FUniforms *pUniforms) {
    if (cShaderProgram != NULL && pUniforms != NULL) {
        cShaderProgram->BindUniform(pUniforms);
    } else {
        Log(""** Illegally Trying To Bind [%x] [%x]\\n"", cShaderProgram, pUniforms);
    }
}

int Graphics::TextureGenerate(unsigned int *pData, int pWidth, int pHeight) {
    int aBindIndex = -1;
    glGenTextures(1, (GLuint*)(&aBindIndex));
    if (aBindIndex == -1) {
        Log(""Error Binding Texture [%d x %d]\\n"", pWidth, pHeight);
    } else {
        TextureSetData(aBindIndex, pData, pWidth, pHeight);
    }
    return aBindIndex;
}

void Graphics::TextureDelete(int pIndex) {
    if (pIndex != -1) {
        glDeleteTextures(1, (GLuint*)(&(pIndex)));
    }
}

void Graphics::TextureSetData(int pIndex, unsigned int *pData, int pWidth, int pHeight) {
    
    glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
    
    TextureBind(pIndex);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, pWidth, pHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, pData);
}

void Graphics::TextureBind(int pIndex) {
    glBindTexture(GL_TEXTURE_2D, pIndex);
}

void Graphics::TextureBind(FTexture *pTexture) {
    if (pTexture) {
        TextureBind(pTexture->mBindIndex);
    }
}




int Graphics::BufferArrayGenerate(int pLength) {
    unsigned int aBindIndex = 0;
    if (pLength > 0) {
        glGenBuffers(1, &aBindIndex);
        if (aBindIndex != 0) {
            glBindBuffer(GL_ARRAY_BUFFER, aBindIndex);
            glBufferData(GL_ARRAY_BUFFER, pLength, 0, GL_DYNAMIC_DRAW);
        } else {
            GLenum aError = glGetError();
            
            Log(""Failed To Make Buffer[%d] Err[%d]\\n"", pLength, aError);
        }
    } else {
        Log(""Creating Invalid Sized Buffer... [%d]\\n"", pLength);
    }
    
    return aBindIndex;
    
    //glBindBuffer(GL_ARRAY_BUFFER, pBufferIndex);
    //glBufferData(GL_ARRAY_BUFFER, pSize * 4, pData, GL_STATIC_DRAW);
    //GL_ELEMENT_ARRAY_BUFFER
}

void Graphics::BufferArrayWrite(FBuffer *pBuffer, void *pData, int pLength) {
    //BufferArrayWrite(pBuffer, pData, 0, pLength);
    
    if (pBuffer != NULL && pBuffer->mBindIndex != -1) {
        glBindBuffer(GL_ARRAY_BUFFER, pBuffer->mBindIndex);
        glBufferData(GL_ARRAY_BUFFER, pLength, pData, GL_STATIC_DRAW);
        //glBufferSubData(GL_ARRAY_BUFFER, pOffset, pLength, pData);
        
    }
    
}

void Graphics::BufferArrayWrite(FBuffer *pBuffer, void *pData, int pOffset, int pLength) {
    if (pBuffer != NULL && pBuffer->mBindIndex != -1) {
        glBindBuffer(GL_ARRAY_BUFFER, pBuffer->mBindIndex);
        glBufferSubData(GL_ARRAY_BUFFER, pOffset, pLength, pData);
    }
    //glBufferSubData (GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) OPENGLES_DEPRECATED(ios(3.0, 12.0), tvos(9.0, 12.0));
    
}

void Graphics::BufferArrayDelete(int pIndex) {
    if (pIndex != -1) {
        glDeleteBuffers(1, (unsigned int *)(&(pIndex)));
    }
}


int Graphics::BufferElementGenerate(int pLength) {
    unsigned int aBindIndex = -1;
    if (pLength > 0) {
        glGenBuffers(1, &aBindIndex);
        if (aBindIndex != -1) {
            Log(""Create Element Buffer [%d] Sized[%d]\\n"", aBindIndex, pLength);
            glBufferData(GL_ELEMENT_ARRAY_BUFFER, pLength, 0, GL_STATIC_DRAW);
        } else {
            Log(""Failed To Make Element Buffer[%d]\\n"", pLength);
        }
    } else {
        Log(""Creating Invalid Sized Element Buffer... [%d]\\n"", pLength);
    }
    
    
    
    return aBindIndex;
}

void Graphics::BufferElementWrite(FBuffer *pBuffer, void *pData, int pLength) {
    BufferElementWrite(pBuffer, pData, 0, pLength);
}

void Graphics::BufferElementWrite(FBuffer *pBuffer, void *pData, int pOffset, int pLength) {
    
    if (pBuffer != NULL && pBuffer->mBindIndex != -1) {
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, pBuffer->mBindIndex);
        glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, pOffset, pLength, pData);
    }
}

void Graphics::BufferElementDelete(int pIndex) {
    if (pIndex != -1) {
        glDeleteBuffers(1, (unsigned int *)(&(pIndex)));
    }
}

void Graphics::BufferSetUniformsIndex(int pIndex) {
    cBufferIndexUniforms = pIndex;
}

void Graphics::BufferSetPositionsIndex(int pIndex) {
    cBufferIndexPositions = pIndex;
}

void Graphics::BufferSetTextureCoordsIndex(int pIndex) {
    cBufferIndexTextureCoords = pIndex;
}

void Graphics::BufferSetNormalsIndex(int pIndex) {
    cBufferIndexNormals = pIndex;
}

void Graphics::BufferSetTangentsIndex(int pIndex) {
    cBufferIndexTangents = pIndex;
}

void Graphics::BufferSetUNormalsIndex(int pIndex) {
    cBufferIndexUNormals = pIndex;
}

void Graphics::BufferSetDataIndex(int pIndex) {
    cBufferIndexData = pIndex;
}

void Graphics::BufferSetTexturesIndex(int pIndex) {
    cBufferIndexTextures = pIndex;
}

void Graphics::BufferSetIndicesShape() {
    Graphics::BufferSetPositionsIndex(GFX_BUFFER_INDEX_POSITIONS_SHAPE);
    Graphics::BufferSetTextureCoordsIndex(-1);
    Graphics::BufferSetNormalsIndex(-1);
    Graphics::BufferSetTangentsIndex(-1);
    Graphics::BufferSetUNormalsIndex(-1);
    Graphics::BufferSetDataIndex(-1);
    Graphics::BufferSetUniformsIndex(GFX_BUFFER_INDEX_UNIFORMS_SHAPE);
}

void Graphics::BufferSetIndicesShapeNode() {
    Graphics::BufferSetPositionsIndex(GFX_BUFFER_INDEX_DATA_SHAPE_NODE);
    Graphics::BufferSetTextureCoordsIndex(-1);
    Graphics::BufferSetNormalsIndex(-1);
    Graphics::BufferSetTangentsIndex(-1);
    Graphics::BufferSetUNormalsIndex(-1);
    Graphics::BufferSetDataIndex(-1);
    Graphics::BufferSetUniformsIndex(GFX_BUFFER_INDEX_UNIFORMS_SHAPE_NODE);
}

void Graphics::BufferSetIndicesSprite() {
    Graphics::BufferSetPositionsIndex(GFX_BUFFER_INDEX_POSITIONS_SPRITE);
    Graphics::BufferSetTextureCoordsIndex(GFX_BUFFER_INDEX_TEXTURE_COORDS_SPRITE);
    Graphics::BufferSetNormalsIndex(-1);
    Graphics::BufferSetTangentsIndex(-1);
    Graphics::BufferSetUNormalsIndex(-1);
    Graphics::BufferSetDataIndex(-1);
    Graphics::BufferSetUniformsIndex(GFX_BUFFER_INDEX_UNIFORMS_SPRITE);
}

void Graphics::BufferSetIndicesSimpleModel() {
    Graphics::BufferSetPositionsIndex(GFX_BUFFER_INDEX_POSITIONS_SIMPLE_MODEL);
    Graphics::BufferSetTextureCoordsIndex(GFX_BUFFER_INDEX_TEXTURE_COORDS_SIMPLE_MODEL);
    Graphics::BufferSetNormalsIndex(-1);
    Graphics::BufferSetTangentsIndex(-1);
    Graphics::BufferSetUNormalsIndex(-1);
    Graphics::BufferSetDataIndex(-1);
    Graphics::BufferSetUniformsIndex(GFX_BUFFER_INDEX_UNIFORMS_SIMPLE_MODEL);
}

void Graphics::BufferSetIndicesSimpleModelIndexed() {
    Graphics::BufferSetPositionsIndex(-1);
    Graphics::BufferSetTextureCoordsIndex(-1);
    Graphics::BufferSetNormalsIndex(-1);
    Graphics::BufferSetTangentsIndex(-1);
    Graphics::BufferSetUNormalsIndex(-1);
    Graphics::BufferSetDataIndex(GFX_BUFFER_INDEX_DATA_INDEXED_SIMPLE_MODEL);
    Graphics::BufferSetUniformsIndex(GFX_BUFFER_INDEX_UNIFORMS_INDEXED_SIMPLE_MODEL);
}

void Graphics::BufferSetIndicesModelIndexed() {
    Graphics::BufferSetPositionsIndex(-1);
    Graphics::BufferSetTextureCoordsIndex(-1);
    Graphics::BufferSetNormalsIndex(-1);
    Graphics::BufferSetTangentsIndex(-1);
    Graphics::BufferSetUNormalsIndex(-1);
    Graphics::BufferSetDataIndex(GFX_BUFFER_INDEX_DATA_INDEXED_MODEL);
    Graphics::BufferSetUniformsIndex(GFX_BUFFER_INDEX_UNIFORMS_INDEXED_MODEL);
}

void Graphics::ClipEnable() {
    if (cClipEnabled == false) {
        cClipEnabled = true;
        
        
        glEnable(GL_SCISSOR_TEST);
        
        /*
         glEnable(GLenum(GL_SCISSOR_TEST))
         glScissor(GLint(clipRect.origin.x), GLint(clipRect.origin.y), GLsizei(clipRect.size.width), GLsizei(clipRect.size.height))
         */
        
        
    }
}

void Graphics::ClipDisable() {
    //if (cClipEnabled) {
    cClipEnabled = false;
    //Clip(0.0f, 0.0f, gDeviceWidth, gDeviceHeight);
    
    glDisable(GL_SCISSOR_TEST);
}



//static double cClipPlane[4][4] = { { 0.0f, 1.0f, 0.0f, 0.0f }, { 1.0f, 0.0f, 0.0f, 0.0f }, { -1.0f, 0.0f, 0.0f, 512.0f }, { 0.0f, -1.0f, 0.0f, 512.0f } };

void Graphics::Clip(float pX, float pY, float pWidth, float pHeight) {
    
    int aMaxX = gDeviceWidth * cDeviceScale;
    int aMaxY = gDeviceHeight * cDeviceScale;
    int aLeft = roundf(pX);
    int aTop = roundf(pY);
    int aWidth = (int)(pWidth + 0.5f);
    int aHeight = (int)(pHeight + 0.5f);
    
    aLeft *= cDeviceScale;
    aTop *= cDeviceScale;
    aWidth *= cDeviceScale;
    aHeight *= cDeviceScale;
    
    if (aLeft < 0) {
        aWidth += aLeft;
        aLeft = 0;
    }
    if (aTop < 0) {
        aHeight += aTop;
        aTop = 0;
    }
    int aRight = aLeft + aWidth;
    if (aRight > aMaxX) { aWidth -= (aRight - aMaxX); }
    int aBottom = aTop + aHeight;
    if (aBottom > aMaxY) { aHeight -= (aBottom - aMaxY); }
    if (aWidth < 0) { return; }
    if (aHeight < 0) { return; }
    
    glScissor(aLeft, gDeviceHeight * cDeviceScale - (aTop + aHeight), aWidth, aHeight);
    
}

void Graphics::ClipSetAppFrame(float pX, float pY, float pWidth, float pHeight) {
    cClipRectBase[0] = pX;
    cClipRectBase[1] = pY;
    cClipRectBase[2] = pWidth;
    cClipRectBase[3] = pHeight;
}

void Graphics::ViewportSet(float pX, float pY, float pWidth, float pHeight) {
    glViewport(pX, pY, pWidth, pHeight);
}

void Graphics::DrawModelEfficientSetup(float *pPositions, float *pTextureCoords, float *pNormals, FTexture *pTexture) {
    
}

void Graphics::DrawModelIndexedEfficientSetup(float *pPositions, float *pTextureCoords, float *pNormals, FTexture *pTexture) {
    
}

void Graphics::DrawModelIndexed(float *pPositions, int pPositionsCount, float *pTextureCoords, int pTextureCoordsCount, float *pNormals, int pNormalsCount, GFX_MODEL_INDEX_TYPE *pIndex, int pCount, FTexture *pTexture) {
    
    if (pTexture == NULL || pTexture->mBindIndex == -1) {
        return;
    }
    
    if (pPositions != NULL && cBufferIndexPositions != -1 && pPositionsCount > 0) {
        cVertexCache.Get(sizeof(float) * pPositionsCount * 3);
        if (cVertexCache.mResult.mSuccess) {
            FBuffer *aPositionsBuffer = cVertexCache.mResult.mBuffer;
            int aPositionsBufferOffset = cVertexCache.mResult.mBufferOffset;
            BufferArrayWrite(aPositionsBuffer, pPositions, aPositionsBufferOffset, sizeof(float) * pPositionsCount * 3);
            ArrayBufferPositions(aPositionsBuffer, aPositionsBufferOffset);
        }
    }
    
    if (pTextureCoords != NULL && cBufferIndexTextureCoords != -1 && pTextureCoordsCount > 0) {
        cVertexCache.Get(sizeof(float) * pTextureCoordsCount * 3);
        if (cVertexCache.mResult.mSuccess) {
            FBuffer *aTextureCoordsBuffer = cVertexCache.mResult.mBuffer;
            int aTextureCoordsBufferOffset = cVertexCache.mResult.mBufferOffset;
            BufferArrayWrite(aTextureCoordsBuffer, pTextureCoords, aTextureCoordsBufferOffset, sizeof(float) * pTextureCoordsCount * 3);
            ArrayBufferTextureCoords(aTextureCoordsBuffer, aTextureCoordsBufferOffset);
        }
    }
    
    if (pNormals != NULL && cBufferIndexNormals != -1 && pNormalsCount > 0) {
        cVertexCache.Get(sizeof(float) * pNormalsCount * 3);
        if (cVertexCache.mResult.mSuccess) {
            
            FBuffer *aNormalsBuffer = cVertexCache.mResult.mBuffer;
            int aNormalsBufferOffset = cVertexCache.mResult.mBufferOffset;
            BufferArrayWrite(aNormalsBuffer, pTextureCoords, aNormalsBufferOffset, sizeof(float) * pNormalsCount * 3);
            ArrayBufferNormals(aNormalsBuffer, aNormalsBufferOffset);
        }
    }
    
    /////////////////////
    //
    TextureBind(pTexture);
    UniformBind();
    //
    //DrawTriangles(pCount);
    
    
    //DrawTrianglesIndexed(pIndex, pCount / 3);
    DrawTrianglesIndexed(pIndex, pCount);
    
}

void Graphics::DrawModelIndexed(float *pPositions, int pPositionsCount, float *pTextureCoords, int pTextureCoordsCount, float *pNormals, int pNormalsCount, GFX_MODEL_INDEX_TYPE *pIndex, FTexture *pTexture, int pStartIndex, int pEndIndex) {
    DrawModelIndexed(pPositions, pPositionsCount, pTextureCoords, pTextureCoordsCount, pNormals, pNormalsCount, pIndex + pStartIndex, (pEndIndex - pStartIndex) + 1, pTexture);
}

void Graphics::DrawModel(float *pPositions, float *pTextureCoords, float *pNormals, int pCount, FTexture *pTexture) {
    if (pTexture == NULL || pTexture->mBindIndex == -1) {
        return;
    }
    
    FBuffer *aPositionsBuffer = gBufferCache.GetArrayBuffer(sizeof(float) * pCount * 3);
    FBuffer *aTextureCoordsBuffer = gBufferCache.GetArrayBuffer(sizeof(float) * pCount * 3);
    FBuffer *aNormalsBuffer = gBufferCache.GetArrayBuffer(sizeof(float) * pCount * 3);
    
    if (aPositionsBuffer != NULL && aTextureCoordsBuffer != NULL && aNormalsBuffer != NULL) {\\
        if (aPositionsBuffer->mBindIndex != -1 && aTextureCoordsBuffer->mBindIndex != -1 && aNormalsBuffer->mBindIndex != -1) {
            
            BufferArrayWrite(aPositionsBuffer, pPositions, sizeof(float) * pCount * 3);
            ArrayBufferPositions(aPositionsBuffer);
            
            BufferArrayWrite(aTextureCoordsBuffer, pTextureCoords, sizeof(float) * pCount * 3);
            ArrayBufferTextureCoords(aTextureCoordsBuffer);
            
            BufferArrayWrite(aNormalsBuffer, pTextureCoords, sizeof(float) * pCount * 3);
            ArrayBufferNormals(aNormalsBuffer);
            
            TextureBind(pTexture);
            DrawTriangles(pCount);
        }
    }
}

void Graphics::DrawTriangles(int pCount, float *pPositions, float *pTextureCoords, float *pNormals) {
    
}

void Graphics::DrawTriangles(int pCount) {
    glDrawArrays(GL_TRIANGLES, 0, pCount);
}

void Graphics::DrawTriangleStrips(int pCount) {
    glDrawArrays(GL_TRIANGLE_STRIP, 0, pCount);
}

void Graphics::DrawTrianglesIndexed(GFX_MODEL_INDEX_TYPE *pIndices, int pCount) {
    glDrawElements(GL_TRIANGLES, pCount, GFX_MODEL_INDEX_GL_TYPE, pIndices);
}

void Graphics::DrawTrianglesIndexedWithPackedBuffers(FBuffer *pVertexBuffer, int pVertexBufferOffset, GFX_MODEL_INDEX_TYPE *pIndices, int pCount, FTexture *pTexture) {
    if (pVertexBuffer == NULL || pVertexBuffer->mBindIndex == -1) { return; }
    Graphics::TextureBind(pTexture);
    Graphics::ArrayBufferData(pVertexBuffer, pVertexBufferOffset);
    Graphics::ArrayBufferPositions(NULL, 0);
    Graphics::ArrayBufferTextureCoords(NULL, sizeof(float) * 3);
    Graphics::ArrayBufferNormals(NULL, sizeof(float) * 6);
    
    Graphics::DrawTrianglesIndexed(pIndices, pCount);
}

void Graphics::DrawTriangleStripsIndexed(GFX_MODEL_INDEX_TYPE *pIndices, int pCount) {
    glDrawElements(GL_TRIANGLE_STRIP, pCount, GFX_MODEL_INDEX_GL_TYPE, pIndices);
}

void Graphics::MatrixProjectionSet(FMatrix &pMatrix) {
    cMatrixProjection.Set(pMatrix);
}

void Graphics::MatrixModelViewSet(FMatrix &pMatrix) {
    cMatrixModelView.Set(pMatrix);
}

void Graphics::MatrixProjectionReset() {
    cMatrixProjection.Reset();
}

void Graphics::MatrixModelViewReset() {
    cMatrixModelView.Reset();
}

void Graphics::MatrixProjectionResetOrtho() {
    Graphics::MatrixProjectionSet(cMatrixOrtho);
}

FMatrix Graphics::MatrixProjectionGet() {
    FMatrix aResult;
    aResult.Set(cMatrixProjection);
    return aResult;
}

void Graphics::MatrixProjectionGet(FMatrix *pMatrix) {
    pMatrix->Set(cMatrixProjection);
}

FMatrix Graphics::MatrixModelViewGet() {
    FMatrix aResult;
    aResult.Set(cMatrixModelView);
    return aResult;
}

void Graphics::MatrixModelViewGet(FMatrix *pMatrix) {
    pMatrix->Set(cMatrixModelView);
}

void Graphics::CullFacesSetFront() {
    glEnable(GL_CULL_FACE);
    //glCullFace(GL_FRONT);
    glCullFace(GL_BACK);
}

void Graphics::CullFacesSetBack() {
    glEnable(GL_CULL_FACE);
    //glCullFace(GL_BACK);
    glCullFace(GL_FRONT);
}

void Graphics::CullFacesSetDisabled() {
    glDisable(GL_CULL_FACE);
}

void Graphics::RenderQuad(float pX1, float pY1, float pX2, float pY2, float pX3, float pY3, float pX4, float pY4, FTexture *pTexture) {
    RenderQuad(pX1, pY1, pX2, pY2, pX3, pY3, pX4, pY4, 0, 0, 0, 1, 1, 0, 1, 1, pTexture);
}

static float cRenderQuadBufferPositions[9];
static float cRenderQuadBufferUV[9];

void Graphics::RenderQuad(float pX1, float pY1, float pX2, float pY2, float pX3, float pY3, float pX4, float pY4, float pU1, float pV1, float pU2, float pV2, float pU3, float pV3, float pU4, float pV4, FTexture *pTexture) {
    cRenderQuadBufferPositions[0] = pX1;
    cRenderQuadBufferPositions[1] = pY1;
    cRenderQuadBufferPositions[2] = pX2;
    cRenderQuadBufferPositions[3] = pY2;
    cRenderQuadBufferPositions[4] = pX3;
    cRenderQuadBufferPositions[5] = pY3;
    cRenderQuadBufferPositions[6] = pX4;
    cRenderQuadBufferPositions[7] = pY4;
    cRenderQuadBufferUV[0] = pU1;
    cRenderQuadBufferUV[1] = pV1;
    cRenderQuadBufferUV[2] = pU2;
    cRenderQuadBufferUV[3] = pV2;
    cRenderQuadBufferUV[4] = pU3;
    cRenderQuadBufferUV[5] = pV3;
    cRenderQuadBufferUV[6] = pU4;
    cRenderQuadBufferUV[7] = pV4;
    
    DrawSprite(cRenderQuadBufferPositions, cRenderQuadBufferUV, pTexture);
}

//void Graphics::RenderQuadPushed(float pX1, float pY1, float pX2, float pY2, float pX3, float pY3, float pX4, float pY4,
//float pU1, float pV1, float pU2, float pV2, float pU3, float pV3, float pU4, //float pV4, FTexture *pTexture, float pPush)

void Graphics::RenderQuadScaled(float pX1, float pY1, float pX2, float pY2, float pX3, float pY3, float pX4, float pY4, float pU1, float pV1, float pU2, float pV2, float pU3, float pV3, float pU4, float pV4, FTexture *pTexture, float pScale)
{
    float aRangeX = (pX2 - pX1);
    float aRangeY = (pY3 - pY1);
    
    float aCenterX = pX1 + aRangeX / 2.0f;
    float aCenterY = pY1 + aRangeY / 2.0f;
    
    aRangeX *= pScale;
    aRangeY *= pScale;
    
    aRangeX /= 2.0f;
    aRangeY /= 2.0f;
    
    pX1 = aCenterX - aRangeX;
    pX2 = aCenterX + aRangeX;
    
    pY1 = aCenterY - aRangeY;
    pY3 = aCenterY + aRangeY;
    
    pX3 = pX1;
    pX4 = pX2;
    pY2 = pY1;
    pY4 = pY3;
    
    cRenderQuadBufferPositions[0] = pX1;
    cRenderQuadBufferPositions[1] = pY1;
    
    cRenderQuadBufferPositions[2] = pX2;
    cRenderQuadBufferPositions[3] = pY2;
    
    cRenderQuadBufferPositions[4] = pX3;
    cRenderQuadBufferPositions[5] = pY3;
    
    cRenderQuadBufferPositions[6] = pX4;
    cRenderQuadBufferPositions[7] = pY4;
    
    cRenderQuadBufferUV[0] = pU1;
    cRenderQuadBufferUV[1] = pV1;
    
    cRenderQuadBufferUV[2] = pU2;
    cRenderQuadBufferUV[3] = pV2;
    
    cRenderQuadBufferUV[4] = pU3;
    cRenderQuadBufferUV[5] = pV3;
    
    cRenderQuadBufferUV[6] = pU4;
    cRenderQuadBufferUV[7] = pV4;
    
    DrawSprite(cRenderQuadBufferPositions, cRenderQuadBufferUV, pTexture);
}


void Graphics::RenderQuadScaled(float pX1, float pY1, float pX2, float pY2, float pX3, float pY3, float pX4, float pY4, float pU1, float pV1, float pU2, float pV2, float pU3, float pV3, float pU4, float pV4, FTexture *pTexture, float pScale, float pCenterX, float pCenterY) {
    
    pX1 = pCenterX - (pCenterX - pX1) * pScale;
    pX2 = pCenterX - (pX2 - pCenterX) * pScale;
    
    pY1 = pCenterY - (pCenterY - pY1) * pScale;
    pY3 = pCenterY - (pY2 - pCenterY) * pScale;
    
    pX3 = pX1;
    pX4 = pX2;
    pY2 = pY1;
    pY4 = pY3;
    
    //pX1 -= pPush;
    //pX2 += pPush;
    
    cRenderQuadBufferPositions[0] = pX1;
    cRenderQuadBufferPositions[1] = pY1;
    
    cRenderQuadBufferPositions[2] = pX2;
    cRenderQuadBufferPositions[3] = pY2;
    
    cRenderQuadBufferPositions[4] = pX3;
    cRenderQuadBufferPositions[5] = pY3;
    
    cRenderQuadBufferPositions[6] = pX4;
    cRenderQuadBufferPositions[7] = pY4;
    
    cRenderQuadBufferUV[0] = pU1;
    cRenderQuadBufferUV[1] = pV1;
    
    cRenderQuadBufferUV[2] = pU2;
    cRenderQuadBufferUV[3] = pV2;
    
    cRenderQuadBufferUV[4] = pU3;
    cRenderQuadBufferUV[5] = pV3;
    
    cRenderQuadBufferUV[6] = pU4;
    cRenderQuadBufferUV[7] = pV4;
    
    DrawSprite(cRenderQuadBufferPositions, cRenderQuadBufferUV, pTexture);
}

void Graphics::RenderTriangle(float pX1, float pY1, float pZ1, float pX2, float pY2, float pZ2, float pX3, float pY3, float pZ3) {
    cRenderQuadBufferPositions[0] = pX1;
    cRenderQuadBufferPositions[1] = pY1;
    cRenderQuadBufferPositions[2] = pZ1;
    
    cRenderQuadBufferPositions[3] = pX2;
    cRenderQuadBufferPositions[4] = pY2;
    cRenderQuadBufferPositions[5] = pZ2;
    
    cRenderQuadBufferPositions[6] = pX3;
    cRenderQuadBufferPositions[7] = pY3;
    cRenderQuadBufferPositions[8] = pZ3;
    
    
}

void Graphics::RenderTriangle(float pX1, float pY1, float pX2, float pY2, float pX3, float pY3) {
    RenderTriangle(pX1, pY1, 0.0f, pX2, pY2, 0.0f, pX3, pY3, 0.0f);
}

bool Graphics::DrawSpriteSetup(float *pPositions, float *pTextureCoords) {
    
    
    //gQuadBufferPosition = Graphics::BufferArrayGenerate(sizeof(float) * 4);
    //gQuadBufferTextureCoord = Graphics::BufferArrayGenerate(sizeof(float) * 4);
    
    FBuffer *aBufferPositions = gBufferCache.GetArrayBuffer(sizeof(float) * 8);
    if (aBufferPositions == NULL) { return false; }
    if (aBufferPositions->mBindIndex == -1) { return false; }
    
    FBuffer *aBufferTextureCoords = gBufferCache.GetArrayBuffer(sizeof(float) * 8);
    if (aBufferTextureCoords == NULL) { return false; }
    if (aBufferTextureCoords->mBindIndex == -1) { return false; }
    
    BufferArrayWrite(aBufferPositions, pPositions, sizeof(float) * 8);
    ArrayBufferPositions(aBufferPositions);
    
    BufferArrayWrite(aBufferTextureCoords, pTextureCoords, sizeof(float) * 8);
    ArrayBufferTextureCoords(aBufferTextureCoords);

    return true;
}

void Graphics::DrawSprite(float *pPositions, float *pTextureCoords, FTexture *pTexture) {
    
    if (pTexture == NULL || pTexture->mBindIndex == -1) {
        return;
    }
    
    if (DrawSpriteSetup(pPositions, pTextureCoords)) {
        TextureBind(pTexture);
        UniformBind();
        //
        DrawTriangleStrips(4);
    }
}

void Graphics::DrawSprite(float pX, float pY, float pScaleX, float pScaleY, float pScaleZ, float pRotation, float *pPositions, float *pTextureCoords, FTexture *pTexture) {
    FMatrix aHold = cMatrixModelView;
    FMatrix aModelView = cMatrixModelView;
    
    if (pX != 0.0f || pY != 0.0f) {
        aModelView.Translate(pX, pY);
    }
    if (pScaleX != 1.0f || pScaleY != 1.0f || pScaleZ != 1.0f) {
        aModelView.Scale(pScaleX, pScaleY, pScaleZ);
    }
    if (pRotation != 0.0f) {
        aModelView.Rotate(pRotation);
    }
    MatrixModelViewSet(aModelView);
    
    DrawSprite(pPositions, pTextureCoords, pTexture);
    
    MatrixModelViewSet(aHold);
}

void Graphics::DrawSpriteTriangle(float pX, float pY, float pScaleX, float pScaleY, float pScaleZ, float pRotation, float *pPositions, float *pTextureCoords, FTexture *pTexture) {
    
    FMatrix aHold = cMatrixModelView;
    FMatrix aModelView = cMatrixModelView;
    aModelView.Translate(pX, pY);
    aModelView.Scale(pScaleX, pScaleY, pScaleZ);
    aModelView.Rotate(pRotation);
    MatrixModelViewSet(aModelView);
    
    
    DrawSpriteTriangle(pPositions, pTextureCoords, pTexture);
    
    MatrixModelViewSet(aHold);
}

bool Graphics::DrawSpriteTriangleSetup(float *pPositions, float *pTextureCoords) {
    
    
    FBuffer *aBufferPositions = gBufferCache.GetArrayBuffer(sizeof(float) * 6);
    if (aBufferPositions == NULL) { return false; }
    if (aBufferPositions->mBindIndex == -1) { return false; }
    
    FBuffer *aBufferTextureCoords = gBufferCache.GetArrayBuffer(sizeof(float) * 6);
    if (aBufferTextureCoords == NULL) { return false; }
    if (aBufferTextureCoords->mBindIndex == -1) { return false; }
    
    BufferArrayWrite(aBufferPositions, pPositions, sizeof(float) * 6);
    ArrayBufferPositions(aBufferPositions);
    
    BufferArrayWrite(aBufferTextureCoords, pTextureCoords, sizeof(float) * 6);
    ArrayBufferTextureCoords(aBufferTextureCoords);
    
    return true;
    
    /*
    cVertexCache.Get(sizeof(float) * 6);
    if (cVertexCache.mResult.mSuccess) {
        FBuffer *aPositionsBuffer = cVertexCache.mResult.mBuffer;
        int aPositionsBufferOffset = cVertexCache.mResult.mBufferOffset;
        BufferArrayWrite(aPositionsBuffer, pPositions, aPositionsBufferOffset, sizeof(float) * 6);
        ArrayBufferPositions(aPositionsBuffer, aPositionsBufferOffset);
    }
    //
    cVertexCache.Get(sizeof(float) * 6);
    if (cVertexCache.mResult.mSuccess) {
        FBuffer *aTextureCoordsBuffer = cVertexCache.mResult.mBuffer;
        int aTextureCoordsBufferOffset = cVertexCache.mResult.mBufferOffset;
        BufferArrayWrite(aTextureCoordsBuffer, pTextureCoords, aTextureCoordsBufferOffset, sizeof(float) * 6);
        ArrayBufferTextureCoords(aTextureCoordsBuffer, aTextureCoordsBufferOffset);
    }
    */
}

void Graphics::DrawSpriteTriangle(float *pPositions, float *pTextureCoords, FTexture *pTexture) {
    
    if (pTexture == NULL || pTexture->mBindIndex == -1) {
        return;
    }
    
    if (DrawSpriteTriangleSetup(pPositions, pTextureCoords)) {
        TextureBind(pTexture);
        UniformBind();
        //
        DrawTriangleStrips(3);
    }
}

void Graphics::DrawCurrentTile() {
    PipelineStateSetSpriteNoBlending();
    if (DrawSpriteSetup(cTileRect.mPositions, cTileRect.mTextureCoords)) {
        MatrixProjectionResetOrtho();
        MatrixModelViewReset();
        UniformBind();
        DrawTriangleStrips(4);
    }
    
    /*
     cTileRect.SetRect(0.0f, 0.0f, gDeviceWidth2, gDeviceHeight2);
     UniformBind();
     DrawSpriteSetup(cTileRect.mVertex, cTileRect.mTextureCoord);
     DrawTriangleStrips(4);
     
     
     cTileRect.SetRect(gDeviceWidth2, 0.0f, gDeviceWidth2, gDeviceHeight2);
     UniformBind();
     DrawSpriteSetup(cTileRect.mVertex, cTileRect.mTextureCoord);
     DrawTriangleStrips(4);
     
     cTileRect.SetRect(0.0f, gDeviceHeight2, gDeviceWidth2, gDeviceHeight2);
     UniformBind();
     DrawSpriteSetup(cTileRect.mVertex, cTileRect.mTextureCoord);
     DrawTriangleStrips(4);
     
     cTileRect.SetRect(gDeviceWidth2, gDeviceHeight2, gDeviceWidth2, gDeviceHeight2);
     UniformBind();
     DrawSpriteSetup(cTileRect.mVertex, cTileRect.mTextureCoord);
     DrawTriangleStrips(4);
     */
    
}

void Graphics::Ortho2D(float pLeft, float pRight, float pBottom, float pTop) {
    //glOrthof(pLeft, pRight, pBottom, pTop, -1024.0f, 1024.0f);
    //glOrthof
    
}

void Graphics::Ortho2D() {
    //Ortho2D(0.0f, 0.0f, gDeviceWidth, gDeviceHeight);
    
}



void Graphics::PipelineStateSetShape2DNoBlending() {
    if (gOpenGLEngine) {
        BlendDisable();
        gOpenGLEngine->UseProgramShape2D();
    }
}

void Graphics::PipelineStateSetShape2DAlphaBlending() {
    if (gOpenGLEngine) {
        BlendEnable();
        BlendSetAlpha();
        gOpenGLEngine->UseProgramShape2D();
    }
}

void Graphics::PipelineStateSetShape2DAdditiveBlending() {
    if (gOpenGLEngine) {
        BlendEnable();
        BlendSetAdditive();
        gOpenGLEngine->UseProgramShape2D();
    }
}

void Graphics::PipelineStateSetShape3DNoBlending() {
    if (gOpenGLEngine) {
        BlendDisable();
        gOpenGLEngine->UseProgramShape3D();
    }
}

void Graphics::PipelineStateSetShape3DAlphaBlending() {
    if (gOpenGLEngine) {
        BlendEnable();
        BlendSetAlpha();
        gOpenGLEngine->UseProgramShape3D();
    }
}

void Graphics::PipelineStateSetShape3DAdditiveBlending() {
    if (gOpenGLEngine) {
        BlendEnable();
        BlendSetAdditive();
        gOpenGLEngine->UseProgramShape3D();
    }
}

void Graphics::PipelineStateSetSpriteNoBlending() {
    if (gOpenGLEngine) {
        BlendDisable();
        gOpenGLEngine->UseProgramSprite();
    }
}

void Graphics::PipelineStateSetSpriteAlphaBlending() {
    if (gOpenGLEngine) {
        BlendEnable();
        BlendSetAlpha();
        gOpenGLEngine->UseProgramSprite();
    }
}

void Graphics::PipelineStateSetSpriteAdditiveBlending() {
    if (gOpenGLEngine) {
        BlendEnable();
        BlendSetAdditive();
        gOpenGLEngine->UseProgramSprite();
    }
}

void Graphics::PipelineStateSetSpritePremultipliedBlending() {
    if (gOpenGLEngine) {
        BlendEnable();
        BlendSetPremultiplied();
        gOpenGLEngine->UseProgramSprite();
    }
}

void Graphics::PipelineStateSetSpriteWhiteBlending() {
    if (gOpenGLEngine) {
        BlendEnable();
        BlendSetAlpha();
        gOpenGLEngine->UseProgramSpriteWhite();
    }
}


void Graphics::PipelineStateSetShapeNodeNoBlending() {
    if (gOpenGLEngine) {
        BlendDisable();
        gOpenGLEngine->UseProgramShapeNode();
    }
}

void Graphics::PipelineStateSetShapeNodeAlphaBlending() {
    if (gOpenGLEngine) {
        BlendEnable();
        BlendSetAlpha();
        gOpenGLEngine->UseProgramShapeNode();
    }
}

void Graphics::PipelineStateSetShapeNodeAdditiveBlending() {
    if (gOpenGLEngine) {
        BlendEnable();
        BlendSetAdditive();
        gOpenGLEngine->UseProgramShapeNode();
    }
}

void Graphics::PipelineStateSetShapeNodeSpriteNoBlending() {
    if (gOpenGLEngine) {
        BlendDisable();
        gOpenGLEngine->UseProgramShapeNodeSprite();
    }
}

void Graphics::PipelineStateSetShapeNodeSpriteAlphaBlending() {
    if (gOpenGLEngine) {
        BlendEnable();
        BlendSetAlpha();
        gOpenGLEngine->UseProgramShapeNodeSprite();
    }
}

void Graphics::PipelineStateSetShapeNodeSpriteAdditiveBlending() {
    if (gOpenGLEngine) {
        BlendEnable();
        BlendSetAdditive();
        gOpenGLEngine->UseProgramShapeNodeSprite();
    }
}

void Graphics::PipelineStateSetShapeNodeSpritePremultipliedBlending() {
    if (gOpenGLEngine) {
        BlendEnable();
        BlendSetPremultiplied();
        gOpenGLEngine->UseProgramShapeNodeSprite();
    }
}

void Graphics::PipelineStateSetSimpleModelNoBlending() {
    if (gOpenGLEngine) {
        BlendDisable();
        gOpenGLEngine->UseProgramSimpleModel();
    }
}

void Graphics::PipelineStateSetSimpleModelAlphaBlending() {
    if (gOpenGLEngine) {
        BlendEnable();
        BlendSetAlpha();
        gOpenGLEngine->UseProgramSimpleModel();
    }
}

void Graphics::PipelineStateSetSimpleModelAdditiveBlending() {
    if (gOpenGLEngine) {
        BlendEnable();
        BlendSetAdditive();
        gOpenGLEngine->UseProgramSimpleModel();
    }
}

void Graphics::PipelineStateSetSimpleModelPremultipliedBlending() {
    if (gOpenGLEngine) {
        BlendEnable();
        BlendSetPremultiplied();
        gOpenGLEngine->UseProgramSimpleModel();
    }
}

void Graphics::PipelineStateSetSimpleModelIndexedNoBlending() {
    if (gOpenGLEngine) {
        BlendDisable();
        gOpenGLEngine->UseProgramSimpleModelIndexed();
    }
}

void Graphics::PipelineStateSetSimpleModelIndexedAlphaBlending() {
    if (gOpenGLEngine) {
        BlendEnable();
        BlendSetAlpha();
        gOpenGLEngine->UseProgramSimpleModelIndexed();
    }
}



void Graphics::PipelineStateSetModelIndexedNoBlending() {
    if (gOpenGLEngine) {
        BlendDisable();
        gOpenGLEngine->UseProgramModelIndexed();
    }
}

void Graphics::PipelineStateSetModelIndexedAlphaBlending() {
    if (gOpenGLEngine) {
        BlendEnable();
        BlendSetAlpha();
        gOpenGLEngine->UseProgramModelIndexed();
    }
}


void Graphics::PipelineStateSetModelIndexedLightedAmbientNoBlending() {
    if (gOpenGLEngine) {
        BlendDisable();
        gOpenGLEngine->UseProgramModelIndexedAmbient();
    }
}

void Graphics::PipelineStateSetModelIndexedLightedAmbientAlphaBlending() {
    if (gOpenGLEngine) {
        BlendEnable();
        BlendSetAlpha();
        gOpenGLEngine->UseProgramModelIndexedAmbient();
    }
}

void Graphics::PipelineStateSetModelIndexedLightedDiffuseNoBlending() {
    if (gOpenGLEngine) {
        BlendDisable();
        gOpenGLEngine->UseProgramModelIndexedDiffuse();
    }
}

void Graphics::PipelineStateSetModelIndexedLightedDiffuseAlphaBlending() {
    if (gOpenGLEngine) {
        BlendEnable();
        BlendSetAlpha();
        gOpenGLEngine->UseProgramModelIndexedDiffuse();
    }
}



void Graphics::PipelineStateSetModelIndexedLightedPhongNoBlending() {
    if (gOpenGLEngine) {
        BlendDisable();
        gOpenGLEngine->UseProgramModelIndexedPhong();
    }
}

void Graphics::PipelineStateSetModelIndexedLightedPhongAlphaBlending() {
    if (gOpenGLEngine) {
        BlendEnable();
        BlendSetAlpha();
        gOpenGLEngine->UseProgramModelIndexedPhong();
    }
}

void Graphics::PipelineStateSetModelIndexedLightedPhongOverlayNoBlending() {
    if (gOpenGLEngine) {
        BlendDisable();
        gOpenGLEngine->UseProgramModelIndexedPhongOverlay();
    }
}

void Graphics::PipelineStateSetModelIndexedLightedPhongOverlayAlphaBlending() {
    if (gOpenGLEngine) {
        BlendEnable();
        BlendSetAlpha();
        gOpenGLEngine->UseProgramModelIndexedPhongOverlay();
    }
}

void Graphics::PipelineStateSetModelIndexedLightedSimpleSpotlightNoBlending() {
    if (gOpenGLEngine) {
        BlendDisable();
        gOpenGLEngine->UseProgramModelIndexedSimpleSpotlight();
    }
}

void Graphics::PipelineStateSetModelIndexedLightedSimpleSpotlightAlphaBlending() {
    if (gOpenGLEngine) {
        BlendEnable();
        BlendSetAlpha();
        gOpenGLEngine->UseProgramModelIndexedSimpleSpotlight();
    }
    
}















int Graphics::RenderPass() {
    return cCurrentRenderPass;
}

void Graphics::RenderPassBegin(int pRenderPass, bool pClearColor, bool pClearDepth) {
    cCurrentRenderPass = pRenderPass;
    
    if (pClearDepth) {
        Graphics::DepthClear();
    }
    if (pClearColor) {
        //Graphics::Clear(0.025f, 0.025f, 0.065f);
        Graphics::Clear(0.65f, 0.675f, 0.965f);
        
    }
    
    //[gMetalEngine startRenderPass:pRenderPass clearingColor: pClearColor clearingDepth: pClearDepth];
    
}

void Graphics::SetShaderProgram(ShaderProgram *pShaderProgram) {
    cShaderProgram = pShaderProgram;
}

void Graphics::BlendEnable() {
    glEnable(GL_BLEND);
}

void Graphics::BlendDisable() {
    glDisable(GL_BLEND);
}

void Graphics::BlendSetAlpha() {
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
}

void Graphics::BlendSetAdditive() {
    glBlendFunc(GL_SRC_ALPHA, GL_ONE);
}

void Graphics::BlendSetPremultiplied() {
    glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
}

",16318,True,3144.314209815705,median
"/*
 *  Copyright (c) 2016, The OpenThread Authors.
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are met:
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. Neither the name of the copyright holder nor the
 *     names of its contributors may be used to endorse or promote products
 *     derived from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS""
 *  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 *  IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 *  ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
 *  LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 *  INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *  CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 *  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 *  POSSIBILITY OF SUCH DAMAGE.
 */

/**
 * @file
 *   This file includes definitions for MLE functionality required by the Thread Child, Router, and Leader roles.
 */

#ifndef MLE_HPP_
#define MLE_HPP_

#include ""openthread-core-config.h""

#include ""common/encoding.hpp""
#include ""common/locator.hpp""
#include ""common/non_copyable.hpp""
#include ""common/timer.hpp""
#include ""mac/mac.hpp""
#include ""meshcop/joiner_router.hpp""
#include ""meshcop/meshcop.hpp""
#include ""net/udp6.hpp""
#include ""thread/link_metrics.hpp""
#include ""thread/link_metrics_tlvs.hpp""
#include ""thread/mle_tlvs.hpp""
#include ""thread/mle_types.hpp""
#include ""thread/neighbor_table.hpp""
#include ""thread/topology.hpp""

namespace ot {

/**
 * @addtogroup core-mle MLE
 *
 * @brief
 *   This module includes definitions for the MLE protocol.
 *
 * @{
 *
 * @defgroup core-mle-core Core
 * @defgroup core-mle-router Router
 * @defgroup core-mle-tlvs TLVs
 *
 * @}
 */

/**
 * @namespace ot::Mle
 *
 * @brief
 *   This namespace includes definitions for the MLE protocol.
 */

namespace Mle {

/**
 * @addtogroup core-mle-core
 *
 * @brief
 *   This module includes definitions for MLE functionality required by the Thread Child, Router, and Leader roles.
 *
 * @{
 *
 */

/**
 * This class implements MLE functionality required by the Thread EndDevices, Router, and Leader roles.
 *
 */
class Mle : public InstanceLocator, private NonCopyable
{
    friend class DiscoverScanner;
    friend class ot::Notifier;
#if OPENTHREAD_CONFIG_MLE_LINK_METRICS_ENABLE
    friend class ot::LinkMetrics;
#endif

public:
    /**
     * This constructor initializes the MLE object.
     *
     * @param[in]  aInstance     A reference to the OpenThread instance.
     *
     */
    explicit Mle(Instance &aInstance);

    /**
     * This method enables MLE.
     *
     * @retval kErrorNone     Successfully enabled MLE.
     * @retval kErrorAlready  MLE was already enabled.
     *
     */
    Error Enable(void);

    /**
     * This method disables MLE.
     *
     * @retval kErrorNone     Successfully disabled MLE.
     *
     */
    Error Disable(void);

    /**
     * This method starts the MLE protocol operation.
     *
     * @param[in]  aAnnounceAttach True if attach on the announced thread network with newer active timestamp,
     *                             or False if not.
     *
     * @retval kErrorNone     Successfully started the protocol operation.
     * @retval kErrorAlready  The protocol operation was already started.
     *
     */
    Error Start(bool aAnnounceAttach);

    /**
     * This method stops the MLE protocol operation.
     *
     * @param[in]  aClearNetworkDatasets  True to clear network datasets, False not.
     *
     */
    void Stop(bool aClearNetworkDatasets);

    /**
     * This method restores network information from non-volatile memory.
     *
     * @retval kErrorNone      Successfully restore the network information.
     * @retval kErrorNotFound  There is no valid network information stored in non-volatile memory.
     *
     */
    Error Restore(void);

    /**
     * This method stores network information into non-volatile memory.
     *
     * @retval kErrorNone      Successfully store the network information.
     * @retval kErrorNoBufs    Could not store the network information due to insufficient memory space.
     *
     */
    Error Store(void);

    /**
     * This method generates an MLE Announce message.
     *
     * @param[in]  aChannel        The channel to use when transmitting.
     * @param[in]  aOrphanAnnounce To indicate if MLE Announce is sent from an orphan end device.
     *
     */
    void SendAnnounce(uint8_t aChannel, bool aOrphanAnnounce);

    /**
     * This method causes the Thread interface to detach from the Thread network.
     *
     * @retval kErrorNone          Successfully detached from the Thread network.
     * @retval kErrorInvalidState  MLE is Disabled.
     *
     */
    Error BecomeDetached(void);

    /**
     * This method causes the Thread interface to attempt an MLE attach.
     *
     * @param[in]  aMode  Indicates what partitions to attach to.
     *
     * @retval kErrorNone          Successfully began the attach process.
     * @retval kErrorInvalidState  MLE is Disabled.
     * @retval kErrorBusy          An attach process is in progress.
     *
     */
    Error BecomeChild(AttachMode aMode);

    /**
     * This method indicates whether or not the Thread device is attached to a Thread network.
     *
     * @retval TRUE   Attached to a Thread network.
     * @retval FALSE  Not attached to a Thread network.
     *
     */
    bool IsAttached(void) const;

    /**
     * This method indicates whether device is currently attaching or not.
     *
     * Note that an already attached device may also be in attaching state. Examples of this include a leader/router
     * trying to attach to a better partition, or a child trying to find a better parent (when feature
     * `OPENTHREAD_CONFIG_PARENT_SEARCH_ENABLE` is enabled).
     *
     * @retval TRUE   Device is currently trying to attach.
     * @retval FALSE  Device is not in middle of attach process.
     *
     */
    bool IsAttaching(void) const { return (mAttachState != kAttachStateIdle); }

    /**
     * This method returns the current Thread device role.
     *
     * @returns The current Thread device role.
     *
     */
    DeviceRole GetRole(void) const { return mRole; }

    /**
     * This method indicates whether device role is disabled.
     *
     * @retval TRUE   Device role is disabled.
     * @retval FALSE  Device role is not disabled.
     *
     */
    bool IsDisabled(void) const { return (mRole == kRoleDisabled); }

    /**
     * This method indicates whether device role is detached.
     *
     * @retval TRUE   Device role is detached.
     * @retval FALSE  Device role is not detached.
     *
     */
    bool IsDetached(void) const { return (mRole == kRoleDetached); }

    /**
     * This method indicates whether device role is child.
     *
     * @retval TRUE   Device role is child.
     * @retval FALSE  Device role is not child.
     *
     */
    bool IsChild(void) const { return (mRole == kRoleChild); }

    /**
     * This method indicates whether device role is router.
     *
     * @retval TRUE   Device role is router.
     * @retval FALSE  Device role is not router.
     *
     */
    bool IsRouter(void) const { return (mRole == kRoleRouter); }

    /**
     * This method indicates whether device role is leader.
     *
     * @retval TRUE   Device role is leader.
     * @retval FALSE  Device role is not leader.
     *
     */
    bool IsLeader(void) const { return (mRole == kRoleLeader); }

    /**
     * This method indicates whether device role is either router or leader.
     *
     * @retval TRUE   Device role is either router or leader.
     * @retval FALSE  Device role is neither router nor leader.
     *
     */
    bool IsRouterOrLeader(void) const;

    /**
     * This method returns the Device Mode as reported in the Mode TLV.
     *
     * @returns The Device Mode as reported in the Mode TLV.
     *
     */
    DeviceMode GetDeviceMode(void) const { return mDeviceMode; }

    /**
     * This method sets the Device Mode as reported in the Mode TLV.
     *
     * @param[in]  aDeviceMode  The device mode to set.
     *
     * @retval kErrorNone         Successfully set the Mode TLV.
     * @retval kErrorInvalidArgs  The mode combination specified in @p aMode is invalid.
     *
     */
    Error SetDeviceMode(DeviceMode aDeviceMode);

    /**
     * This method indicates whether or not the device is rx-on-when-idle.
     *
     * @returns TRUE if rx-on-when-idle, FALSE otherwise.
     *
     */
    bool IsRxOnWhenIdle(void) const { return mDeviceMode.IsRxOnWhenIdle(); }

    /**
     * This method indicates whether or not the device is a Full Thread Device.
     *
     * @returns TRUE if a Full Thread Device, FALSE otherwise.
     *
     */
    bool IsFullThreadDevice(void) const { return mDeviceMode.IsFullThreadDevice(); }

    /**
     * This method indicates whether or not the device requests Full Network Data.
     *
     * @returns TRUE if requests Full Network Data, FALSE otherwise.
     *
     */
    bool IsFullNetworkData(void) const { return mDeviceMode.IsFullNetworkData(); }

    /**
     * This method indicates whether or not the device is a Minimal End Device.
     *
     * @returns TRUE if the device is a Minimal End Device, FALSE otherwise.
     *
     */
    bool IsMinimalEndDevice(void) const { return mDeviceMode.IsMinimalEndDevice(); }

    /**
     * This method returns a pointer to the Mesh Local Prefix.
     *
     * @returns A reference to the Mesh Local Prefix.
     *
     */
    const MeshLocalPrefix &GetMeshLocalPrefix(void) const
    {
        return static_cast<const MeshLocalPrefix &>(mMeshLocal16.GetAddress().GetPrefix());
    }

    /**
     * This method sets the Mesh Local Prefix.
     *
     * @param[in]  aMeshLocalPrefix  A reference to the Mesh Local Prefix.
     *
     */
    void SetMeshLocalPrefix(const MeshLocalPrefix &aMeshLocalPrefix);

    /**
     * This method applies the Mesh Local Prefix.
     *
     */
    void ApplyMeshLocalPrefix(void);

    /**
     * This method returns a reference to the Thread link-local address.
     *
     * The Thread link local address is derived using IEEE802.15.4 Extended Address as Interface Identifier.
     *
     * @returns A reference to the Thread link local address.
     *
     */
    const Ip6::Address &GetLinkLocalAddress(void) const { return mLinkLocal64.GetAddress(); }

    /**
     * This method updates the link local address.
     *
     * Call this method when the IEEE 802.15.4 Extended Address has changed.
     *
     */
    void UpdateLinkLocalAddress(void);

    /**
     * This method returns a reference to the link-local all Thread nodes multicast address.
     *
     * @returns A reference to the link-local all Thread nodes multicast address.
     *
     */
    const Ip6::Address &GetLinkLocalAllThreadNodesAddress(void) const { return mLinkLocalAllThreadNodes.GetAddress(); }

    /**
     * This method returns a reference to the realm-local all Thread nodes multicast address.
     *
     * @returns A reference to the realm-local all Thread nodes multicast address.
     *
     */
    const Ip6::Address &GetRealmLocalAllThreadNodesAddress(void) const
    {
        return mRealmLocalAllThreadNodes.GetAddress();
    }

    /**
     * This method gets the parent when operating in End Device mode.
     *
     * @returns A reference to the parent.
     *
     */
    Router &GetParent(void) { return mParent; }

    /**
     * This method get the parent candidate.
     *
     * The parent candidate is valid when attempting to attach to a new parent.
     *
     */
    Router &GetParentCandidate(void) { return mParentCandidate; }

    /**
     * This method indicates whether or not an IPv6 address is an RLOC.
     *
     * @retval TRUE   If @p aAddress is an RLOC.
     * @retval FALSE  If @p aAddress is not an RLOC.
     *
     */
    bool IsRoutingLocator(const Ip6::Address &aAddress) const;

    /**
     * This method indicates whether or not an IPv6 address is an ALOC.
     *
     * @retval TRUE   If @p aAddress is an ALOC.
     * @retval FALSE  If @p aAddress is not an ALOC.
     *
     */
    bool IsAnycastLocator(const Ip6::Address &aAddress) const;

    /**
     * This method indicates whether or not an IPv6 address is a Mesh Local Address.
     *
     * @retval TRUE   If @p aAddress is a Mesh Local Address.
     * @retval FALSE  If @p aAddress is not a Mesh Local Address.
     *
     */
    bool IsMeshLocalAddress(const Ip6::Address &aAddress) const;

    /**
     * This method returns the MLE Timeout value.
     *
     * @returns The MLE Timeout value in seconds.
     *
     */
    uint32_t GetTimeout(void) const { return mTimeout; }

    /**
     * This method sets the MLE Timeout value.
     *
     * @param[in]  aTimeout  The Timeout value in seconds.
     *
     */
    void SetTimeout(uint32_t aTimeout);

    /**
     * This method returns the RLOC16 assigned to the Thread interface.
     *
     * @returns The RLOC16 assigned to the Thread interface.
     *
     */
    uint16_t GetRloc16(void) const;

    /**
     * This method returns a reference to the RLOC assigned to the Thread interface.
     *
     * @returns A reference to the RLOC assigned to the Thread interface.
     *
     */
    const Ip6::Address &GetMeshLocal16(void) const { return mMeshLocal16.GetAddress(); }

    /**
     * This method returns a reference to the ML-EID assigned to the Thread interface.
     *
     * @returns A reference to the ML-EID assigned to the Thread interface.
     *
     */
    const Ip6::Address &GetMeshLocal64(void) const { return mMeshLocal64.GetAddress(); }

    /**
     * This method returns the Router ID of the Leader.
     *
     * @returns The Router ID of the Leader.
     *
     */
    uint8_t GetLeaderId(void) const { return mLeaderData.GetLeaderRouterId(); }

    /**
     * This method retrieves the Leader's RLOC.
     *
     * @param[out]  aAddress  A reference to the Leader's RLOC.
     *
     * @retval kErrorNone      Successfully retrieved the Leader's RLOC.
     * @retval kErrorDetached  The Thread interface is not currently attached to a Thread Partition.
     *
     */
    Error GetLeaderAddress(Ip6::Address &aAddress) const;

    /**
     * This method retrieves the Leader's ALOC.
     *
     * @param[out]  aAddress  A reference to the Leader's ALOC.
     *
     * @retval kErrorNone      Successfully retrieved the Leader's ALOC.
     * @retval kErrorDetached  The Thread interface is not currently attached to a Thread Partition.
     *
     */
    Error GetLeaderAloc(Ip6::Address &aAddress) const { return GetLocatorAddress(aAddress, kAloc16Leader); }

    /**
     * This method computes the Commissioner's ALOC.
     *
     * @param[out]  aAddress        A reference to the Commissioner's ALOC.
     * @param[in]   aSessionId      Commissioner session id.
     *
     * @retval kErrorNone      Successfully retrieved the Commissioner's ALOC.
     * @retval kErrorDetached  The Thread interface is not currently attached to a Thread Partition.
     *
     */
    Error GetCommissionerAloc(Ip6::Address &aAddress, uint16_t aSessionId) const
    {
        return GetLocatorAddress(aAddress, CommissionerAloc16FromId(aSessionId));
    }

    /**
     * This method retrieves the Service ALOC for given Service ID.
     *
     * @param[in]   aServiceId Service ID to get ALOC for.
     * @param[out]  aAddress   A reference to the Service ALOC.
     *
     * @retval kErrorNone      Successfully retrieved the Service ALOC.
     * @retval kErrorDetached  The Thread interface is not currently attached to a Thread Partition.
     *
     */
    Error GetServiceAloc(uint8_t aServiceId, Ip6::Address &aAddress) const;

    /**
     * This method returns the most recently received Leader Data.
     *
     * @returns  A reference to the most recently received Leader Data.
     *
     */
    const LeaderData &GetLeaderData(void);

    /**
     * This method derives the Child ID from a given RLOC16.
     *
     * @param[in]  aRloc16  The RLOC16 value.
     *
     * @returns The Child ID portion of an RLOC16.
     *
     */
    static uint16_t ChildIdFromRloc16(uint16_t aRloc16) { return aRloc16 & kMaxChildId; }

    /**
     * This method derives the Router ID portion from a given RLOC16.
     *
     * @param[in]  aRloc16  The RLOC16 value.
     *
     * @returns The Router ID portion of an RLOC16.
     *
     */
    static uint8_t RouterIdFromRloc16(uint16_t aRloc16) { return aRloc16 >> kRouterIdOffset; }

    /**
     * This method returns whether the two RLOC16 have the same Router ID.
     *
     * @param[in]  aRloc16A  The first RLOC16 value.
     * @param[in]  aRloc16B  The second RLOC16 value.
     *
     * @returns true if the two RLOC16 have the same Router ID, false otherwise.
     *
     */
    static bool RouterIdMatch(uint16_t aRloc16A, uint16_t aRloc16B)
    {
        return RouterIdFromRloc16(aRloc16A) == RouterIdFromRloc16(aRloc16B);
    }

    /**
     * This method returns the Service ID corresponding to a Service ALOC16.
     *
     * @param[in]  aAloc16  The Servicer ALOC16 value.
     *
     * @returns The Service ID corresponding to given ALOC16.
     *
     */
    static uint8_t ServiceIdFromAloc(uint16_t aAloc16) { return static_cast<uint8_t>(aAloc16 - kAloc16ServiceStart); }

    /**
     * This method returns the Service Aloc corresponding to a Service ID.
     *
     * @param[in]  aServiceId  The Service ID value.
     *
     * @returns The Service ALOC16 corresponding to given ID.
     *
     */
    static uint16_t ServiceAlocFromId(uint8_t aServiceId)
    {
        return static_cast<uint16_t>(aServiceId + kAloc16ServiceStart);
    }

    /**
     * This method returns the Commissioner Aloc corresponding to a Commissioner Session ID.
     *
     * @param[in]  aSessionId   The Commissioner Session ID value.
     *
     * @returns The Commissioner ALOC16 corresponding to given ID.
     *
     */
    static uint16_t CommissionerAloc16FromId(uint16_t aSessionId)
    {
        return static_cast<uint16_t>((aSessionId & kAloc16CommissionerMask) + kAloc16CommissionerStart);
    }

    /**
     * This method derives RLOC16 from a given Router ID.
     *
     * @param[in]  aRouterId  The Router ID value.
     *
     * @returns The RLOC16 corresponding to the given Router ID.
     *
     */
    static uint16_t Rloc16FromRouterId(uint8_t aRouterId)
    {
        return static_cast<uint16_t>(aRouterId << kRouterIdOffset);
    }

    /**
     * This method indicates whether or not @p aRloc16 refers to an active router.
     *
     * @param[in]  aRloc16  The RLOC16 value.
     *
     * @retval TRUE   If @p aRloc16 refers to an active router.
     * @retval FALSE  If @p aRloc16 does not refer to an active router.
     *
     */
    static bool IsActiveRouter(uint16_t aRloc16) { return ChildIdFromRloc16(aRloc16) == 0; }

    /**
     * This method returns a reference to the send queue.
     *
     * @returns A reference to the send queue.
     *
     */
    const MessageQueue &GetMessageQueue(void) const { return mDelayedResponses; }

    /**
     * This method frees multicast MLE Data Response from Delayed Message Queue if any.
     *
     */
    void RemoveDelayedDataResponseMessage(void);

    /**
     * This method converts a device role into a human-readable string.
     *
     */
    static const char *RoleToString(DeviceRole aRole);

    /**
     * This method gets the MLE counters.
     *
     * @returns A reference to the MLE counters.
     *
     */
    const otMleCounters &GetCounters(void) const { return mCounters; }

    /**
     * This method resets the MLE counters.
     *
     */
    void ResetCounters(void) { memset(&mCounters, 0, sizeof(mCounters)); }

    /**
     * This function registers the client callback that is called when processing an MLE Parent Response message.
     *
     * @param[in]  aCallback A pointer to a function that is called to deliver MLE Parent Response data.
     * @param[in]  aContext  A pointer to application-specific context.
     *
     */
    void RegisterParentResponseStatsCallback(otThreadParentResponseCallback aCallback, void *aContext);

    /**
     * This method requests MLE layer to prepare and send a shorter version of Child ID Request message by only
     * including the mesh-local IPv6 address in the Address Registration TLV.
     *
     * This method should be called when a previous MLE Child ID Request message would require fragmentation at 6LoWPAN
     * layer.
     *
     */
    void RequestShorterChildIdRequest(void);

    /**
     * This method gets the RLOC or ALOC of a given RLOC16 or ALOC16.
     *
     * @param[out]  aAddress  A reference to the RLOC or ALOC.
     * @param[in]   aLocator  RLOC16 or ALOC16.
     *
     * @retval kErrorNone      If got the RLOC or ALOC successfully.
     * @retval kErrorDetached  If device is detached.
     *
     */
    Error GetLocatorAddress(Ip6::Address &aAddress, uint16_t aLocator) const;

    /**
     * This method schedules a Child Update Request.
     *
     */
    void ScheduleChildUpdateRequest(void);

    /*
     * This method indicates whether or not the device has restored the network information from
     * non-volatile settings after boot.
     *
     * @retval true  Successfully restored the network information.
     * @retval false No valid network information was found.
     *
     */
    bool HasRestored(void) const { return mHasRestored; }

protected:
    /**
     * MLE Command Types.
     *
     */
    enum Command : uint8_t
    {
        kCommandLinkRequest                   = 0,  ///< Link Request
        kCommandLinkAccept                    = 1,  ///< Link Accept
        kCommandLinkAcceptAndRequest          = 2,  ///< Link Accept and Reject
        kCommandLinkReject                    = 3,  ///< Link Reject
        kCommandAdvertisement                 = 4,  ///< Advertisement
        kCommandUpdate                        = 5,  ///< Update
        kCommandUpdateRequest                 = 6,  ///< Update Request
        kCommandDataRequest                   = 7,  ///< Data Request
        kCommandDataResponse                  = 8,  ///< Data Response
        kCommandParentRequest                 = 9,  ///< Parent Request
        kCommandParentResponse                = 10, ///< Parent Response
        kCommandChildIdRequest                = 11, ///< Child ID Request
        kCommandChildIdResponse               = 12, ///< Child ID Response
        kCommandChildUpdateRequest            = 13, ///< Child Update Request
        kCommandChildUpdateResponse           = 14, ///< Child Update Response
        kCommandAnnounce                      = 15, ///< Announce
        kCommandDiscoveryRequest              = 16, ///< Discovery Request
        kCommandDiscoveryResponse             = 17, ///< Discovery Response
        kCommandLinkMetricsManagementRequest  = 18, ///< Link Metrics Management Request
        kCommandLinkMetricsManagementResponse = 19, ///< Link Metrics Management Response
        kCommandLinkProbe                     = 20, ///< Link Probe
        kCommandTimeSync = 99, ///< Time Sync (applicable when OPENTHREAD_CONFIG_TIME_SYNC_ENABLE enabled)
    };

    /**
     * States during attach (when searching for a parent).
     *
     */
    enum AttachState
    {
        kAttachStateIdle,                ///< Not currently searching for a parent.
        kAttachStateProcessAnnounce,     ///< Waiting to process a received Announce (to switch channel/pan-id).
        kAttachStateStart,               ///< Starting to look for a parent.
        kAttachStateParentRequestRouter, ///< Searching for a Router to attach to.
        kAttachStateParentRequestReed,   ///< Searching for Routers or REEDs to attach to.
        kAttachStateAnnounce,            ///< Send Announce messages
        kAttachStateChildIdRequest,      ///< Sending a Child ID Request message.
    };

    /**
     * States when reattaching network using stored dataset
     *
     */
    enum ReattachState
    {
        kReattachStop    = 0, ///< Reattach process is disabled or finished
        kReattachStart   = 1, ///< Start reattach process
        kReattachActive  = 2, ///< Reattach using stored Active Dataset
        kReattachPending = 3, ///< Reattach using stored Pending Dataset
    };

    enum
    {
        kMleMaxResponseDelay = 1000u, ///< Maximum delay before responding to a multicast request.
    };

    /**
     * This enumeration type is used in `AppendAddressRegistration()` to determine which addresses to include in the
     * appended Address Registration TLV.
     *
     */
    enum AddressRegistrationMode
    {
        kAppendAllAddresses,  ///< Append all addresses (unicast/multicast) in Address Registration TLV.
        kAppendMeshLocalOnly, ///< Only append the Mesh Local (ML-EID) address in Address Registration TLV.
    };

    /**
     * This enumeration represents the message actions used in `Log()` methods.
     *
     */
    enum MessageAction : uint8_t
    {
        kMessageSend,
        kMessageReceive,
        kMessageDelay,
        kMessageRemoveDelayed,
    };

    /**
     * This enumeration represents message types used in `Log()` methods.
     *
     */
    enum MessageType : uint8_t
    {
        kTypeAdvertisement,
        kTypeAnnounce,
        kTypeChildIdRequest,
        kTypeChildIdRequestShort,
        kTypeChildIdResponse,
        kTypeChildUpdateRequestOfParent,
        kTypeChildUpdateResponseOfParent,
        kTypeDataRequest,
        kTypeDataResponse,
        kTypeDiscoveryRequest,
        kTypeDiscoveryResponse,
        kTypeGenericDelayed,
        kTypeGenericUdp,
        kTypeParentRequestToRouters,
        kTypeParentRequestToRoutersReeds,
        kTypeParentResponse,
#if OPENTHREAD_FTD
        kTypeAddressRelease,
        kTypeAddressReleaseReply,
        kTypeAddressReply,
        kTypeAddressSolicit,
        kTypeChildUpdateRequestOfChild,
        kTypeChildUpdateResponseOfChild,
        kTypeChildUpdateResponseOfUnknownChild,
        kTypeLinkAccept,
        kTypeLinkAcceptAndRequest,
        kTypeLinkReject,
        kTypeLinkRequest,
        kTypeParentRequest,
#if OPENTHREAD_CONFIG_TIME_SYNC_ENABLE
        kTypeTimeSync,
#endif
#endif
#if OPENTHREAD_CONFIG_MLE_LINK_METRICS_ENABLE
        kTypeLinkMetricsManagementRequest,
        kTypeLinkMetricsManagementResponse,
        kTypeLinkProbe,
#endif
    };

    /**
     * This type represents a Challenge (or Response) data.
     *
     */
    struct Challenge
    {
        uint8_t mBuffer[kMaxChallengeSize]; ///< Buffer containing the challenge/response byte sequence.
        uint8_t mLength;                    ///< Challenge length (in bytes).

        /**
         * This method generates a cryptographically secure random sequence to populate the challenge data.
         *
         */
        void GenerateRandom(void);

        /**
         * This method indicates whether the Challenge matches a given buffer.
         *
         * @param[in] aBuffer   A pointer to a buffer to compare with the Challenge.
         * @param[in] aLength   Length of @p aBuffer (in bytes).
         *
         * @retval TRUE  If the Challenge matches the given buffer.
         * @retval FALSE If the Challenge does not match the given buffer.
         *
         */
        bool Matches(const uint8_t *aBuffer, uint8_t aLength) const;

        /**
         * This method indicates whether two Challenge data byte sequences are equal or not.
         *
         * @param[in] aOther   Another Challenge data to compare.
         *
         * @retval TRUE  If the two Challenges match.
         * @retval FALSE If the two Challenges do not match.
         *
         */
        bool operator==(const Challenge &aOther) const { return Matches(aOther.mBuffer, aOther.mLength); }
    };

    /**
     * This type represents list of requested TLVs in a TLV Request TLV.
     *
     */
    struct RequestedTlvs
    {
        enum
        {
            kMaxNumTlvs = 16, ///< Maximum number of TLVs in request array.
        };

        uint8_t mTlvs[kMaxNumTlvs]; ///< Array of requested TLVs.
        uint8_t mNumTlvs;           ///< Number of TLVs in the array.
    };

    /**
     * This method allocates a new message buffer for preparing an MLE message.
     *
     * @returns A pointer to the message or nullptr if insufficient message buffers are available.
     *
     */
    Message *NewMleMessage(void);

    /**
     * This method sets the device role.
     *
     * @param[in] aRole A device role.
     *
     */
    void SetRole(DeviceRole aRole);

    /**
     * This method sets the attach state
     *
     * @param[in] aState An attach state
     *
     */
    void SetAttachState(AttachState aState);

    /**
     * This method appends an MLE header to a message.
     *
     * @param[in]  aMessage  A reference to the message.
     * @param[in]  aCommand  The MLE Command Type.
     *
     * @retval kErrorNone    Successfully appended the header.
     * @retval kErrorNoBufs  Insufficient buffers available to append the header.
     *
     */
    Error AppendHeader(Message &aMessage, Command aCommand);

    /**
     * This method appends a Source Address TLV to a message.
     *
     * @param[in]  aMessage  A reference to the message.
     *
     * @retval kErrorNone    Successfully appended the Source Address TLV.
     * @retval kErrorNoBufs  Insufficient buffers available to append the Source Address TLV.
     *
     */
    Error AppendSourceAddress(Message &aMessage) const;

    /**
     * This method appends a Mode TLV to a message.
     *
     * @param[in]  aMessage  A reference to the message.
     * @param[in]  aMode     The Device Mode.
     *
     * @retval kErrorNone    Successfully appended the Mode TLV.
     * @retval kErrorNoBufs  Insufficient buffers available to append the Mode TLV.
     *
     */
    Error AppendMode(Message &aMessage, DeviceMode aMode);

    /**
     * This method appends a Timeout TLV to a message.
     *
     * @param[in]  aMessage  A reference to the message.
     * @param[in]  aTimeout  The Timeout value.
     *
     * @retval kErrorNone    Successfully appended the Timeout TLV.
     * @retval kErrorNoBufs  Insufficient buffers available to append the Timeout TLV.
     *
     */
    Error AppendTimeout(Message &aMessage, uint32_t aTimeout);

    /**
     * This method appends a Challenge TLV to a message.
     *
     * @param[in]  aMessage          A reference to the message.
     * @param[in]  aChallenge        A pointer to the Challenge value.
     * @param[in]  aChallengeLength  The length of the Challenge value in bytes.
     *
     * @retval kErrorNone    Successfully appended the Challenge TLV.
     * @retval kErrorNoBufs  Insufficient buffers available to append the Challenge TLV.
     *
     */
    Error AppendChallenge(Message &aMessage, const uint8_t *aChallenge, uint8_t aChallengeLength);

    /**
     * This method appends a Challenge TLV to a message.
     *
     * @param[in]  aMessage          A reference to the message.
     * @param[in]  aChallenge        A reference to the Challenge data.
     *
     * @retval kErrorNone    Successfully appended the Challenge TLV.
     * @retval kErrorNoBufs  Insufficient buffers available to append the Challenge TLV.
     *
     */
    Error AppendChallenge(Message &aMessage, const Challenge &aChallenge);

    /**
     * This method reads Challenge TLV from a message.
     *
     * @param[in]  aMessage          A reference to the message.
     * @param[out] aChallenge        A reference to the Challenge data where to output the read value.
     *
     * @retval kErrorNone       Successfully read the Challenge TLV.
     * @retval kErrorNotFound   Challenge TLV was not found in the message.
     * @retval kErrorParse      Challenge TLV was found but could not be parsed.
     *
     */
    Error ReadChallenge(const Message &aMessage, Challenge &aChallenge);

    /**
     * This method appends a Response TLV to a message.
     *
     * @param[in]  aMessage         A reference to the message.
     * @param[in]  aResponse        A reference to the Response data.
     *
     * @retval kErrorNone    Successfully appended the Response TLV.
     * @retval kErrorNoBufs  Insufficient buffers available to append the Response TLV.
     *
     */
    Error AppendResponse(Message &aMessage, const Challenge &aResponse);

    /**
     * This method reads Response TLV from a message.
     *
     * @param[in]  aMessage         A reference to the message.
     * @param[out] aResponse        A reference to the Response data where to output the read value.
     *
     * @retval kErrorNone       Successfully read the Response TLV.
     * @retval kErrorNotFound   Response TLV was not found in the message.
     * @retval kErrorParse      Response TLV was found but could not be parsed.
     *
     */
    Error ReadResponse(const Message &aMessage, Challenge &aResponse);

    /**
     * This method appends a Link Frame Counter TLV to a message.
     *
     * @param[in]  aMessage  A reference to the message.
     *
     * @retval kErrorNone     Successfully appended the Link Frame Counter TLV.
     * @retval kErrorNoBufs   Insufficient buffers available to append the Link Frame Counter TLV.
     *
     */
    Error AppendLinkFrameCounter(Message &aMessage);

    /**
     * This method reads Link and MLE Frame Counters from a message.
     *
     * Link Frame Counter TLV must be present in the message and its value is read into @p aLinkFrameCounter. If MLE
     * Frame Counter TLV is present in the message, its value is read into @p aMleFrameCounter. If the MLE Frame
     * Counter TLV is not present in the message, then @p aMleFrameCounter is set to same value as @p aLinkFrameCounter.
     *
     * @param[in]  aMesssage           A reference to the message to read from.
     * @param[out] aLinkFrameCounter   A reference to an `uint32_t` to output the Link Frame Counter.
     * @param[out] aMleFrameCounter    A reference to an `uint32_t` to output the MLE Frame Counter.
     *
     * @retval kErrorNone       Successfully read the counters.
     * @retval kErrorNotFound   Link Frame Counter TLV was not found in the message.
     * @retval kErrorParse      TLVs are not well-formed.
     *
     */
    Error ReadFrameCounters(const Message &aMessage, uint32_t &aLinkFrameCounter, uint32_t &aMleFrameCounter) const;

    /**
     * This method appends an MLE Frame Counter TLV to a message.
     *
     * @param[in]  aMessage  A reference to the message.
     *
     * @retval kErrorNone     Successfully appended the Frame Counter TLV.
     * @retval kErrorNoBufs   Insufficient buffers available to append the MLE Frame Counter TLV.
     *
     */
    Error AppendMleFrameCounter(Message &aMessage);

    /**
     * This method appends an Address16 TLV to a message.
     *
     * @param[in]  aMessage  A reference to the message.
     * @param[in]  aRloc16   The RLOC16 value.
     *
     * @retval kErrorNone     Successfully appended the Address16 TLV.
     * @retval kErrorNoBufs   Insufficient buffers available to append the Address16 TLV.
     *
     */
    Error AppendAddress16(Message &aMessage, uint16_t aRloc16);

    /**
     * This method appends a Network Data TLV to the message.
     *
     * @param[in]  aMessage     A reference to the message.
     * @param[in]  aStableOnly  TRUE to append stable data, FALSE otherwise.
     *
     * @retval kErrorNone     Successfully appended the Network Data TLV.
     * @retval kErrorNoBufs   Insufficient buffers available to append the Network Data TLV.
     *
     */
    Error AppendNetworkData(Message &aMessage, bool aStableOnly);

    /**
     * This method appends a TLV Request TLV to a message.
     *
     * @param[in]  aMessage     A reference to the message.
     * @param[in]  aTlvs        A pointer to the list of TLV types.
     * @param[in]  aTlvsLength  The number of TLV types in @p aTlvs
     *
     * @retval kErrorNone     Successfully appended the TLV Request TLV.
     * @retval kErrorNoBufs   Insufficient buffers available to append the TLV Request TLV.
     *
     */
    Error AppendTlvRequest(Message &aMessage, const uint8_t *aTlvs, uint8_t aTlvsLength);

    /**
     * This method reads TLV Request TLV from a message.
     *
     * @param[in]  aMessage         A reference to the message.
     * @param[out] aRequestedTlvs   A reference to output the read list of requested TLVs.
     *
     * @retval kErrorNone       Successfully read the TLV.
     * @retval kErrorNotFound   TLV was not found in the message.
     * @retval kErrorParse      TLV was found but could not be parsed.
     *
     */
    Error FindTlvRequest(const Message &aMessage, RequestedTlvs &aRequestedTlvs);

    /**
     * This method appends a Leader Data TLV to a message.
     *
     * @param[in]  aMessage  A reference to the message.
     *
     * @retval kErrorNone     Successfully appended the Leader Data TLV.
     * @retval kErrorNoBufs   Insufficient buffers available to append the Leader Data TLV.
     *
     */
    Error AppendLeaderData(Message &aMessage);

    /**
     * This method reads Leader Data TLV from a message.
     *
     * @param[in]  aMessage        A reference to the message.
     * @param[out] aLeaderData     A reference to output the Leader Data.
     *
     * @retval kErrorNone       Successfully read the TLV.
     * @retval kErrorNotFound   TLV was not found in the message.
     * @retval kErrorParse      TLV was found but could not be parsed.
     *
     */
    Error ReadLeaderData(const Message &aMessage, LeaderData &aLeaderData);

    /**
     * This method appends a Scan Mask TLV to a message.
     *
     * @param[in]  aMessage   A reference to the message.
     * @param[in]  aScanMask  The Scan Mask value.
     *
     * @retval kErrorNone     Successfully appended the Scan Mask TLV.
     * @retval kErrorNoBufs   Insufficient buffers available to append the Scan Mask TLV.
     *
     */
    Error AppendScanMask(Message &aMessage, uint8_t aScanMask);

    /**
     * This method appends a Status TLV to a message.
     *
     * @param[in]  aMessage  A reference to the message.
     * @param[in]  aStatus   The Status value.
     *
     * @retval kErrorNone     Successfully appended the Status TLV.
     * @retval kErrorNoBufs   Insufficient buffers available to append the Status TLV.
     *
     */
    Error AppendStatus(Message &aMessage, StatusTlv::Status aStatus);

    /**
     * This method appends a Link Margin TLV to a message.
     *
     * @param[in]  aMessage     A reference to the message.
     * @param[in]  aLinkMargin  The Link Margin value.
     *
     * @retval kErrorNone     Successfully appended the Link Margin TLV.
     * @retval kErrorNoBufs   Insufficient buffers available to append the Link Margin TLV.
     *
     */
    Error AppendLinkMargin(Message &aMessage, uint8_t aLinkMargin);

    /**
     * This method appends a Version TLV to a message.
     *
     * @param[in]  aMessage  A reference to the message.
     *
     * @retval kErrorNone     Successfully appended the Version TLV.
     * @retval kErrorNoBufs   Insufficient buffers available to append the Version TLV.
     *
     */
    Error AppendVersion(Message &aMessage);

    /**
     * This method appends an Address Registration TLV to a message.
     *
     * @param[in]  aMessage  A reference to the message.
     * @param[in]  aMode     Determines which addresses to include in the TLV (see `AddressRegistrationMode`).
     *
     * @retval kErrorNone     Successfully appended the Address Registration TLV.
     * @retval kErrorNoBufs   Insufficient buffers available to append the Address Registration TLV.
     *
     */
    Error AppendAddressRegistration(Message &aMessage, AddressRegistrationMode aMode = kAppendAllAddresses);

#if OPENTHREAD_CONFIG_TIME_SYNC_ENABLE
    /**
     * This method appends a Time Request TLV to a message.
     *
     * @param[in]  aMessage  A reference to the message.
     *
     * @retval kErrorNone     Successfully appended the Time Request TLV.
     * @retval kErrorNoBufs   Insufficient buffers available to append the Time Request TLV.
     *
     */
    Error AppendTimeRequest(Message &aMessage);

    /**
     * This method appends a Time Parameter TLV to a message.
     *
     * @param[in]  aMessage  A reference to the message.
     *
     * @retval kErrorNone     Successfully appended the Time Parameter TLV.
     * @retval kErrorNoBufs   Insufficient buffers available to append the Time Parameter TLV.
     *
     */
    Error AppendTimeParameter(Message &aMessage);

    /**
     * This method appends a XTAL Accuracy TLV to a message.
     *
     * @param[in]  aMessage  A reference to the message.
     *
     * @retval kErrorNone     Successfully appended the XTAL Accuracy TLV.
     * @retval kErrorNoBufs   Insufficient buffers available to append the XTAl Accuracy TLV.
     *
     */
    Error AppendXtalAccuracy(Message &aMessage);
#endif // OPENTHREAD_CONFIG_TIME_SYNC_ENABLE

#if (OPENTHREAD_FTD && OPENTHREAD_CONFIG_MAC_CSL_TRANSMITTER_ENABLE) || OPENTHREAD_CONFIG_MAC_CSL_RECEIVER_ENABLE
    /**
     * This method appends a CSL Channel TLV to a message.
     *
     * @param[in]  aMessage  A reference to the message.
     *
     * @retval kErrorNone     Successfully appended the CSL Channel TLV.
     * @retval kErrorNoBufs   Insufficient buffers available to append the CSL Channel TLV.
     *
     */
    Error AppendCslChannel(Message &aMessage);

    /**
     * This method appends a CSL Sync Timeout TLV to a message.
     *
     * @param[in]  aMessage  A reference to the message.
     *
     * @retval kErrorNone     Successfully appended the CSL Timeout TLV.
     * @retval kErrorNoBufs   Insufficient buffers available to append the CSL Timeout TLV.
     *
     */
    Error AppendCslTimeout(Message &aMessage);
#endif // (OPENTHREAD_FTD && OPENTHREAD_CONFIG_MAC_CSL_TRANSMITTER_ENABLE) || OPENTHREAD_CONFIG_MAC_CSL_RECEIVER_ENABLE

    /**
     * This method appends a Active Timestamp TLV to a message.
     *
     * @param[in]  aMessage  A reference to the message.
     *
     * @retval kErrorNone     Successfully appended the Active Timestamp TLV.
     * @retval kErrorNoBufs   Insufficient buffers available to append the Active Timestamp TLV.
     *
     */
    Error AppendActiveTimestamp(Message &aMessage);

    /**
     * This method appends a Pending Timestamp TLV to a message.
     *
     * @param[in]  aMessage  A reference to the message.
     *
     * @retval kErrorNone     Successfully appended the Pending Timestamp TLV.
     * @retval kErrorNoBufs   Insufficient buffers available to append the Pending Timestamp TLV.
     *
     */
    Error AppendPendingTimestamp(Message &aMessage);

    /**
     * This method checks if the destination is reachable.
     *
     * @param[in]  aMeshDest   The RLOC16 of the destination.
     * @param[in]  aIp6Header  The IPv6 header of the message.
     *
     * @retval kErrorNone      The destination is reachable.
     * @retval kErrorNoRoute   The destination is not reachable and the message should be dropped.
     *
     */
    Error CheckReachability(uint16_t aMeshDest, Ip6::Header &aIp6Header);

    /**
     * This method returns the next hop towards an RLOC16 destination.
     *
     * @param[in]  aDestination  The RLOC16 of the destination.
     *
     * @returns A RLOC16 of the next hop if a route is known, kInvalidRloc16 otherwise.
     *
     */
    Mac::ShortAddress GetNextHop(uint16_t aDestination) const;

    /**
     * This method generates an MLE Data Request message.
     *
     * @param[in]  aDestination      A reference to the IPv6 address of the destination.
     * @param[in]  aTlvs             A pointer to requested TLV types.
     * @param[in]  aTlvsLength       The number of TLV types in @p aTlvs.
     * @param[in]  aDelay            Delay in milliseconds before the Data Request message is sent.
     * @param[in]  aExtraTlvs        A pointer to extra TLVs.
     * @param[in]  aExtraTlvsLength  Length of extra TLVs.
     *
     * @retval kErrorNone     Successfully generated an MLE Data Request message.
     * @retval kErrorNoBufs   Insufficient buffers to generate the MLE Data Request message.
     *
     */
    Error SendDataRequest(const Ip6::Address &aDestination,
                          const uint8_t *     aTlvs,
                          uint8_t             aTlvsLength,
                          uint16_t            aDelay,
                          const uint8_t *     aExtraTlvs       = nullptr,
                          uint8_t             aExtraTlvsLength = 0);

    /**
     * This method generates an MLE Child Update Request message.
     *
     * @retval kErrorNone    Successfully generated an MLE Child Update Request message.
     * @retval kErrorNoBufs  Insufficient buffers to generate the MLE Child Update Request message.
     *
     */
    Error SendChildUpdateRequest(void);

    /**
     * This method generates an MLE Child Update Response message.
     *
     * @param[in]  aTlvs         A pointer to requested TLV types.
     * @param[in]  aNumTlvs      The number of TLV types in @p aTlvs.
     * @param[in]  aChallenge    The Challenge for the response.
     *
     * @retval kErrorNone     Successfully generated an MLE Child Update Response message.
     * @retval kErrorNoBufs   Insufficient buffers to generate the MLE Child Update Response message.
     *
     */
    Error SendChildUpdateResponse(const uint8_t *aTlvs, uint8_t aNumTlvs, const Challenge &aChallenge);

    /**
     * This method submits an MLE message to the UDP socket.
     *
     * @param[in]  aMessage      A reference to the message.
     * @param[in]  aDestination  A reference to the IPv6 address of the destination.
     *
     * @retval kErrorNone     Successfully submitted the MLE message.
     * @retval kErrorNoBufs   Insufficient buffers to form the rest of the MLE message.
     *
     */
    Error SendMessage(Message &aMessage, const Ip6::Address &aDestination);

    /**
     * This method sets the RLOC16 assigned to the Thread interface.
     *
     * @param[in]  aRloc16  The RLOC16 to set.
     *
     */
    void SetRloc16(uint16_t aRloc16);

    /**
     * This method sets the Device State to Detached.
     *
     */
    void SetStateDetached(void);

    /**
     * This method sets the Device State to Child.
     *
     */
    void SetStateChild(uint16_t aRloc16);

    /**
     * This method sets the Leader's Partition ID, Weighting, and Router ID values.
     *
     * @param[in]  aPartitionId     The Leader's Partition ID value.
     * @param[in]  aWeighting       The Leader's Weighting value.
     * @param[in]  aLeaderRouterId  The Leader's Router ID value.
     *
     */
    void SetLeaderData(uint32_t aPartitionId, uint8_t aWeighting, uint8_t aLeaderRouterId);

    /**
     * This method adds a message to the message queue. The queued message will be transmitted after given delay.
     *
     * @param[in]  aMessage      The message to transmit after given delay.
     * @param[in]  aDestination  The IPv6 address of the recipient of the message.
     * @param[in]  aDelay        The delay in milliseconds before transmission of the message.
     *
     * @retval kErrorNone     Successfully queued the message to transmit after the delay.
     * @retval kErrorNoBufs   Insufficient buffers to queue the message.
     *
     */
    Error AddDelayedResponse(Message &aMessage, const Ip6::Address &aDestination, uint16_t aDelay);

#if (OPENTHREAD_CONFIG_LOG_LEVEL >= OT_LOG_LEVEL_INFO) && (OPENTHREAD_CONFIG_LOG_MLE == 1)
    /**
     * This static method emits a log message with an IPv6 address.
     *
     * @param[in]  aAction     The message action (send/receive/delay, etc).
     * @param[in]  aType       The message type.
     * @param[in]  aAddress    The IPv6 address of the peer.
     *
     */
    static void Log(MessageAction aAction, MessageType aType, const Ip6::Address &aAddress);

    /**
     * This static method emits a log message with an IPv6 address and RLOC16.
     *
     * @param[in]  aAction     The message action (send/receive/delay, etc).
     * @param[in]  aType       The message type.
     * @param[in]  aAddress    The IPv6 address of the peer.
     * @param[in]  aRloc       The RLOC16.
     *
     */
    static void Log(MessageAction aAction, MessageType aType, const Ip6::Address &aAddress, uint16_t aRloc);
#else
    static void Log(MessageAction, MessageType, const Ip6::Address &) {}
    static void Log(MessageAction, MessageType, const Ip6::Address &, uint16_t) {}
#endif // #if (OPENTHREAD_CONFIG_LOG_LEVEL >= OT_LOG_LEVEL_INFO) && (OPENTHREAD_CONFIG_LOG_MLE == 1)

#if (OPENTHREAD_CONFIG_LOG_LEVEL >= OT_LOG_LEVEL_WARN) && (OPENTHREAD_CONFIG_LOG_MLE == 1)
    /**
     * This static method emits a log message indicating an error in processing of a message.
     *
     * Note that log message is emitted only if there is an error, i.e., @p aError is not `kErrorNone`. The log
     * message will have the format ""Failed to process {aMessageString} : {ErrorString}"".
     *
     * @param[in]  aType      The message type.
     * @param[in]  aError     The error in processing of the message.
     *
     */
    static void LogProcessError(MessageType aType, Error aError);

    /**
     * This static method emits a log message indicating an error when sending a message.
     *
     * Note that log message is emitted only if there is an error, i.e. @p aError is not `kErrorNone`. The log
     * message will have the format ""Failed to send {Message Type} : {ErrorString}"".
     *
     * @param[in]  aType    The message type.
     * @param[in]  aError   The error in sending the message.
     *
     */
    static void LogSendError(MessageType aType, Error aError);
#else
    static void LogProcessError(MessageType, Error) {}
    static void LogSendError(MessageType, Error) {}
#endif // #if (OPENTHREAD_CONFIG_LOG_LEVEL >= OT_LOG_LEVEL_WARN) && (OPENTHREAD_CONFIG_LOG_MLE == 1)

    /**
     * This method triggers MLE Announce on previous channel after the Thread device successfully
     * attaches and receives the new Active Commissioning Dataset if needed.
     *
     * MTD would send Announce immediately after attached.
     * FTD would delay to send Announce after tried to become Router or decided to stay in REED role.
     *
     */
    void InformPreviousChannel(void);

    /**
     * This method indicates whether or not in announce attach process.
     *
     * @retval true if attaching/attached on the announced parameters, false otherwise.
     *
     */
    bool IsAnnounceAttach(void) const { return mAlternatePanId != Mac::kPanIdBroadcast; }

#if (OPENTHREAD_CONFIG_LOG_LEVEL >= OT_LOG_LEVEL_NOTE) && (OPENTHREAD_CONFIG_LOG_MLE == 1)
    /**
     * This method converts an `AttachMode` enumeration value into a human-readable string.
     *
     * @param[in] aMode An attach mode
     *
     * @returns A human-readable string corresponding to the attach mode.
     *
     */
    static const char *AttachModeToString(AttachMode aMode);

    /**
     * This method converts an `AttachState` enumeration value into a human-readable string.
     *
     * @param[in] aState An attach state
     *
     * @returns A human-readable string corresponding to the attach state.
     *
     */
    static const char *AttachStateToString(AttachState aState);

    /**
     * This method converts a `ReattachState` enumeration value into a human-readable string.
     *
     * @param[in] aState A reattach state
     *
     * @returns A human-readable string corresponding to the reattach state.
     *
     */
    static const char *ReattachStateToString(ReattachState aState);
#endif

#if OPENTHREAD_CONFIG_MLE_LINK_METRICS_ENABLE
    /**
     * This method sends a Link Metrics Management Request message.
     *
     * @param[in]  aDestination  A reference to the IPv6 address of the destination.
     * @param[in]  aSubTlvs      A pointer to the buffer of the sub-TLVs in the message.
     * @param[in]  aLength       The overall length of @p aSubTlvs.
     *
     * @retval kErrorNone     Successfully sent a Link Metrics Management Request.
     * @retval kErrorNoBufs   Insufficient buffers to generate the MLE Link Metrics Management Request message.
     *
     */
    Error SendLinkMetricsManagementRequest(const Ip6::Address &aDestination, const uint8_t *aSubTlvs, uint8_t aLength);

    /**
     * This method sends an MLE Link Probe message.
     *
     * @param[in]  aDestination  A reference to the IPv6 address of the destination.
     * @param[in]  aSeriesId     The Series ID [1, 254] which the Probe message targets at.
     * @param[in]  aBuf          A pointer to the data payload.
     * @param[in]  aLength       The length of the data payload in Link Probe TLV, [0, 64].
     *
     * @retval kErrorNone         Successfully sent a Link Metrics Management Request.
     * @retval kErrorNoBufs       Insufficient buffers to generate the MLE Link Metrics Management Request message.
     * @retval kErrorInvalidArgs  Series ID is not a valid value, not within range [1, 254].
     *
     */
    Error SendLinkProbe(const Ip6::Address &aDestination, uint8_t aSeriesId, uint8_t *aBuf, uint8_t aLength);

#endif

    Ip6::NetifUnicastAddress mLeaderAloc; ///< Leader anycast locator

    LeaderData    mLeaderData;               ///< Last received Leader Data TLV.
    bool          mRetrieveNewNetworkData;   ///< Indicating new Network Data is needed if set.
    DeviceRole    mRole;                     ///< Current Thread role.
    Router        mParent;                   ///< Parent information.
    Router        mParentCandidate;          ///< Parent candidate information.
    NeighborTable mNeighborTable;            ///< The neighbor table.
    DeviceMode    mDeviceMode;               ///< Device mode setting.
    AttachState   mAttachState;              ///< The parent request state.
    ReattachState mReattachState;            ///< Reattach state
    uint16_t      mAttachCounter;            ///< Attach attempt counter.
    uint16_t      mAnnounceDelay;            ///< Delay in between sending Announce messages during attach.
    TimerMilli    mAttachTimer;              ///< The timer for driving the attach process.
    TimerMilli    mDelayedResponseTimer;     ///< The timer to delay MLE responses.
    TimerMilli    mMessageTransmissionTimer; ///< The timer for (re-)sending of MLE messages (e.g. Child Update).
    uint8_t       mParentLeaderCost;

private:
    enum
    {
        kMleHopLimit        = 255,
        kMleSecurityTagSize = 4, // Security tag size in bytes.

        // Parameters related to ""periodic parent search"" feature (CONFIG_ENABLE_PERIODIC_PARENT_SEARCH).
        // All timer intervals are converted to milliseconds.
        kParentSearchCheckInterval   = (OPENTHREAD_CONFIG_PARENT_SEARCH_CHECK_INTERVAL * 1000u),
        kParentSearchBackoffInterval = (OPENTHREAD_CONFIG_PARENT_SEARCH_BACKOFF_INTERVAL * 1000u),
        kParentSearchJitterInterval  = (15 * 1000u),
        kParentSearchRssThreadhold   = OPENTHREAD_CONFIG_PARENT_SEARCH_RSS_THRESHOLD,
    };

    // Parameters for ""attach backoff"" feature (CONFIG_ENABLE_ATTACH_BACKOFF) - Intervals are in milliseconds.
    enum : uint32_t
    {
        kAttachBackoffMinInterval         = OPENTHREAD_CONFIG_MLE_ATTACH_BACKOFF_MINIMUM_INTERVAL,
        kAttachBackoffMaxInterval         = OPENTHREAD_CONFIG_MLE_ATTACH_BACKOFF_MAXIMUM_INTERVAL,
        kAttachBackoffJitter              = OPENTHREAD_CONFIG_MLE_ATTACH_BACKOFF_JITTER_INTERVAL,
        kAttachBackoffDelayToResetCounter = OPENTHREAD_CONFIG_MLE_ATTACH_BACKOFF_DELAY_TO_RESET_BACKOFF_INTERVAL,
    };

    enum ParentRequestType
    {
        kParentRequestTypeRouters,         ///< Parent Request to all routers.
        kParentRequestTypeRoutersAndReeds, ///< Parent Request to all routers and REEDs.
    };

    enum ChildUpdateRequestState
    {
        kChildUpdateRequestNone,    ///< No pending or active Child Update Request.
        kChildUpdateRequestPending, ///< Pending Child Update Request due to relative OT_CHANGED event.
        kChildUpdateRequestActive,  ///< Child Update Request has been sent and Child Update Response is expected.
    };

    enum DataRequestState
    {
        kDataRequestNone,   ///< Not waiting for a Data Response.
        kDataRequestActive, ///< Data Request has been sent, Data Response is expected.
    };

    struct DelayedResponseMetadata
    {
        Error AppendTo(Message &aMessage) const { return aMessage.Append(*this); }
        void  ReadFrom(const Message &aMessage);
        void  RemoveFrom(Message &aMessage) const;

        Ip6::Address mDestination; // IPv6 address of the message destination.
        TimeMilli    mSendTime;    // Time when the message shall be sent.
    };

    OT_TOOL_PACKED_BEGIN
    class Header
    {
    public:
        enum SecuritySuite
        {
            k154Security = 0,
            kNoSecurity  = 255,
        };

        void Init(void)
        {
            mSecuritySuite   = k154Security;
            mSecurityControl = Mac::Frame::kSecEncMic32;
        }

        bool IsValid(void) const
        {
            return (mSecuritySuite == kNoSecurity) ||
                   (mSecuritySuite == k154Security &&
                    mSecurityControl == (Mac::Frame::kKeyIdMode2 | Mac::Frame::kSecEncMic32));
        }

        uint8_t GetLength(void) const
        {
            return sizeof(mSecuritySuite) + sizeof(mCommand) +
                   ((mSecuritySuite == k154Security)
                        ? sizeof(mSecurityControl) + sizeof(mFrameCounter) + sizeof(mKeySource) + sizeof(mKeyIndex)
                        : 0);
        }

        SecuritySuite GetSecuritySuite(void) const { return static_cast<SecuritySuite>(mSecuritySuite); }
        void SetSecuritySuite(SecuritySuite aSecuritySuite) { mSecuritySuite = static_cast<uint8_t>(aSecuritySuite); }

        uint8_t GetHeaderLength(void) const
        {
            return sizeof(mSecurityControl) + sizeof(mFrameCounter) + sizeof(mKeySource) + sizeof(mKeyIndex);
        }

        const uint8_t *GetBytes(void) const { return reinterpret_cast<const uint8_t *>(&mSecuritySuite); }
        uint8_t        GetSecurityControl(void) const { return mSecurityControl; }

        bool IsKeyIdMode2(void) const
        {
            return (mSecurityControl & Mac::Frame::kKeyIdModeMask) == Mac::Frame::kKeyIdMode2;
        }

        void SetKeyIdMode2(void)
        {
            mSecurityControl = (mSecurityControl & ~Mac::Frame::kKeyIdModeMask) | Mac::Frame::kKeyIdMode2;
        }

        uint32_t GetKeyId(void) const { return Encoding::BigEndian::HostSwap32(mKeySource); }

        void SetKeyId(uint32_t aKeySequence)
        {
            mKeySource = Encoding::BigEndian::HostSwap32(aKeySequence);
            mKeyIndex  = (aKeySequence & 0x7f) + 1;
        }

        uint32_t GetFrameCounter(void) const { return Encoding::LittleEndian::HostSwap32(mFrameCounter); }
        void     SetFrameCounter(uint32_t aFrameCounter)
        {
            mFrameCounter = Encoding::LittleEndian::HostSwap32(aFrameCounter);
        }

        Command GetCommand(void) const
        {
            return static_cast<Command>((mSecuritySuite == kNoSecurity) ? mSecurityControl : mCommand);
        }

        void SetCommand(Command aCommand)
        {
            if (mSecuritySuite == kNoSecurity)
            {
                mSecurityControl = static_cast<uint8_t>(aCommand);
            }
            else
            {
                mCommand = static_cast<uint8_t>(aCommand);
            }
        }

    private:
        uint8_t  mSecuritySuite;
        uint8_t  mSecurityControl;
        uint32_t mFrameCounter;
        uint32_t mKeySource;
        uint8_t  mKeyIndex;
        uint8_t  mCommand;
    } OT_TOOL_PACKED_END;

    void        HandleNotifierEvents(Events aEvents);
    static void HandleAttachTimer(Timer &aTimer);
    void        HandleAttachTimer(void);
    static void HandleDelayedResponseTimer(Timer &aTimer);
    void        HandleDelayedResponseTimer(void);
    static void HandleMessageTransmissionTimer(Timer &aTimer);
    void        HandleMessageTransmissionTimer(void);
    static void HandleUdpReceive(void *aContext, otMessage *aMessage, const otMessageInfo *aMessageInfo);
    void        HandleUdpReceive(Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
    void        ScheduleMessageTransmissionTimer(void);
    Error       ReadChallengeOrResponse(const Message &aMessage, uint8_t aTlvType, Challenge &aBuffer);

    void HandleAdvertisement(const Message &aMessage, const Ip6::MessageInfo &aMessageInfo, Neighbor *aNeighbor);
    void HandleChildIdResponse(const Message &         aMessage,
                               const Ip6::MessageInfo &aMessageInfo,
                               const Neighbor *        aNeighbor);
    void HandleChildUpdateRequest(const Message &aMessage, const Ip6::MessageInfo &aMessageInfo, Neighbor *aNeighbor);
    void HandleChildUpdateResponse(const Message &         aMessage,
                                   const Ip6::MessageInfo &aMessageInfo,
                                   const Neighbor *        aNeighbor);
    void HandleDataResponse(const Message &aMessage, const Ip6::MessageInfo &aMessageInfo, const Neighbor *aNeighbor);
    void HandleParentResponse(const Message &aMessage, const Ip6::MessageInfo &aMessageInfo, uint32_t aKeySequence);
    void HandleAnnounce(const Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
#if OPENTHREAD_CONFIG_MLE_LINK_METRICS_ENABLE
    void HandleLinkMetricsManagementRequest(const Message &         aMessage,
                                            const Ip6::MessageInfo &aMessageInfo,
                                            Neighbor *              aNeighbor);
    void HandleLinkMetricsManagementResponse(const Message &         aMessage,
                                             const Ip6::MessageInfo &aMessageInfo,
                                             Neighbor *              aNeighbor);
    void HandleLinkProbe(const Message &aMessage, const Ip6::MessageInfo &aMessageInfo, Neighbor *aNeighbor);
#endif
    Error HandleLeaderData(const Message &aMessage, const Ip6::MessageInfo &aMessageInfo);
    void  ProcessAnnounce(void);
    bool  HasUnregisteredAddress(void);

    uint32_t GetAttachStartDelay(void) const;
    Error    SendParentRequest(ParentRequestType aType);
    Error    SendChildIdRequest(void);
    Error    SendOrphanAnnounce(void);
    bool     PrepareAnnounceState(void);
    void     SendAnnounce(uint8_t aChannel, bool aOrphanAnnounce, const Ip6::Address &aDestination);
#if OPENTHREAD_CONFIG_MLE_LINK_METRICS_ENABLE
    Error SendLinkMetricsManagementResponse(const Ip6::Address &aDestination, LinkMetrics::LinkMetricsStatus aStatus);
#endif
    uint32_t Reattach(void);

    bool IsBetterParent(uint16_t               aRloc16,
                        uint8_t                aLinkQuality,
                        uint8_t                aLinkMargin,
                        const ConnectivityTlv &aConnectivityTlv,
                        uint8_t                aVersion);
    bool IsNetworkDataNewer(const LeaderData &aLeaderData);

#if OPENTHREAD_CONFIG_TMF_NETDATA_SERVICE_ENABLE
    /**
     * This method scans for network data from the leader and updates IP addresses assigned to this
     * interface to make sure that all Service ALOCs (0xfc10-0xfc1f) are properly set.
     */
    void UpdateServiceAlocs(void);
#endif

#if OPENTHREAD_CONFIG_MLE_INFORM_PREVIOUS_PARENT_ON_REATTACH
    void InformPreviousParent(void);
#endif

#if OPENTHREAD_CONFIG_PARENT_SEARCH_ENABLE
    static void HandleParentSearchTimer(Timer &aTimer);
    void        HandleParentSearchTimer(void);
    void        StartParentSearchTimer(void);
    void        UpdateParentSearchState(void);
#endif

#if (OPENTHREAD_CONFIG_LOG_LEVEL >= OT_LOG_LEVEL_WARN) && (OPENTHREAD_CONFIG_LOG_MLE == 1)
    static void        LogError(MessageAction aAction, MessageType aType, Error aError);
    static const char *MessageActionToString(MessageAction aAction);
    static const char *MessageTypeToString(MessageType aType);
    static const char *MessageTypeActionToSuffixString(MessageType aType, MessageAction aAction);
#endif

    MessageQueue mDelayedResponses;

    Challenge mParentRequestChallenge;

    AttachMode mParentRequestMode;
    int8_t     mParentPriority;
    uint8_t    mParentLinkQuality3;
    uint8_t    mParentLinkQuality2;
    uint8_t    mParentLinkQuality1;
    uint16_t   mParentSedBufferSize;
    uint8_t    mParentSedDatagramCount;

    uint8_t                 mChildUpdateAttempts;
    ChildUpdateRequestState mChildUpdateRequestState;
    uint8_t                 mDataRequestAttempts;
    DataRequestState        mDataRequestState;

    AddressRegistrationMode mAddressRegistrationMode;

    bool       mHasRestored;
    uint8_t    mParentLinkMargin;
    bool       mParentIsSingleton;
    bool       mReceivedResponseFromParent;
    LeaderData mParentLeaderData;

    Challenge mParentCandidateChallenge;

    Ip6::Udp::Socket mSocket;
    uint32_t         mTimeout;

#if OPENTHREAD_CONFIG_MLE_INFORM_PREVIOUS_PARENT_ON_REATTACH
    uint16_t mPreviousParentRloc;
#endif

#if OPENTHREAD_CONFIG_PARENT_SEARCH_ENABLE
    bool       mParentSearchIsInBackoff : 1;
    bool       mParentSearchBackoffWasCanceled : 1;
    bool       mParentSearchRecentlyDetached : 1;
    TimeMilli  mParentSearchBackoffCancelTime;
    TimerMilli mParentSearchTimer;
#endif

    uint8_t  mAnnounceChannel;
    uint8_t  mAlternateChannel;
    uint16_t mAlternatePanId;
    uint64_t mAlternateTimestamp;

#if OPENTHREAD_CONFIG_TMF_NETDATA_SERVICE_ENABLE
    Ip6::NetifUnicastAddress mServiceAlocs[kMaxServiceAlocs];
#endif

    otMleCounters mCounters;

    Ip6::NetifUnicastAddress   mLinkLocal64;
    Ip6::NetifUnicastAddress   mMeshLocal64;
    Ip6::NetifUnicastAddress   mMeshLocal16;
    Ip6::NetifMulticastAddress mLinkLocalAllThreadNodes;
    Ip6::NetifMulticastAddress mRealmLocalAllThreadNodes;

    otThreadParentResponseCallback mParentResponseCb;
    void *                         mParentResponseCbContext;
};

} // namespace Mle

/**
 * @}
 *
 */

} // namespace ot

#endif // MLE_HPP_
",16241,True,3221.8829902324205,median
"/*************************************************************************/
/*  csharp_script.cpp                                                    */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                      https://godotengine.org                          */
/*************************************************************************/
/* Copyright (c) 2007-2018 Juan Linietsky, Ariel Manzur.                 */
/* Copyright (c) 2014-2018 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 ""csharp_script.h""

#include <mono/metadata/threads.h>

#include ""os/file_access.h""
#include ""os/os.h""
#include ""os/thread.h""
#include ""project_settings.h""

#ifdef TOOLS_ENABLED
#include ""editor/bindings_generator.h""
#include ""editor/csharp_project.h""
#include ""editor/editor_node.h""
#include ""editor/godotsharp_editor.h""
#include ""utils/string_utils.h""
#endif

#include ""godotsharp_dirs.h""
#include ""mono_gd/gd_mono_class.h""
#include ""mono_gd/gd_mono_marshal.h""
#include ""signal_awaiter_utils.h""
#include ""utils/macros.h""
#include ""utils/thread_local.h""

#define CACHED_STRING_NAME(m_var) (CSharpLanguage::get_singleton()->get_string_names().m_var)

#ifdef TOOLS_ENABLED
static bool _create_project_solution_if_needed() {

	String sln_path = GodotSharpDirs::get_project_sln_path();
	String csproj_path = GodotSharpDirs::get_project_csproj_path();

	if (!FileAccess::exists(sln_path) || !FileAccess::exists(csproj_path)) {
		// A solution does not yet exist, create a new one

		CRASH_COND(GodotSharpEditor::get_singleton() == NULL);
		return GodotSharpEditor::get_singleton()->call(""_create_project_solution"");
	}

	return true;
}
#endif

CSharpLanguage *CSharpLanguage::singleton = NULL;

String CSharpLanguage::get_name() const {

	return ""C#"";
}

String CSharpLanguage::get_type() const {

	return ""CSharpScript"";
}

String CSharpLanguage::get_extension() const {

	return ""cs"";
}

Error CSharpLanguage::execute_file(const String &p_path) {

	// ??
	return OK;
}

#ifdef TOOLS_ENABLED
void gdsharp_editor_init_callback() {

	EditorNode *editor = EditorNode::get_singleton();
	editor->add_child(memnew(GodotSharpEditor(editor)));
}
#endif

void CSharpLanguage::init() {

	gdmono = memnew(GDMono);
	gdmono->initialize();

#ifdef MONO_GLUE_DISABLED
	WARN_PRINT(""This binary is built with `mono_glue=no` and cannot be used for scripting"");
#endif

#if defined(TOOLS_ENABLED) && defined(DEBUG_METHODS_ENABLED)
	if (gdmono->get_editor_tools_assembly() != NULL) {
		List<String> cmdline_args = OS::get_singleton()->get_cmdline_args();
		BindingsGenerator::handle_cmdline_args(cmdline_args);
	}
#endif

#ifdef TOOLS_ENABLED
	EditorNode::add_init_callback(&gdsharp_editor_init_callback);

	GLOBAL_DEF(""mono/export/include_scripts_content"", true);
#endif
}

void CSharpLanguage::finish() {

	finalizing = true;

#ifdef TOOLS_ENABLED
	// Must be here, to avoid StringName leaks
	if (BindingsGenerator::singleton) {
		memdelete(BindingsGenerator::singleton);
		BindingsGenerator::singleton = NULL;
	}
#endif

	// Release gchandle bindings before finalizing mono runtime
	gchandle_bindings.clear();

	if (gdmono) {
		memdelete(gdmono);
		gdmono = NULL;
	}

	finalizing = false;
}

void CSharpLanguage::get_reserved_words(List<String> *p_words) const {

	static const char *_reserved_words[] = {
		// Reserved keywords
		""abstract"",
		""as"",
		""base"",
		""bool"",
		""break"",
		""byte"",
		""case"",
		""catch"",
		""char"",
		""checked"",
		""class"",
		""const"",
		""continue"",
		""decimal"",
		""default"",
		""delegate"",
		""do"",
		""double"",
		""else"",
		""enum"",
		""event"",
		""explicit"",
		""extern"",
		""false"",
		""finally"",
		""fixed"",
		""float"",
		""for"",
		""foreach"",
		""goto"",
		""if"",
		""implicit"",
		""in"",
		""int"",
		""interface"",
		""internal"",
		""is"",
		""lock"",
		""long"",
		""namespace"",
		""new"",
		""null"",
		""object"",
		""operator"",
		""out"",
		""override"",
		""params"",
		""private"",
		""protected"",
		""public"",
		""readonly"",
		""ref"",
		""return"",
		""sbyte"",
		""sealed"",
		""short"",
		""sizeof"",
		""stackalloc"",
		""static"",
		""string"",
		""struct"",
		""switch"",
		""this"",
		""throw"",
		""true"",
		""try"",
		""typeof"",
		""uint"",
		""ulong"",
		""unchecked"",
		""unsafe"",
		""ushort"",
		""using"",
		""virtual"",
		""void"",
		""volatile"",
		""while"",

		// Contextual keywords. Not reserved words, but I guess we should include
		// them because this seems to be used only for syntax highlighting.
		""add"",
		""alias"",
		""ascending"",
		""async"",
		""await"",
		""by"",
		""descending"",
		""dynamic"",
		""equals"",
		""from"",
		""get"",
		""global"",
		""group"",
		""into"",
		""join"",
		""let"",
		""nameof"",
		""on"",
		""orderby"",
		""partial"",
		""remove"",
		""select"",
		""set"",
		""value"",
		""var"",
		""when"",
		""where"",
		""yield"",
		0
	};

	const char **w = _reserved_words;

	while (*w) {
		p_words->push_back(*w);
		w++;
	}
}

void CSharpLanguage::get_comment_delimiters(List<String> *p_delimiters) const {

	p_delimiters->push_back(""//""); // single-line comment
	p_delimiters->push_back(""/* */""); // delimited comment
}

void CSharpLanguage::get_string_delimiters(List<String> *p_delimiters) const {

	p_delimiters->push_back(""' '""); // character literal
	p_delimiters->push_back(""\\"" \\""""); // regular string literal
	p_delimiters->push_back(""@\\"" \\""""); // verbatim string literal
}

static String get_base_class_name(const String &p_base_class_name, const String p_class_name) {

	String base_class = p_base_class_name;
	if (p_class_name == base_class) {
		base_class = ""Godot."" + base_class;
	}
	return base_class;
}

Ref<Script> CSharpLanguage::get_template(const String &p_class_name, const String &p_base_class_name) const {

	String script_template = ""using "" BINDINGS_NAMESPACE "";\\n""
							 ""using System;\\n""
							 ""\\n""
							 ""public class %CLASS% : %BASE%\\n""
							 ""{\\n""
							 ""    // Declare member variables here. Examples:\\n""
							 ""    // private int a = 2;\\n""
							 ""    // private string b = \\""text\\"";\\n""
							 ""\\n""
							 ""    // Called when the node enters the scene tree for the first time.\\n""
							 ""    public override void _Ready()\\n""
							 ""    {\\n""
							 ""        \\n""
							 ""    }\\n""
							 ""\\n""
							 ""//  // Called every frame. 'delta' is the elapsed time since the previous frame.\\n""
							 ""//  public override void _Process(float delta)\\n""
							 ""//  {\\n""
							 ""//      \\n""
							 ""//  }\\n""
							 ""}\\n"";

	String base_class_name = get_base_class_name(p_base_class_name, p_class_name);
	script_template = script_template.replace(""%BASE%"", base_class_name)
							  .replace(""%CLASS%"", p_class_name);

	Ref<CSharpScript> script;
	script.instance();
	script->set_source_code(script_template);
	script->set_name(p_class_name);

	return script;
}

bool CSharpLanguage::is_using_templates() {

	return true;
}

void CSharpLanguage::make_template(const String &p_class_name, const String &p_base_class_name, Ref<Script> &p_script) {

	String src = p_script->get_source_code();
	String base_class_name = get_base_class_name(p_base_class_name, p_class_name);
	src = src.replace(""%BASE%"", base_class_name)
				  .replace(""%CLASS%"", p_class_name)
				  .replace(""%TS%"", _get_indentation());
	p_script->set_source_code(src);
}

String CSharpLanguage::validate_path(const String &p_path) const {

	String class_name = p_path.get_file().get_basename();
	List<String> keywords;
	get_reserved_words(&keywords);
	if (keywords.find(class_name)) {
		return TTR(""Class name can't be a reserved keyword"");
	}
	return """";
}

Script *CSharpLanguage::create_script() const {

	return memnew(CSharpScript);
}

bool CSharpLanguage::has_named_classes() const {

	return false;
}

bool CSharpLanguage::supports_builtin_mode() const {

	return false;
}

static String variant_type_to_managed_name(const String &p_var_type_name) {

	if (p_var_type_name.empty())
		return ""object"";

	if (!ClassDB::class_exists(p_var_type_name)) {
		Variant::Type var_types[] = {
			Variant::BOOL,
			Variant::INT,
			Variant::REAL,
			Variant::STRING,
			Variant::VECTOR2,
			Variant::RECT2,
			Variant::VECTOR3,
			Variant::TRANSFORM2D,
			Variant::PLANE,
			Variant::QUAT,
			Variant::AABB,
			Variant::BASIS,
			Variant::TRANSFORM,
			Variant::COLOR,
			Variant::NODE_PATH,
			Variant::_RID
		};

		for (int i = 0; i < sizeof(var_types) / sizeof(Variant::Type); i++) {
			if (p_var_type_name == Variant::get_type_name(var_types[i]))
				return p_var_type_name;
		}

		if (p_var_type_name == ""String"")
			return ""string""; // I prefer this one >:[

		// TODO these will be rewritten later into custom containers

		if (p_var_type_name == ""Array"")
			return ""object[]"";

		if (p_var_type_name == ""Dictionary"")
			return ""Dictionary<object, object>"";

		if (p_var_type_name == ""PoolByteArray"")
			return ""byte[]"";
		if (p_var_type_name == ""PoolIntArray"")
			return ""int[]"";
		if (p_var_type_name == ""PoolRealArray"")
			return ""float[]"";
		if (p_var_type_name == ""PoolStringArray"")
			return ""string[]"";
		if (p_var_type_name == ""PoolVector2Array"")
			return ""Vector2[]"";
		if (p_var_type_name == ""PoolVector3Array"")
			return ""Vector3[]"";
		if (p_var_type_name == ""PoolColorArray"")
			return ""Color[]"";

		return ""object"";
	}

	return p_var_type_name;
}

String CSharpLanguage::make_function(const String &p_class, const String &p_name, const PoolStringArray &p_args) const {
#ifdef TOOLS_ENABLED
	// FIXME
	// - Due to Godot's API limitation this just appends the function to the end of the file
	// - Use fully qualified name if there is ambiguity
	String s = ""private void "" + p_name + ""("";
	for (int i = 0; i < p_args.size(); i++) {
		const String &arg = p_args[i];

		if (i > 0)
			s += "", "";

		s += variant_type_to_managed_name(arg.get_slice("":"", 1)) + "" "" + escape_csharp_keyword(arg.get_slice("":"", 0));
	}
	s += "")\\n{\\n    // Replace with function body.\\n}\\n"";

	return s;
#else
	return String();
#endif
}

String CSharpLanguage::_get_indentation() const {
#ifdef TOOLS_ENABLED
	if (Engine::get_singleton()->is_editor_hint()) {
		bool use_space_indentation = EDITOR_DEF(""text_editor/indent/type"", 0);

		if (use_space_indentation) {
			int indent_size = EDITOR_DEF(""text_editor/indent/size"", 4);

			String space_indent = """";
			for (int i = 0; i < indent_size; i++) {
				space_indent += "" "";
			}
			return space_indent;
		}
	}
#endif
	return ""\\t"";
}

Vector<ScriptLanguage::StackInfo> CSharpLanguage::debug_get_current_stack_info() {

#ifdef DEBUG_ENABLED
	_TLS_RECURSION_GUARD_V_(Vector<StackInfo>());

	if (!gdmono->is_runtime_initialized() || !GDMono::get_singleton()->get_core_api_assembly() || !GDMonoUtils::mono_cache.corlib_cache_updated)
		return Vector<StackInfo>();

	MonoObject *stack_trace = mono_object_new(mono_domain_get(), CACHED_CLASS(System_Diagnostics_StackTrace)->get_mono_ptr());

	MonoBoolean need_file_info = true;
	void *ctor_args[1] = { &need_file_info };

	CACHED_METHOD(System_Diagnostics_StackTrace, ctor_bool)->invoke_raw(stack_trace, ctor_args);

	Vector<StackInfo> si;
	si = stack_trace_get_info(stack_trace);

	return si;
#else
	return Vector<StackInfo>();
#endif
}

#ifdef DEBUG_ENABLED
Vector<ScriptLanguage::StackInfo> CSharpLanguage::stack_trace_get_info(MonoObject *p_stack_trace) {

	_TLS_RECURSION_GUARD_V_(Vector<StackInfo>());

	MonoException *exc = NULL;

	GDMonoUtils::StackTrace_GetFrames st_get_frames = CACHED_METHOD_THUNK(System_Diagnostics_StackTrace, GetFrames);
	MonoArray *frames = st_get_frames(p_stack_trace, (MonoObject **)&exc);

	if (exc) {
		GDMonoUtils::debug_print_unhandled_exception(exc);
		return Vector<StackInfo>();
	}

	int frame_count = mono_array_length(frames);

	if (frame_count <= 0)
		return Vector<StackInfo>();

	GDMonoUtils::DebugUtils_StackFrameInfo get_sf_info = CACHED_METHOD_THUNK(DebuggingUtils, GetStackFrameInfo);

	Vector<StackInfo> si;
	si.resize(frame_count);

	for (int i = 0; i < frame_count; i++) {
		StackInfo &sif = si[i];
		MonoObject *frame = mono_array_get(frames, MonoObject *, i);

		MonoString *file_name;
		int file_line_num;
		MonoString *method_decl;
		get_sf_info(frame, &file_name, &file_line_num, &method_decl, (MonoObject **)&exc);

		if (exc) {
			GDMonoUtils::debug_print_unhandled_exception(exc);
			return Vector<StackInfo>();
		}

		// TODO
		// what if the StackFrame method is null (method_decl is empty). should we skip this frame?
		// can reproduce with a MissingMethodException on internal calls

		sif.file = GDMonoMarshal::mono_string_to_godot(file_name);
		sif.line = file_line_num;
		sif.func = GDMonoMarshal::mono_string_to_godot(method_decl);
	}

	return si;
}
#endif

void CSharpLanguage::frame() {

	const Ref<MonoGCHandle> &task_scheduler_handle = GDMonoUtils::mono_cache.task_scheduler_handle;

	if (task_scheduler_handle.is_valid()) {
		MonoObject *task_scheduler = task_scheduler_handle->get_target();

		if (task_scheduler) {
			GDMonoUtils::GodotTaskScheduler_Activate thunk = CACHED_METHOD_THUNK(GodotTaskScheduler, Activate);

			ERR_FAIL_NULL(thunk);

			MonoException *exc = NULL;
			thunk(task_scheduler, (MonoObject **)&exc);

			if (exc) {
				GDMonoUtils::debug_unhandled_exception(exc);
				_UNREACHABLE_();
			}
		}
	}
}

struct CSharpScriptDepSort {

	// must support sorting so inheritance works properly (parent must be reloaded first)
	bool operator()(const Ref<CSharpScript> &A, const Ref<CSharpScript> &B) const {
		if (A == B)
			return false; // shouldn't happen but..
		GDMonoClass *I = B->base;
		while (I) {
			if (I == A->script_class) {
				// A is a base of B
				return true;
			}

			I = I->get_parent_class();
		}

		return false; // not a base
	}
};

void CSharpLanguage::reload_all_scripts() {

#ifdef DEBUG_ENABLED

#ifndef NO_THREADS
	lock->lock();
#endif

	List<Ref<CSharpScript> > scripts;

	SelfList<CSharpScript> *elem = script_list.first();
	while (elem) {
		if (elem->self()->get_path().is_resource_file()) {
			scripts.push_back(Ref<CSharpScript>(elem->self())); //cast to gdscript to avoid being erased by accident
		}
		elem = elem->next();
	}

#ifndef NO_THREADS
	lock->unlock();
#endif

	//as scripts are going to be reloaded, must proceed without locking here

	scripts.sort_custom<CSharpScriptDepSort>(); //update in inheritance dependency order

	for (List<Ref<CSharpScript> >::Element *E = scripts.front(); E; E = E->next()) {
		E->get()->load_source_code(E->get()->get_path());
		E->get()->reload(true);
	}
#endif
}

void CSharpLanguage::reload_tool_script(const Ref<Script> &p_script, bool p_soft_reload) {

	(void)p_script; // UNUSED

#ifdef TOOLS_ENABLED
	MonoReloadNode::get_singleton()->restart_reload_timer();
	reload_assemblies_if_needed(p_soft_reload);
#endif
}

#ifdef TOOLS_ENABLED
void CSharpLanguage::reload_assemblies_if_needed(bool p_soft_reload) {

	if (gdmono->is_runtime_initialized()) {

		GDMonoAssembly *proj_assembly = gdmono->get_project_assembly();

		String name = ProjectSettings::get_singleton()->get(""application/config/name"");
		if (name.empty()) {
			name = ""UnnamedProject"";
		}

		if (proj_assembly) {
			String proj_asm_path = proj_assembly->get_path();

			if (!FileAccess::exists(proj_assembly->get_path())) {
				// Maybe it wasn't loaded from the default path, so check this as well
				proj_asm_path = GodotSharpDirs::get_res_temp_assemblies_dir().plus_file(name);
				if (!FileAccess::exists(proj_asm_path))
					return; // No assembly to load
			}

			if (FileAccess::get_modified_time(proj_asm_path) <= proj_assembly->get_modified_time())
				return; // Already up to date
		} else {
			if (!FileAccess::exists(GodotSharpDirs::get_res_temp_assemblies_dir().plus_file(name)))
				return; // No assembly to load
		}
	}

#ifndef NO_THREADS
	lock->lock();
#endif

	List<Ref<CSharpScript> > scripts;

	SelfList<CSharpScript> *elem = script_list.first();
	while (elem) {
		if (elem->self()->get_path().is_resource_file()) {

			scripts.push_back(Ref<CSharpScript>(elem->self())); //cast to CSharpScript to avoid being erased by accident
		}
		elem = elem->next();
	}

#ifndef NO_THREADS
	lock->unlock();
#endif

	//when someone asks you why dynamically typed languages are easier to write....

	Map<Ref<CSharpScript>, Map<ObjectID, List<Pair<StringName, Variant> > > > to_reload;

	//as scripts are going to be reloaded, must proceed without locking here

	scripts.sort_custom<CSharpScriptDepSort>(); //update in inheritance dependency order

	for (List<Ref<CSharpScript> >::Element *E = scripts.front(); E; E = E->next()) {

		to_reload.insert(E->get(), Map<ObjectID, List<Pair<StringName, Variant> > >());

		if (!p_soft_reload) {

			//save state and remove script from instances
			Map<ObjectID, List<Pair<StringName, Variant> > > &map = to_reload[E->get()];

			while (E->get()->instances.front()) {
				Object *obj = E->get()->instances.front()->get();
				//save instance info
				List<Pair<StringName, Variant> > state;
				if (obj->get_script_instance()) {

					obj->get_script_instance()->get_property_state(state);

					Ref<MonoGCHandle> gchandle = CAST_CSHARP_INSTANCE(obj->get_script_instance())->gchandle;
					if (gchandle.is_valid())
						gchandle->release();

					map[obj->get_instance_id()] = state;
					obj->set_script(RefPtr());
				}
			}

			//same thing for placeholders
			while (E->get()->placeholders.size()) {

				Object *obj = E->get()->placeholders.front()->get()->get_owner();
				//save instance info
				List<Pair<StringName, Variant> > state;
				if (obj->get_script_instance()) {
					obj->get_script_instance()->get_property_state(state);
					map[obj->get_instance_id()] = state;
					obj->set_script(RefPtr());
				}
			}

			for (Map<ObjectID, List<Pair<StringName, Variant> > >::Element *F = E->get()->pending_reload_state.front(); F; F = F->next()) {
				map[F->key()] = F->get(); //pending to reload, use this one instead
			}

			E->get()->_clear();
		}
	}

	if (gdmono->reload_scripts_domain() != OK)
		return;

	for (Map<Ref<CSharpScript>, Map<ObjectID, List<Pair<StringName, Variant> > > >::Element *E = to_reload.front(); E; E = E->next()) {

		Ref<CSharpScript> scr = E->key();
		scr->exports_invalidated = true;
		scr->signals_invalidated = true;
		scr->reload(p_soft_reload);
		scr->update_exports();

		//restore state if saved
		for (Map<ObjectID, List<Pair<StringName, Variant> > >::Element *F = E->get().front(); F; F = F->next()) {

			Object *obj = ObjectDB::get_instance(F->key());
			if (!obj)
				continue;

			if (!p_soft_reload) {
				//clear it just in case (may be a pending reload state)
				obj->set_script(RefPtr());
			}
			obj->set_script(scr.get_ref_ptr());
			if (!obj->get_script_instance()) {
				//failed, save reload state for next time if not saved
				if (!scr->pending_reload_state.has(obj->get_instance_id())) {
					scr->pending_reload_state[obj->get_instance_id()] = F->get();
				}
				continue;
			}

			for (List<Pair<StringName, Variant> >::Element *G = F->get().front(); G; G = G->next()) {
				obj->get_script_instance()->set(G->get().first, G->get().second);
			}

			scr->pending_reload_state.erase(obj->get_instance_id()); //as it reloaded, remove pending state
		}

		//if instance states were saved, set them!
	}

	if (Engine::get_singleton()->is_editor_hint()) {
		EditorNode::get_singleton()->get_inspector()->update_tree();
		NodeDock::singleton->update_lists();
	}
}
#endif

void CSharpLanguage::get_recognized_extensions(List<String> *p_extensions) const {

	p_extensions->push_back(""cs"");
}

#ifdef TOOLS_ENABLED
Error CSharpLanguage::open_in_external_editor(const Ref<Script> &p_script, int p_line, int p_col) {

	return GodotSharpEditor::get_singleton()->open_in_external_editor(p_script, p_line, p_col);
}

bool CSharpLanguage::overrides_external_editor() {

	return GodotSharpEditor::get_singleton()->overrides_external_editor();
}
#endif

void CSharpLanguage::thread_enter() {

#if 0
	if (mono->is_runtime_initialized()) {
		GDMonoUtils::attach_current_thread();
	}
#endif
}

void CSharpLanguage::thread_exit() {

#if 0
	if (mono->is_runtime_initialized()) {
		GDMonoUtils::detach_current_thread();
	}
#endif
}

bool CSharpLanguage::debug_break_parse(const String &p_file, int p_line, const String &p_error) {

	// Break because of parse error
	if (ScriptDebugger::get_singleton() && Thread::get_caller_id() == Thread::get_main_id()) {
		// TODO
		//_debug_parse_err_line = p_line;
		//_debug_parse_err_file = p_file;
		//_debug_error = p_error;
		ScriptDebugger::get_singleton()->debug(this, false);
		return true;
	} else {
		return false;
	}
}

bool CSharpLanguage::debug_break(const String &p_error, bool p_allow_continue) {

	if (ScriptDebugger::get_singleton() && Thread::get_caller_id() == Thread::get_main_id()) {
		// TODO
		//_debug_parse_err_line = -1;
		//_debug_parse_err_file = """";
		//_debug_error = p_error;
		ScriptDebugger::get_singleton()->debug(this, p_allow_continue);
		return true;
	} else {
		return false;
	}
}

void CSharpLanguage::set_language_index(int p_idx) {

	ERR_FAIL_COND(lang_idx != -1);
	lang_idx = p_idx;
}

CSharpLanguage::CSharpLanguage() {

	ERR_FAIL_COND(singleton);
	singleton = this;

	finalizing = false;

	gdmono = NULL;

#ifdef NO_THREADS
	lock = NULL;
	gchandle_bind_lock = NULL;
#else
	lock = Mutex::create();
	script_bind_lock = Mutex::create();
#endif

	lang_idx = -1;
}

CSharpLanguage::~CSharpLanguage() {

	finish();

	if (lock) {
		memdelete(lock);
		lock = NULL;
	}

	if (script_bind_lock) {
		memdelete(script_bind_lock);
		script_bind_lock = NULL;
	}

	singleton = NULL;
}

void *CSharpLanguage::alloc_instance_binding_data(Object *p_object) {

#ifdef DEBUG_ENABLED
	// I don't trust you
	if (p_object->get_script_instance())
		CRASH_COND(NULL != CAST_CSHARP_INSTANCE(p_object->get_script_instance()));
#endif

	StringName type_name = p_object->get_class_name();

	// ¯\\_(ツ)_/¯
	const ClassDB::ClassInfo *classinfo = ClassDB::classes.getptr(type_name);
	while (classinfo && !classinfo->exposed)
		classinfo = classinfo->inherits_ptr;
	ERR_FAIL_NULL_V(classinfo, NULL);
	type_name = classinfo->name;

	GDMonoClass *type_class = GDMonoUtils::type_get_proxy_class(type_name);

	ERR_FAIL_NULL_V(type_class, NULL);

	MonoObject *mono_object = GDMonoUtils::create_managed_for_godot_object(type_class, type_name, p_object);

	ERR_FAIL_NULL_V(mono_object, NULL);

	// Tie managed to unmanaged
	Reference *ref = Object::cast_to<Reference>(p_object);

	if (ref) {
		// Unsafe refcount increment. The managed instance also counts as a reference.
		// This way if the unmanaged world has no references to our owner
		// but the managed instance is alive, the refcount will be 1 instead of 0.
		// See: _GodotSharp::_dispose_object(Object *p_object)

		ref->reference();
	}

	Ref<MonoGCHandle> gchandle = MonoGCHandle::create_strong(mono_object);

#ifndef NO_THREADS
	script_bind_lock->lock();
#endif

	void *data = (void *)gchandle_bindings.insert(p_object, gchandle);

#ifndef NO_THREADS
	script_bind_lock->unlock();
#endif

	return data;
}

void CSharpLanguage::free_instance_binding_data(void *p_data) {

	if (GDMono::get_singleton() == NULL) {
#ifdef DEBUG_ENABLED
		CRASH_COND(!gchandle_bindings.empty());
#endif
		// Mono runtime finalized, all the gchandle bindings were already released
		return;
	}

	if (finalizing)
		return; // inside CSharpLanguage::finish(), all the gchandle bindings are released there

#ifndef NO_THREADS
	script_bind_lock->lock();
#endif

	Map<Object *, Ref<MonoGCHandle> >::Element *data = (Map<Object *, Ref<MonoGCHandle> >::Element *)p_data;

	// Set the native instance field to IntPtr.Zero, if not yet garbage collected
	MonoObject *mono_object = data->value()->get_target();
	if (mono_object) {
		CACHED_FIELD(GodotObject, ptr)->set_value_raw(mono_object, NULL);
	}

	gchandle_bindings.erase(data);

#ifndef NO_THREADS
	script_bind_lock->unlock();
#endif
}

CSharpInstance *CSharpInstance::create_for_managed_type(Object *p_owner, CSharpScript *p_script, const Ref<MonoGCHandle> &p_gchandle) {

	CSharpInstance *instance = memnew(CSharpInstance);

	Reference *ref = Object::cast_to<Reference>(p_owner);

	instance->base_ref = ref != NULL;
	instance->script = Ref<CSharpScript>(p_script);
	instance->owner = p_owner;
	instance->gchandle = p_gchandle;

	if (instance->base_ref)
		instance->_reference_owner_unsafe();

	p_script->instances.insert(p_owner);

	return instance;
}

MonoObject *CSharpInstance::get_mono_object() const {
#ifdef DEBUG_ENABLED
	CRASH_COND(gchandle.is_null());
#endif
	return gchandle->get_target();
}

bool CSharpInstance::set(const StringName &p_name, const Variant &p_value) {

	ERR_FAIL_COND_V(!script.is_valid(), false);

	MonoObject *mono_object = get_mono_object();
	ERR_FAIL_NULL_V(mono_object, false);

	GDMonoClass *top = script->script_class;

	while (top && top != script->native) {
		GDMonoField *field = script->script_class->get_field(p_name);

		if (field) {
			field->set_value_from_variant(mono_object, p_value);
			return true;
		}

		GDMonoProperty *property = script->script_class->get_property(p_name);

		if (property) {
			property->set_value(mono_object, GDMonoMarshal::variant_to_mono_object(p_value));
			return true;
		}

		top = top->get_parent_class();
	}

	// Call _set

	top = script->script_class;

	while (top && top != script->native) {
		GDMonoMethod *method = top->get_method(CACHED_STRING_NAME(_set), 2);

		if (method) {
			Variant name = p_name;
			const Variant *args[2] = { &name, &p_value };

			MonoObject *ret = method->invoke(mono_object, args);

			if (ret && GDMonoMarshal::unbox<MonoBoolean>(ret) == true)
				return true;

			break;
		}

		top = top->get_parent_class();
	}

	return false;
}

bool CSharpInstance::get(const StringName &p_name, Variant &r_ret) const {

	ERR_FAIL_COND_V(!script.is_valid(), false);

	MonoObject *mono_object = get_mono_object();
	ERR_FAIL_NULL_V(mono_object, false);

	GDMonoClass *top = script->script_class;

	while (top && top != script->native) {
		GDMonoField *field = top->get_field(p_name);

		if (field) {
			MonoObject *value = field->get_value(mono_object);
			r_ret = GDMonoMarshal::mono_object_to_variant(value);
			return true;
		}

		GDMonoProperty *property = top->get_property(p_name);

		if (property) {
			MonoException *exc = NULL;
			MonoObject *value = property->get_value(mono_object, &exc);
			if (exc) {
				r_ret = Variant();
				GDMonoUtils::set_pending_exception(exc);
			} else {
				r_ret = GDMonoMarshal::mono_object_to_variant(value);
			}
			return true;
		}

		top = top->get_parent_class();
	}

	// Call _get

	top = script->script_class;

	while (top && top != script->native) {
		GDMonoMethod *method = top->get_method(CACHED_STRING_NAME(_get), 1);

		if (method) {
			Variant name = p_name;
			const Variant *args[1] = { &name };

			MonoObject *ret = method->invoke(mono_object, args);

			if (ret) {
				r_ret = GDMonoMarshal::mono_object_to_variant(ret);
				return true;
			}

			break;
		}

		top = top->get_parent_class();
	}

	return false;
}

void CSharpInstance::get_property_list(List<PropertyInfo> *p_properties) const {

	for (Map<StringName, PropertyInfo>::Element *E = script->member_info.front(); E; E = E->next()) {
		p_properties->push_back(E->value());
	}
}

Variant::Type CSharpInstance::get_property_type(const StringName &p_name, bool *r_is_valid) const {

	if (script->member_info.has(p_name)) {
		if (r_is_valid)
			*r_is_valid = true;
		return script->member_info[p_name].type;
	}

	if (r_is_valid)
		*r_is_valid = false;

	return Variant::NIL;
}

bool CSharpInstance::has_method(const StringName &p_method) const {

	if (!script.is_valid())
		return false;

	GDMonoClass *top = script->script_class;

	while (top && top != script->native) {
		if (top->has_fetched_method_unknown_params(p_method)) {
			return true;
		}

		top = top->get_parent_class();
	}

	return false;
}

Variant CSharpInstance::call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error) {

	MonoObject *mono_object = get_mono_object();

	if (!mono_object) {
		r_error.error = Variant::CallError::CALL_ERROR_INSTANCE_IS_NULL;
		ERR_FAIL_V(Variant());
	}

	if (!script.is_valid())
		ERR_FAIL_V(Variant());

	GDMonoClass *top = script->script_class;

	while (top && top != script->native) {
		GDMonoMethod *method = top->get_method(p_method, p_argcount);

		if (method) {
			MonoObject *return_value = method->invoke(mono_object, p_args);

			r_error.error = Variant::CallError::CALL_OK;

			if (return_value) {
				return GDMonoMarshal::mono_object_to_variant(return_value);
			} else {
				return Variant();
			}
		}

		top = top->get_parent_class();
	}

	r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;

	return Variant();
}

void CSharpInstance::call_multilevel(const StringName &p_method, const Variant **p_args, int p_argcount) {

	if (script.is_valid()) {
		MonoObject *mono_object = get_mono_object();

		ERR_FAIL_NULL(mono_object);

		_call_multilevel(mono_object, p_method, p_args, p_argcount);
	}
}

void CSharpInstance::_call_multilevel(MonoObject *p_mono_object, const StringName &p_method, const Variant **p_args, int p_argcount) {

	GDMonoClass *top = script->script_class;

	while (top && top != script->native) {
		GDMonoMethod *method = top->get_method(p_method, p_argcount);

		if (method) {
			method->invoke(p_mono_object, p_args);
			return;
		}

		top = top->get_parent_class();
	}
}

void CSharpInstance::call_multilevel_reversed(const StringName &p_method, const Variant **p_args, int p_argcount) {

	// Sorry, the method is the one that controls the call order

	call_multilevel(p_method, p_args, p_argcount);
}

void CSharpInstance::_reference_owner_unsafe() {

#ifdef DEBUG_ENABLED
	CRASH_COND(!base_ref);
#endif

	// Unsafe refcount increment. The managed instance also counts as a reference.
	// This way if the unmanaged world has no references to our owner
	// but the managed instance is alive, the refcount will be 1 instead of 0.
	// See: _unreference_owner_unsafe()

	// May not me referenced yet, so we must use init_ref() instead of reference()
	Object::cast_to<Reference>(owner)->init_ref();
}

void CSharpInstance::_unreference_owner_unsafe() {

#ifdef DEBUG_ENABLED
	CRASH_COND(!base_ref);
#endif

	// Called from CSharpInstance::mono_object_disposed() or ~CSharpInstance()

	// Unsafe refcount decrement. The managed instance also counts as a reference.
	// See: _reference_owner_unsafe()

	if (Object::cast_to<Reference>(owner)->unreference()) {
		memdelete(owner);
		owner = NULL;
	}
}

void CSharpInstance::mono_object_disposed() {

	if (base_ref)
		_unreference_owner_unsafe();
}

void CSharpInstance::refcount_incremented() {

	CRASH_COND(!base_ref);

	Reference *ref_owner = Object::cast_to<Reference>(owner);

	if (ref_owner->reference_get_count() > 1) { // The managed side also holds a reference, hence 1 instead of 0
		// The reference count was increased after the managed side was the only one referencing our owner.
		// This means the owner is being referenced again by the unmanaged side,
		// so the owner must hold the managed side alive again to avoid it from being GCed.

		// Release the current weak handle and replace it with a strong handle.
		uint32_t strong_gchandle = MonoGCHandle::make_strong_handle(gchandle->get_target());
		gchandle->release();
		gchandle->set_handle(strong_gchandle);
	}
}

bool CSharpInstance::refcount_decremented() {

	CRASH_COND(!base_ref);

	Reference *ref_owner = Object::cast_to<Reference>(owner);

	int refcount = ref_owner->reference_get_count();

	if (refcount == 1) { // The managed side also holds a reference, hence 1 instead of 0
		// If owner owner is no longer referenced by the unmanaged side,
		// the managed instance takes responsibility of deleting the owner when GCed.

		// Release the current strong handle and replace it with a weak handle.
		uint32_t weak_gchandle = MonoGCHandle::make_weak_handle(gchandle->get_target());
		gchandle->release();
		gchandle->set_handle(weak_gchandle);

		return false;
	}

	ref_dying = (refcount == 0);

	return ref_dying;
}

MultiplayerAPI::RPCMode CSharpInstance::_member_get_rpc_mode(GDMonoClassMember *p_member) const {

	if (p_member->has_attribute(CACHED_CLASS(RemoteAttribute)))
		return MultiplayerAPI::RPC_MODE_REMOTE;
	if (p_member->has_attribute(CACHED_CLASS(SyncAttribute)))
		return MultiplayerAPI::RPC_MODE_SYNC;
	if (p_member->has_attribute(CACHED_CLASS(MasterAttribute)))
		return MultiplayerAPI::RPC_MODE_MASTER;
	if (p_member->has_attribute(CACHED_CLASS(SlaveAttribute)))
		return MultiplayerAPI::RPC_MODE_SLAVE;
	if (p_member->has_attribute(CACHED_CLASS(RemoteSyncAttribute)))
		return MultiplayerAPI::RPC_MODE_REMOTESYNC;
	if (p_member->has_attribute(CACHED_CLASS(MasterSyncAttribute)))
		return MultiplayerAPI::RPC_MODE_MASTERSYNC;
	if (p_member->has_attribute(CACHED_CLASS(SlaveSyncAttribute)))
		return MultiplayerAPI::RPC_MODE_SLAVESYNC;

	return MultiplayerAPI::RPC_MODE_DISABLED;
}

MultiplayerAPI::RPCMode CSharpInstance::get_rpc_mode(const StringName &p_method) const {

	GDMonoClass *top = script->script_class;

	while (top && top != script->native) {
		GDMonoMethod *method = top->get_fetched_method_unknown_params(p_method);

		if (method && !method->is_static())
			return _member_get_rpc_mode(method);

		top = top->get_parent_class();
	}

	return MultiplayerAPI::RPC_MODE_DISABLED;
}

MultiplayerAPI::RPCMode CSharpInstance::get_rset_mode(const StringName &p_variable) const {

	GDMonoClass *top = script->script_class;

	while (top && top != script->native) {
		GDMonoField *field = top->get_field(p_variable);

		if (field && !field->is_static())
			return _member_get_rpc_mode(field);

		GDMonoProperty *property = top->get_property(p_variable);

		if (property && !property->is_static())
			return _member_get_rpc_mode(property);

		top = top->get_parent_class();
	}

	return MultiplayerAPI::RPC_MODE_DISABLED;
}

void CSharpInstance::notification(int p_notification) {

	MonoObject *mono_object = get_mono_object();

	if (p_notification == Object::NOTIFICATION_PREDELETE) {
		if (mono_object != NULL) { // otherwise it was collected, and the finalizer already called NOTIFICATION_PREDELETE
			call_notification_no_check(mono_object, p_notification);
			// Set the native instance field to IntPtr.Zero
			CACHED_FIELD(GodotObject, ptr)->set_value_raw(mono_object, NULL);
		}
		return;
	}

	call_notification_no_check(mono_object, p_notification);
}

void CSharpInstance::call_notification_no_check(MonoObject *p_mono_object, int p_notification) {
	Variant value = p_notification;
	const Variant *args[1] = { &value };

	_call_multilevel(p_mono_object, CACHED_STRING_NAME(_notification), args, 1);
}

Ref<Script> CSharpInstance::get_script() const {

	return script;
}

ScriptLanguage *CSharpInstance::get_language() {

	return CSharpLanguage::get_singleton();
}

CSharpInstance::CSharpInstance() {

	owner = NULL;
	base_ref = false;
	ref_dying = false;
}

CSharpInstance::~CSharpInstance() {

	if (gchandle.is_valid()) {
		gchandle->release(); // Make sure it's released
	}

	if (base_ref && !ref_dying) { // it may be called from the owner's destructor
#ifdef DEBUG_ENABLED
		CRASH_COND(!owner); // dunno, just in case
#endif
		_unreference_owner_unsafe();
	}

	if (script.is_valid() && owner) {
#ifndef NO_THREADS
		CSharpLanguage::singleton->lock->lock();
#endif

#ifdef DEBUG_ENABLED
		// CSharpInstance must not be created unless it's going to be added to the list for sure
		Set<Object *>::Element *match = script->instances.find(owner);
		CRASH_COND(!match);
		script->instances.erase(match);
#else
		script->instances.erase(owner);
#endif

#ifndef NO_THREADS
		CSharpLanguage::singleton->lock->unlock();
#endif
	}
}

#ifdef TOOLS_ENABLED
void CSharpScript::_placeholder_erased(PlaceHolderScriptInstance *p_placeholder) {

	placeholders.erase(p_placeholder);
}
#endif

#ifdef TOOLS_ENABLED
void CSharpScript::_update_exports_values(Map<StringName, Variant> &values, List<PropertyInfo> &propnames) {

	if (base_cache.is_valid()) {
		base_cache->_update_exports_values(values, propnames);
	}

	for (Map<StringName, Variant>::Element *E = exported_members_defval_cache.front(); E; E = E->next()) {
		values[E->key()] = E->get();
	}

	for (List<PropertyInfo>::Element *E = exported_members_cache.front(); E; E = E->next()) {
		propnames.push_back(E->get());
	}
}
#endif

bool CSharpScript::_update_exports() {

#ifdef TOOLS_ENABLED
	if (!valid)
		return false;

	bool changed = false;

	if (exports_invalidated) {
		exports_invalidated = false;

		changed = true;

		member_info.clear();
		exported_members_cache.clear();
		exported_members_defval_cache.clear();

		// We are creating a temporary new instance of the class here to get the default value
		// TODO Workaround. Should be replaced with IL opcodes analysis

		MonoObject *tmp_object = mono_object_new(SCRIPTS_DOMAIN, script_class->get_mono_ptr());

		if (tmp_object) {
			CACHED_FIELD(GodotObject, ptr)->set_value_raw(tmp_object, tmp_object); // FIXME WTF is this workaround

			GDMonoMethod *ctor = script_class->get_method(CACHED_STRING_NAME(dotctor), 0);
			MonoException *exc = NULL;
			ctor->invoke(tmp_object, NULL, &exc);

			if (exc) {
				ERR_PRINT(""Exception thrown from constructor of temporary MonoObject:"");
				GDMonoUtils::debug_print_unhandled_exception(exc);
				tmp_object = NULL;
				ERR_FAIL_V(false);
			}
		} else {
			ERR_PRINT(""Failed to create temporary MonoObject"");
			return false;
		}

		GDMonoClass *top = script_class;

		while (top && top != native) {
			PropertyInfo prop_info;
			bool exported;

			const Vector<GDMonoField *> &fields = top->get_all_fields();

			for (int i = fields.size() - 1; i >= 0; i--) {
				GDMonoField *field = fields[i];

				if (_get_member_export(top, field, prop_info, exported)) {
					StringName name = field->get_name();

					if (exported) {
						member_info[name] = prop_info;
						exported_members_cache.push_front(prop_info);

						if (tmp_object) {
							exported_members_defval_cache[name] = GDMonoMarshal::mono_object_to_variant(field->get_value(tmp_object));
						}
					} else {
						member_info[name] = prop_info;
					}
				}
			}

			const Vector<GDMonoProperty *> &properties = top->get_all_properties();

			for (int i = properties.size() - 1; i >= 0; i--) {
				GDMonoProperty *property = properties[i];

				if (_get_member_export(top, property, prop_info, exported)) {
					StringName name = property->get_name();

					if (exported) {
						member_info[name] = prop_info;
						exported_members_cache.push_front(prop_info);

						if (tmp_object) {
							MonoException *exc = NULL;
							MonoObject *ret = property->get_value(tmp_object, &exc);
							if (exc) {
								exported_members_defval_cache[name] = Variant();
								GDMonoUtils::debug_print_unhandled_exception(exc);
							} else {
								exported_members_defval_cache[name] = GDMonoMarshal::mono_object_to_variant(ret);
							}
						}
					} else {
						member_info[name] = prop_info;
					}
				}
			}

			top = top->get_parent_class();
		}
	}

	if (placeholders.size()) {
		// Update placeholders if any
		Map<StringName, Variant> values;
		List<PropertyInfo> propnames;
		_update_exports_values(values, propnames);

		for (Set<PlaceHolderScriptInstance *>::Element *E = placeholders.front(); E; E = E->next()) {
			E->get()->update(propnames, values);
		}
	}

	return changed;
#endif
	return false;
}

void CSharpScript::load_script_signals(GDMonoClass *p_class, GDMonoClass *p_native_class) {

	// no need to load the script's signals more than once
	if (!signals_invalidated) {
		return;
	}

	// make sure this classes signals are empty when loading for the first time
	_signals.clear();

	GDMonoClass *top = p_class;
	while (top && top != p_native_class) {
		const Vector<GDMonoClass *> &delegates = top->get_all_delegates();
		for (int i = delegates.size() - 1; i >= 0; --i) {
			Vector<Argument> parameters;

			GDMonoClass *delegate = delegates[i];

			if (_get_signal(top, delegate, parameters)) {
				_signals[delegate->get_name()] = parameters;
			}
		}

		top = top->get_parent_class();
	}

	signals_invalidated = false;
}

bool CSharpScript::_get_signal(GDMonoClass *p_class, GDMonoClass *p_delegate, Vector<Argument> &params) {
	if (p_delegate->has_attribute(CACHED_CLASS(SignalAttribute))) {
		MonoType *raw_type = GDMonoClass::get_raw_type(p_delegate);

		if (mono_type_get_type(raw_type) == MONO_TYPE_CLASS) {
			// Arguments are accessibles as arguments of .Invoke method
			GDMonoMethod *invoke = p_delegate->get_method(""Invoke"", -1);

			Vector<StringName> names;
			Vector<ManagedType> types;
			invoke->get_parameter_names(names);
			invoke->get_parameter_types(types);

			if (names.size() == types.size()) {
				for (int i = 0; i < names.size(); ++i) {
					Argument arg;
					arg.name = names[i];
					arg.type = GDMonoMarshal::managed_to_variant_type(types[i]);

					if (arg.type == Variant::NIL) {
						ERR_PRINTS(""Unknown type of signal parameter: "" + arg.name + "" in "" + p_class->get_full_name());
						return false;
					}

					params.push_back(arg);
				}

				return true;
			}
		}
	}

	return false;
}

#ifdef TOOLS_ENABLED
bool CSharpScript::_get_member_export(GDMonoClass *p_class, GDMonoClassMember *p_member, PropertyInfo &r_prop_info, bool &r_exported) {

	StringName name = p_member->get_name();

	if (p_member->is_static()) {
		if (p_member->has_attribute(CACHED_CLASS(ExportAttribute)))
			ERR_PRINTS(""Cannot export member because it is static: "" + p_class->get_full_name() + ""."" + name.operator String());
		return false;
	}

	if (member_info.has(name))
		return false;

	ManagedType type;

	if (p_member->get_member_type() == GDMonoClassMember::MEMBER_TYPE_FIELD) {
		type = static_cast<GDMonoField *>(p_member)->get_type();
	} else if (p_member->get_member_type() == GDMonoClassMember::MEMBER_TYPE_PROPERTY) {
		type = static_cast<GDMonoProperty *>(p_member)->get_type();
	} else {
		CRASH_NOW();
	}

	Variant::Type variant_type = GDMonoMarshal::managed_to_variant_type(type);

	if (p_member->has_attribute(CACHED_CLASS(ExportAttribute))) {
		if (p_member->get_member_type() == GDMonoClassMember::MEMBER_TYPE_PROPERTY) {
			GDMonoProperty *property = static_cast<GDMonoProperty *>(p_member);
			if (!property->has_getter() || !property->has_setter()) {
				ERR_PRINTS(""Cannot export property because it does not provide a getter or a setter: "" + p_class->get_full_name() + ""."" + name.operator String());
				return false;
			}
		}

		MonoObject *attr = p_member->get_attribute(CACHED_CLASS(ExportAttribute));

		PropertyHint hint;
		String hint_string;

		if (variant_type == Variant::NIL) {
			ERR_PRINTS(""Unknown type of exported member: "" + p_class->get_full_name() + ""."" + name.operator String());
			return false;
		} else if (variant_type == Variant::INT && type.type_encoding == MONO_TYPE_VALUETYPE && mono_class_is_enum(type.type_class->get_mono_ptr())) {
			variant_type = Variant::INT;
			hint = PROPERTY_HINT_ENUM;

			Vector<MonoClassField *> fields = type.type_class->get_enum_fields();

			for (int i = 0; i < fields.size(); i++) {
				if (i > 0)
					hint_string += "","";
				hint_string += mono_field_get_name(fields[i]);
			}
		} else if (variant_type == Variant::OBJECT && CACHED_CLASS(GodotReference)->is_assignable_from(type.type_class)) {
			hint = PROPERTY_HINT_RESOURCE_TYPE;
			hint_string = NATIVE_GDMONOCLASS_NAME(type.type_class);
		} else {
			hint = PropertyHint(CACHED_FIELD(ExportAttribute, hint)->get_int_value(attr));
			hint_string = CACHED_FIELD(ExportAttribute, hintString)->get_string_value(attr);
		}

		r_prop_info = PropertyInfo(variant_type, name.operator String(), hint, hint_string, PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_SCRIPT_VARIABLE);
		r_exported = true;
	} else {
		r_prop_info = PropertyInfo(variant_type, name.operator String(), PROPERTY_HINT_NONE, """", PROPERTY_USAGE_SCRIPT_VARIABLE);
		r_exported = false;
	}

	return true;
}
#endif

void CSharpScript::_clear() {

	tool = false;
	valid = false;

	base = NULL;
	native = NULL;
	script_class = NULL;
}

Variant CSharpScript::call(const StringName &p_method, const Variant **p_args, int p_argcount, Variant::CallError &r_error) {

	if (unlikely(GDMono::get_singleton() == NULL)) {
		// Probably not the best error but eh.
		r_error.error = Variant::CallError::CALL_ERROR_INSTANCE_IS_NULL;
		return Variant();
	}

	GDMonoClass *top = script_class;

	while (top && top != native) {
		GDMonoMethod *method = top->get_method(p_method, p_argcount);

		if (method && method->is_static()) {
			MonoObject *result = method->invoke(NULL, p_args);

			if (result) {
				return GDMonoMarshal::mono_object_to_variant(result);
			} else {
				return Variant();
			}
		}

		top = top->get_parent_class();
	}

	// No static method found. Try regular instance calls
	return Script::call(p_method, p_args, p_argcount, r_error);
}

void CSharpScript::_resource_path_changed() {

	String path = get_path();

	if (!path.empty()) {
		name = get_path().get_file().get_basename();
	}
}

bool CSharpScript::_get(const StringName &p_name, Variant &r_ret) const {

	if (p_name == CSharpLanguage::singleton->string_names._script_source) {

		r_ret = get_source_code();
		return true;
	}

	return false;
}

bool CSharpScript::_set(const StringName &p_name, const Variant &p_value) {

	if (p_name == CSharpLanguage::singleton->string_names._script_source) {

		set_source_code(p_value);
		reload();
		return true;
	}

	return false;
}

void CSharpScript::_get_property_list(List<PropertyInfo> *p_properties) const {

	p_properties->push_back(PropertyInfo(Variant::STRING, CSharpLanguage::singleton->string_names._script_source, PROPERTY_HINT_NONE, """", PROPERTY_USAGE_NOEDITOR | PROPERTY_USAGE_INTERNAL));
}

void CSharpScript::_bind_methods() {

	ClassDB::bind_vararg_method(METHOD_FLAGS_DEFAULT, ""new"", &CSharpScript::_new, MethodInfo(Variant::OBJECT, ""new""));
}

Ref<CSharpScript> CSharpScript::create_for_managed_type(GDMonoClass *p_class) {

	// This method should not fail

	CRASH_COND(!p_class);

	Ref<CSharpScript> script = memnew(CSharpScript);

	script->name = p_class->get_name();
	script->script_class = p_class;
	script->native = GDMonoUtils::get_class_native_base(script->script_class);

	CRASH_COND(script->native == NULL);

	GDMonoClass *base = script->script_class->get_parent_class();

	if (base != script->native)
		script->base = base;

#ifdef DEBUG_ENABLED
	// For debug builds, we must fetch from all native base methods as well.
	// Native base methods must be fetched before the current class.
	// Not needed if the script class itself is a native class.

	if (script->script_class != script->native) {
		GDMonoClass *native_top = script->native;
		while (native_top) {
			native_top->fetch_methods_with_godot_api_checks(script->native);

			if (native_top == CACHED_CLASS(GodotObject))
				break;

			native_top = native_top->get_parent_class();
		}
	}
#endif

	script->script_class->fetch_methods_with_godot_api_checks(script->native);

	// Need to fetch method from base classes as well
	GDMonoClass *top = script->script_class;
	while (top && top != script->native) {
		top->fetch_methods_with_godot_api_checks(script->native);
		top = top->get_parent_class();
	}

	script->load_script_signals(script->script_class, script->native);

	return script;
}

bool CSharpScript::can_instance() const {

#ifdef TOOLS_ENABLED
	if (Engine::get_singleton()->is_editor_hint()) {

		if (get_path().find(""::"") == -1) { // Ignore if built-in script. Can happen if the file is deleted...
			if (_create_project_solution_if_needed()) {
				CSharpProject::add_item(GodotSharpDirs::get_project_csproj_path(),
						""Compile"",
						ProjectSettings::get_singleton()->globalize_path(get_path()));
			} else {
				ERR_PRINTS(""Cannot add "" + get_path() + "" to the C# project because it could not be created."");
			}
		}
	}
#endif

	return valid || (!tool && !ScriptServer::is_scripting_enabled());
}

StringName CSharpScript::get_instance_base_type() const {

	if (native)
		return native->get_name();
	else
		return StringName();
}

CSharpInstance *CSharpScript::_create_instance(const Variant **p_args, int p_argcount, Object *p_owner, bool p_isref, Variant::CallError &r_error) {

	/* STEP 1, CREATE */

	CSharpInstance *instance = memnew(CSharpInstance);
	instance->base_ref = p_isref;
	instance->script = Ref<CSharpScript>(this);
	instance->owner = p_owner;
	instance->owner->set_script_instance(instance);

	if (instance->base_ref)
		instance->_reference_owner_unsafe();

	/* STEP 2, INITIALIZE AND CONSTRUCT */

	MonoObject *mono_object = mono_object_new(SCRIPTS_DOMAIN, script_class->get_mono_ptr());

	if (!mono_object) {
		instance->script = Ref<CSharpScript>();
		instance->owner->set_script_instance(NULL);
		r_error.error = Variant::CallError::CALL_ERROR_INSTANCE_IS_NULL;
		ERR_EXPLAIN(""Failed to allocate memory for the object"");
		ERR_FAIL_V(NULL);
	}

#ifndef NO_THREADS
	CSharpLanguage::singleton->lock->lock();
#endif

	instances.insert(instance->owner);

#ifndef NO_THREADS
	CSharpLanguage::singleton->lock->unlock();
#endif

	CACHED_FIELD(GodotObject, ptr)->set_value_raw(mono_object, instance->owner);

	// Construct
	GDMonoMethod *ctor = script_class->get_method(CACHED_STRING_NAME(dotctor), p_argcount);
	ctor->invoke(mono_object, p_args);

	// Tie managed to unmanaged
	instance->gchandle = MonoGCHandle::create_strong(mono_object);

	/* STEP 3, PARTY */

	//@TODO make thread safe
	return instance;
}

Variant CSharpScript::_new(const Variant **p_args, int p_argcount, Variant::CallError &r_error) {

	if (!valid) {
		r_error.error = Variant::CallError::CALL_ERROR_INVALID_METHOD;
		return Variant();
	}

	r_error.error = Variant::CallError::CALL_OK;
	REF ref;
	Object *owner = NULL;

	ERR_FAIL_NULL_V(native, Variant());

	owner = ClassDB::instance(NATIVE_GDMONOCLASS_NAME(native));

	Reference *r = Object::cast_to<Reference>(owner);
	if (r) {
		ref = REF(r);
	}

	CSharpInstance *instance = _create_instance(p_args, p_argcount, owner, r != NULL, r_error);
	if (!instance) {
		if (ref.is_null()) {
			memdelete(owner); //no owner, sorry
		}
		return Variant();
	}

	if (ref.is_valid()) {
		return ref;
	} else {
		return owner;
	}
}

ScriptInstance *CSharpScript::instance_create(Object *p_this) {

	ERR_FAIL_COND_V(!valid, NULL);

	if (!tool && !ScriptServer::is_scripting_enabled()) {
#ifdef TOOLS_ENABLED
		PlaceHolderScriptInstance *si = memnew(PlaceHolderScriptInstance(CSharpLanguage::get_singleton(), Ref<Script>(this), p_this));
		placeholders.insert(si);
		_update_exports();
		return si;
#else
		return NULL;
#endif
	}

	if (!script_class) {
		if (GDMono::get_singleton()->get_project_assembly() == NULL) {
			// The project assembly is not loaded
			ERR_EXPLAIN(""Cannot instance script because the project assembly is not loaded. Script: "" + get_path());
			ERR_FAIL_V(NULL);
		}

		// The project assembly is loaded, but the class could not found
		ERR_EXPLAIN(""Cannot instance script because the class '"" + name + ""' could not be found. Script: "" + get_path());
		ERR_FAIL_V(NULL);
	}

	if (native) {
		String native_name = native->get_name();
		if (!ClassDB::is_parent_class(p_this->get_class_name(), native_name)) {
			if (ScriptDebugger::get_singleton()) {
				CSharpLanguage::get_singleton()->debug_break_parse(get_path(), 0, ""Script inherits from native type '"" + native_name + ""', so it can't be instanced in object of type: '"" + p_this->get_class() + ""'"");
			}
			ERR_EXPLAIN(""Script inherits from native type '"" + native_name + ""', so it can't be instanced in object of type: '"" + p_this->get_class() + ""'"");
			ERR_FAIL_V(NULL);
		}
	}

	Variant::CallError unchecked_error;
	return _create_instance(NULL, 0, p_this, Object::cast_to<Reference>(p_this), unchecked_error);
}

bool CSharpScript::instance_has(const Object *p_this) const {

#ifndef NO_THREADS
	CSharpLanguage::singleton->lock->lock();
#endif

	bool ret = instances.has((Object *)p_this);

#ifndef NO_THREADS
	CSharpLanguage::singleton->lock->unlock();
#endif

	return ret;
}

bool CSharpScript::has_source_code() const {

	return !source.empty();
}

String CSharpScript::get_source_code() const {

	return source;
}

void CSharpScript::set_source_code(const String &p_code) {

	if (source == p_code)
		return;
	source = p_code;
#ifdef TOOLS_ENABLED
	source_changed_cache = true;
#endif
}

bool CSharpScript::has_method(const StringName &p_method) const {

	return script_class->has_fetched_method_unknown_params(p_method);
}

Error CSharpScript::reload(bool p_keep_state) {

#ifndef NO_THREADS
	CSharpLanguage::singleton->lock->lock();
#endif

	bool has_instances = instances.size();

#ifndef NO_THREADS
	CSharpLanguage::singleton->lock->unlock();
#endif

	ERR_FAIL_COND_V(!p_keep_state && has_instances, ERR_ALREADY_IN_USE);

	GDMonoAssembly *project_assembly = GDMono::get_singleton()->get_project_assembly();

	if (project_assembly) {
		script_class = project_assembly->get_object_derived_class(name);

		valid = script_class != NULL;

		if (script_class) {
#ifdef DEBUG_ENABLED
			OS::get_singleton()->print(String(""Found class "" + script_class->get_namespace() + ""."" +
											  script_class->get_name() + "" for script "" + get_path() + ""\\n"")
											   .utf8());
#endif

			tool = script_class->has_attribute(CACHED_CLASS(ToolAttribute));

			native = GDMonoUtils::get_class_native_base(script_class);

			CRASH_COND(native == NULL);

			GDMonoClass *base_class = script_class->get_parent_class();

			if (base_class != native)
				base = base_class;

#ifdef DEBUG_ENABLED
			// For debug builds, we must fetch from all native base methods as well.
			// Native base methods must be fetched before the current class.
			// Not needed if the script class itself is a native class.

			if (script_class != native) {
				GDMonoClass *native_top = native;
				while (native_top) {
					native_top->fetch_methods_with_godot_api_checks(native);

					if (native_top == CACHED_CLASS(GodotObject))
						break;

					native_top = native_top->get_parent_class();
				}
			}
#endif

			script_class->fetch_methods_with_godot_api_checks(native);

			// Need to fetch method from base classes as well
			GDMonoClass *top = script_class;
			while (top && top != native) {
				top->fetch_methods_with_godot_api_checks(native);
				top = top->get_parent_class();
			}

			load_script_signals(script_class, native);
		}

		return OK;
	}

	return ERR_FILE_MISSING_DEPENDENCIES;
}

ScriptLanguage *CSharpScript::get_language() const {

	return CSharpLanguage::get_singleton();
}

bool CSharpScript::get_property_default_value(const StringName &p_property, Variant &r_value) const {

#ifdef TOOLS_ENABLED

	const Map<StringName, Variant>::Element *E = exported_members_defval_cache.find(p_property);
	if (E) {
		r_value = E->get();
		return true;
	}

	if (base_cache.is_valid()) {
		return base_cache->get_property_default_value(p_property, r_value);
	}

#endif
	return false;
}

void CSharpScript::update_exports() {

#ifdef TOOLS_ENABLED
	_update_exports();
#endif
}

bool CSharpScript::has_script_signal(const StringName &p_signal) const {
	if (_signals.has(p_signal))
		return true;

	return false;
}

void CSharpScript::get_script_signal_list(List<MethodInfo> *r_signals) const {
	for (const Map<StringName, Vector<Argument> >::Element *E = _signals.front(); E; E = E->next()) {
		MethodInfo mi;

		mi.name = E->key();
		for (int i = 0; i < E->get().size(); i++) {
			PropertyInfo arg;
			arg.name = E->get()[i].name;
			mi.arguments.push_back(arg);
		}
		r_signals->push_back(mi);
	}
}

Ref<Script> CSharpScript::get_base_script() const {

	// TODO search in metadata file once we have it, not important any way?
	return Ref<Script>();
}

void CSharpScript::get_script_property_list(List<PropertyInfo> *p_list) const {

	for (Map<StringName, PropertyInfo>::Element *E = member_info.front(); E; E = E->next()) {
		p_list->push_back(E->value());
	}
}

int CSharpScript::get_member_line(const StringName &p_member) const {

	// TODO omnisharp
	return -1;
}

Error CSharpScript::load_source_code(const String &p_path) {

	PoolVector<uint8_t> sourcef;
	Error err;
	FileAccess *f = FileAccess::open(p_path, FileAccess::READ, &err);
	ERR_FAIL_COND_V(err != OK, err);

	int len = f->get_len();
	sourcef.resize(len + 1);
	PoolVector<uint8_t>::Write w = sourcef.write();
	int r = f->get_buffer(w.ptr(), len);
	f->close();
	memdelete(f);
	ERR_FAIL_COND_V(r != len, ERR_CANT_OPEN);
	w[len] = 0;

	String s;
	if (s.parse_utf8((const char *)w.ptr())) {

		ERR_EXPLAIN(""Script '"" + p_path + ""' contains invalid unicode (utf-8), so it was not loaded. Please ensure that scripts are saved in valid utf-8 unicode."");
		ERR_FAIL_V(ERR_INVALID_DATA);
	}

	source = s;

#ifdef TOOLS_ENABLED
	source_changed_cache = true;
#endif

	return OK;
}

StringName CSharpScript::get_script_name() const {

	return name;
}

CSharpScript::CSharpScript() :
		script_list(this) {

	_clear();

#ifdef TOOLS_ENABLED
	source_changed_cache = false;
	exports_invalidated = true;
#endif

	signals_invalidated = true;

	_resource_path_changed();

#ifdef DEBUG_ENABLED

#ifndef NO_THREADS
	CSharpLanguage::get_singleton()->lock->lock();
#endif

	CSharpLanguage::get_singleton()->script_list.add(&script_list);

#ifndef NO_THREADS
	CSharpLanguage::get_singleton()->lock->unlock();
#endif

#endif // DEBUG_ENABLED
}

CSharpScript::~CSharpScript() {

#ifdef DEBUG_ENABLED

#ifndef NO_THREADS
	CSharpLanguage::get_singleton()->lock->lock();
#endif

	CSharpLanguage::get_singleton()->script_list.remove(&script_list);

#ifndef NO_THREADS
	CSharpLanguage::get_singleton()->lock->unlock();
#endif

#endif // DEBUG_ENABLED
}

/*************** RESOURCE ***************/

RES ResourceFormatLoaderCSharpScript::load(const String &p_path, const String &p_original_path, Error *r_error) {

	if (r_error)
		*r_error = ERR_FILE_CANT_OPEN;

	// TODO ignore anything inside bin/ and obj/ in tools builds?

	CSharpScript *script = memnew(CSharpScript);

	Ref<CSharpScript> scriptres(script);

#if defined(DEBUG_ENABLED) || defined(TOOLS_ENABLED)
	Error err = script->load_source_code(p_path);
	ERR_FAIL_COND_V(err != OK, RES());
#endif

	script->set_path(p_original_path);

#ifndef TOOLS_ENABLED

#ifdef DEBUG_ENABLED
	// User is responsible for thread attach/detach
	ERR_EXPLAIN(""Thread is not attached"");
	CRASH_COND(mono_domain_get() == NULL);
#endif

#endif

#ifdef TOOLS_ENABLED
	if (Engine::get_singleton()->is_editor_hint() && mono_domain_get() == NULL) {

		CRASH_COND(Thread::get_caller_id() == Thread::get_main_id());

		// Thread is not attached, but we will make an exception in this case
		// because this may be called by one of the editor's worker threads.
		// Attach this thread temporarily to reload the script.

		if (SCRIPTS_DOMAIN) {
			MonoThread *mono_thread = mono_thread_attach(SCRIPTS_DOMAIN);
			CRASH_COND(mono_thread == NULL);
			script->reload();
			mono_thread_detach(mono_thread);
		}

	} else { // just reload it normally
#endif
		script->reload();

#ifdef TOOLS_ENABLED
	}
#endif

	if (r_error)
		*r_error = OK;

	return scriptres;
}

void ResourceFormatLoaderCSharpScript::get_recognized_extensions(List<String> *p_extensions) const {

	p_extensions->push_back(""cs"");
}

bool ResourceFormatLoaderCSharpScript::handles_type(const String &p_type) const {

	return p_type == ""Script"" || p_type == CSharpLanguage::get_singleton()->get_type();
}

String ResourceFormatLoaderCSharpScript::get_resource_type(const String &p_path) const {

	return p_path.get_extension().to_lower() == ""cs"" ? CSharpLanguage::get_singleton()->get_type() : """";
}

Error ResourceFormatSaverCSharpScript::save(const String &p_path, const RES &p_resource, uint32_t p_flags) {

	Ref<CSharpScript> sqscr = p_resource;
	ERR_FAIL_COND_V(sqscr.is_null(), ERR_INVALID_PARAMETER);

	String source = sqscr->get_source_code();

#ifdef TOOLS_ENABLED
	if (!FileAccess::exists(p_path)) {
		// The file does not yet exists, let's assume the user just created this script

		if (_create_project_solution_if_needed()) {
			CSharpProject::add_item(GodotSharpDirs::get_project_csproj_path(),
					""Compile"",
					ProjectSettings::get_singleton()->globalize_path(p_path));
		} else {
			ERR_PRINTS(""Cannot add "" + p_path + "" to the C# project because it could not be created."");
		}
	}
#endif

	Error err;
	FileAccess *file = FileAccess::open(p_path, FileAccess::WRITE, &err);
	ERR_FAIL_COND_V(err, err);

	file->store_string(source);

	if (file->get_error() != OK && file->get_error() != ERR_FILE_EOF) {
		memdelete(file);
		return ERR_CANT_CREATE;
	}

	file->close();
	memdelete(file);

	if (ScriptServer::is_reload_scripts_on_save_enabled()) {
		CSharpLanguage::get_singleton()->reload_tool_script(p_resource, false);
	}

	return OK;
}

void ResourceFormatSaverCSharpScript::get_recognized_extensions(const RES &p_resource, List<String> *p_extensions) const {

	if (Object::cast_to<CSharpScript>(p_resource.ptr())) {
		p_extensions->push_back(""cs"");
	}
}

bool ResourceFormatSaverCSharpScript::recognize(const RES &p_resource) const {

	return Object::cast_to<CSharpScript>(p_resource.ptr()) != NULL;
}

CSharpLanguage::StringNameCache::StringNameCache() {

	_signal_callback = StaticCString::create(""_signal_callback"");
	_set = StaticCString::create(""_set"");
	_get = StaticCString::create(""_get"");
	_notification = StaticCString::create(""_notification"");
	_script_source = StaticCString::create(""script/source"");
	dotctor = StaticCString::create("".ctor"");
}
",16295,True,2924.224898645695,median
"/******************************************************************************
 * Copyright (c) 2011, Duane Merrill.  All rights reserved.
 * Copyright (c) 2011-2017, NVIDIA CORPORATION.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *     * Redistributions of source code must retain the above copyright
 *       notice, this list of conditions and the following disclaimer.
 *     * Redistributions in binary form must reproduce the above copyright
 *       notice, this list of conditions and the following disclaimer in the
 *       documentation and/or other materials provided with the distribution.
 *     * Neither the name of the NVIDIA CORPORATION nor the
 *       names of its contributors may be used to endorse or promote products
 *       derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS"" AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 * DISCLAIMED. IN NO EVENT SHALL NVIDIA CORPORATION 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.
 *
 ******************************************************************************/

/******************************************************************************
 * Test of DeviceHistogram utilities
 ******************************************************************************/

// Ensure printing of CUDA runtime errors to console
#define CUB_STDERR

#include <stdio.h>
#include <limits>
#include <algorithm>
#include <typeinfo>

#if defined(QUICK_TEST) || defined(QUICKER_TEST)
    #include <npp.h>
#endif

#include <cub/util_allocator.cuh>
#include <cub/iterator/constant_input_iterator.cuh>
#include <cub/device/device_histogram.cuh>

#include ""test_util.h""

using namespace cub;

#undef CUB_RUNTIME_FUNCTION
#define CUB_RUNTIME_FUNCTION __host__


//---------------------------------------------------------------------
// Globals, constants and typedefs
//---------------------------------------------------------------------


// Dispatch types
enum Backend
{
    CUB,        // CUB method
    NPP,        // NPP method
    CDP,        // GPU-based (dynamic parallelism) dispatch to CUB method
};


bool                    g_verbose_input     = false;
bool                    g_verbose           = false;
int                     g_timing_iterations = 0;
int                     g_repeat            = 0;
CachingDeviceAllocator  g_allocator(true);




//---------------------------------------------------------------------
// Dispatch to NPP histogram
//---------------------------------------------------------------------

#if defined(QUICK_TEST) || defined(QUICKER_TEST)

/**
 * Dispatch to single-channel 8b NPP histo-even
 */
template <typename CounterT, typename LevelT, typename OffsetT>
CUB_RUNTIME_FUNCTION __forceinline__
hipError_t DispatchEven(
    Int2Type<1>             num_channels,
    Int2Type<1>             num_active_channels,
    Int2Type<NPP>           dispatch_to,
    int                     timing_timing_iterations,
    size_t                  *d_temp_storage_bytes,
    hipError_t             *d_cdp_error,

    void*               d_temp_storage,
    size_t&             temp_storage_bytes,
    unsigned char       *d_samples,               ///< [in] The pointer to the multi-channel input sequence of data samples. The samples from different channels are assumed to be interleaved (e.g., an array of 32-bit pixels where each pixel consists of four RGBA 8-bit samples).
    CounterT            *d_histogram[1],          ///< [out] The pointers to the histogram counter output arrays, one for each active channel.  For channel<sub><em>i</em></sub>, the allocation length of <tt>d_histograms[i]</tt> should be <tt>num_levels[i]</tt> - 1.
    int                 num_levels[1],            ///< [in] The number of boundaries (levels) for delineating histogram samples in each active channel.  Implies that the number of bins for channel<sub><em>i</em></sub> is <tt>num_levels[i]</tt> - 1.
    LevelT              lower_level[1],           ///< [in] The lower sample value bound (inclusive) for the lowest histogram bin in each active channel.
    LevelT              upper_level[1],           ///< [in] The upper sample value bound (exclusive) for the highest histogram bin in each active channel.
    OffsetT             num_row_pixels,           ///< [in] The number of multi-channel pixels per row in the region of interest
    OffsetT             num_rows,                 ///< [in] The number of rows in the region of interest
    OffsetT             row_stride_bytes,         ///< [in] The number of bytes between starts of consecutive rows in the region of interest
    hipStream_t        stream,
    bool                debug_synchronous)
{
    typedef unsigned char SampleT;

    hipError_t error = hipSuccess;
    NppiSize oSizeROI = {
        num_row_pixels,
        num_rows
    };

    if (d_temp_storage_bytes == NULL)
    {
        int nDeviceBufferSize;
        nppiHistogramEvenGetBufferSize_8u_C1R(oSizeROI, num_levels[0] ,&nDeviceBufferSize);
        temp_storage_bytes = nDeviceBufferSize;
    }
    else
    {
        for (int i = 0; i < timing_timing_iterations; ++i)
        {
            // compute the histogram
            nppiHistogramEven_8u_C1R(
                d_samples,
                row_stride_bytes,
                oSizeROI,
                d_histogram[0],
                num_levels[0],
                lower_level[0],
                upper_level[0],
                (Npp8u*) d_temp_storage);
        }
    }

    return error;
}


/**
 * Dispatch to 3/4 8b NPP histo-even
 */
template <typename CounterT, typename LevelT, typename OffsetT>
CUB_RUNTIME_FUNCTION __forceinline__
hipError_t DispatchEven(
    Int2Type<4>          num_channels,
    Int2Type<3>   num_active_channels,
    Int2Type<NPP>           dispatch_to,
    int                     timing_timing_iterations,
    size_t                  *d_temp_storage_bytes,
    hipError_t             *d_cdp_error,

    void*               d_temp_storage,
    size_t&             temp_storage_bytes,
    unsigned char       *d_samples,               ///< [in] The pointer to the multi-channel input sequence of data samples. The samples from different channels are assumed to be interleaved (e.g., an array of 32-bit pixels where each pixel consists of four RGBA 8-bit samples).
    CounterT            *d_histogram[3],          ///< [out] The pointers to the histogram counter output arrays, one for each active channel.  For channel<sub><em>i</em></sub>, the allocation length of <tt>d_histograms[i]</tt> should be <tt>num_levels[i]</tt> - 1.
    int                 num_levels[3],            ///< [in] The number of boundaries (levels) for delineating histogram samples in each active channel.  Implies that the number of bins for channel<sub><em>i</em></sub> is <tt>num_levels[i]</tt> - 1.
    LevelT              lower_level[3],           ///< [in] The lower sample value bound (inclusive) for the lowest histogram bin in each active channel.
    LevelT              upper_level[3],           ///< [in] The upper sample value bound (exclusive) for the highest histogram bin in each active channel.
    OffsetT             num_row_pixels,           ///< [in] The number of multi-channel pixels per row in the region of interest
    OffsetT             num_rows,                 ///< [in] The number of rows in the region of interest
    OffsetT             row_stride_bytes,         ///< [in] The number of bytes between starts of consecutive rows in the region of interest
    hipStream_t        stream,
    bool                debug_synchronous)
{
    typedef unsigned char SampleT;

    hipError_t error = hipSuccess;
    NppiSize oSizeROI = {
        num_row_pixels,
        num_rows
    };

    if (d_temp_storage_bytes == NULL)
    {
        int nDeviceBufferSize;
        nppiHistogramEvenGetBufferSize_8u_AC4R(oSizeROI, num_levels ,&nDeviceBufferSize);
        temp_storage_bytes = nDeviceBufferSize;
    }
    else
    {
        for (int i = 0; i < timing_timing_iterations; ++i)
        {
            // compute the histogram
            nppiHistogramEven_8u_AC4R(
                d_samples,
                row_stride_bytes,
                oSizeROI,
                d_histogram,
                num_levels,
                lower_level,
                upper_level,
                (Npp8u*) d_temp_storage);
        }
    }

    return error;
}


#endif // #if defined(QUICK_TEST) || defined(QUICKER_TEST)


//---------------------------------------------------------------------
// Dispatch to different DeviceHistogram entrypoints
//---------------------------------------------------------------------

/**
 * Dispatch to CUB single histogram-even entrypoint
 */
template <typename SampleIteratorT, typename CounterT, typename LevelT, typename OffsetT>
CUB_RUNTIME_FUNCTION __forceinline__
hipError_t DispatchEven(
    Int2Type<1>             num_channels,
    Int2Type<1>             num_active_channels,
    Int2Type<CUB>           dispatch_to,
    int                     timing_timing_iterations,
    size_t                  *d_temp_storage_bytes,
    hipError_t             *d_cdp_error,

    void*               d_temp_storage,
    size_t&             temp_storage_bytes,
    SampleIteratorT     d_samples,                                  ///< [in] The pointer to the multi-channel input sequence of data samples. The samples from different channels are assumed to be interleaved (e.g., an array of 32-bit pixels where each pixel consists of four RGBA 8-bit samples).
    CounterT            *d_histogram[1],                            ///< [out] The pointers to the histogram counter output arrays, one for each active channel.  For channel<sub><em>i</em></sub>, the allocation length of <tt>d_histograms[i]</tt> should be <tt>num_levels[i]</tt> - 1.
    int                 num_levels[1],                              ///< [in] The number of boundaries (levels) for delineating histogram samples in each active channel.  Implies that the number of bins for channel<sub><em>i</em></sub> is <tt>num_levels[i]</tt> - 1.
    LevelT              lower_level[1],                             ///< [in] The lower sample value bound (inclusive) for the lowest histogram bin in each active channel.
    LevelT              upper_level[1],                             ///< [in] The upper sample value bound (exclusive) for the highest histogram bin in each active channel.
    OffsetT             num_row_pixels,                             ///< [in] The number of multi-channel pixels per row in the region of interest
    OffsetT             num_rows,                                   ///< [in] The number of rows in the region of interest
    OffsetT             row_stride_bytes,                                 ///< [in] The number of bytes between starts of consecutive rows in the region of interest
    hipStream_t        stream,
    bool                debug_synchronous)
{
    typedef typename std::iterator_traits<SampleIteratorT>::value_type SampleT;

    hipError_t error = hipSuccess;
    for (int i = 0; i < timing_timing_iterations; ++i)
    {
        error = DeviceHistogram::HistogramEven(
            d_temp_storage,
            temp_storage_bytes,
            d_samples,
            d_histogram[0],
            num_levels[0],
            lower_level[0],
            upper_level[0],
            num_row_pixels,
            num_rows,
            row_stride_bytes,
            stream,
            debug_synchronous);
    }
    return error;
}

/**
 * Dispatch to CUB multi histogram-even entrypoint
 */
template <int NUM_ACTIVE_CHANNELS, int NUM_CHANNELS, typename SampleIteratorT, typename CounterT, typename LevelT, typename OffsetT>
CUB_RUNTIME_FUNCTION __forceinline__
hipError_t DispatchEven(
    Int2Type<NUM_CHANNELS>          num_channels,
    Int2Type<NUM_ACTIVE_CHANNELS>   num_active_channels,
    Int2Type<CUB>           dispatch_to,
    int                     timing_timing_iterations,
    size_t                  *d_temp_storage_bytes,
    hipError_t             *d_cdp_error,

    void*               d_temp_storage,
    size_t&             temp_storage_bytes,
    SampleIteratorT     d_samples,                                  ///< [in] The pointer to the multi-channel input sequence of data samples. The samples from different channels are assumed to be interleaved (e.g., an array of 32-bit pixels where each pixel consists of four RGBA 8-bit samples).
    CounterT            *d_histogram[NUM_ACTIVE_CHANNELS],          ///< [out] The pointers to the histogram counter output arrays, one for each active channel.  For channel<sub><em>i</em></sub>, the allocation length of <tt>d_histograms[i]</tt> should be <tt>num_levels[i]</tt> - 1.
    int                 num_levels[NUM_ACTIVE_CHANNELS],            ///< [in] The number of boundaries (levels) for delineating histogram samples in each active channel.  Implies that the number of bins for channel<sub><em>i</em></sub> is <tt>num_levels[i]</tt> - 1.
    LevelT              lower_level[NUM_ACTIVE_CHANNELS],           ///< [in] The lower sample value bound (inclusive) for the lowest histogram bin in each active channel.
    LevelT              upper_level[NUM_ACTIVE_CHANNELS],           ///< [in] The upper sample value bound (exclusive) for the highest histogram bin in each active channel.
    OffsetT             num_row_pixels,                             ///< [in] The number of multi-channel pixels per row in the region of interest
    OffsetT             num_rows,                                   ///< [in] The number of rows in the region of interest
    OffsetT             row_stride_bytes,                                 ///< [in] The number of bytes between starts of consecutive rows in the region of interest
    hipStream_t        stream,
    bool                debug_synchronous)
{
    typedef typename std::iterator_traits<SampleIteratorT>::value_type SampleT;

    hipError_t error = hipSuccess;
    for (int i = 0; i < timing_timing_iterations; ++i)
    {
        error = DeviceHistogram::MultiHistogramEven<NUM_CHANNELS, NUM_ACTIVE_CHANNELS>(
            d_temp_storage,
            temp_storage_bytes,
            d_samples,
            d_histogram,
            num_levels,
            lower_level,
            upper_level,
            num_row_pixels,
            num_rows,
            row_stride_bytes,
            stream,
            debug_synchronous);
    }
    return error;
}


/**
 * Dispatch to CUB single histogram-range entrypoint
 */
template <typename SampleIteratorT, typename CounterT, typename LevelT, typename OffsetT>
CUB_RUNTIME_FUNCTION __forceinline__
hipError_t DispatchRange(
    Int2Type<1>             num_channels,
    Int2Type<1>             num_active_channels,
    Int2Type<CUB>           dispatch_to,
    int                     timing_timing_iterations,
    size_t                  *d_temp_storage_bytes,
    hipError_t             *d_cdp_error,

    void*               d_temp_storage,
    size_t&             temp_storage_bytes,
    SampleIteratorT     d_samples,                                  ///< [in] The pointer to the multi-channel input sequence of data samples. The samples from different channels are assumed to be interleaved (e.g., an array of 32-bit pixels where each pixel consists of four RGBA 8-bit samples).
    CounterT            *d_histogram[1],                            ///< [out] The pointers to the histogram counter output arrays, one for each active channel.  For channel<sub><em>i</em></sub>, the allocation length of <tt>d_histograms[i]</tt> should be <tt>num_levels[i]</tt> - 1.
    int                 num_levels[1],                              ///< [in] The number of boundaries (levels) for delineating histogram samples in each active channel.  Implies that the number of bins for channel<sub><em>i</em></sub> is <tt>num_levels[i]</tt> - 1.
    LevelT              *d_levels[1],                               ///< [in] The pointers to the arrays of boundaries (levels), one for each active channel.  Bin ranges are defined by consecutive boundary pairings: lower sample value boundaries are inclusive and upper sample value boundaries are exclusive.
    OffsetT             num_row_pixels,                             ///< [in] The number of multi-channel pixels per row in the region of interest
    OffsetT             num_rows,                                   ///< [in] The number of rows in the region of interest
    OffsetT             row_stride_bytes,                                 ///< [in] The number of bytes between starts of consecutive rows in the region of interest
    hipStream_t        stream,
    bool                debug_synchronous)
{
    typedef typename std::iterator_traits<SampleIteratorT>::value_type SampleT;

    hipError_t error = hipSuccess;
    for (int i = 0; i < timing_timing_iterations; ++i)
    {
        error = DeviceHistogram::HistogramRange(
            d_temp_storage,
            temp_storage_bytes,
            d_samples,
            d_histogram[0],
            num_levels[0],
            d_levels[0],
            num_row_pixels,
            num_rows,
            row_stride_bytes,
            stream,
            debug_synchronous);
    }
    return error;
}


/**
 * Dispatch to CUB multi histogram-range entrypoint
 */
template <int NUM_ACTIVE_CHANNELS, int NUM_CHANNELS, typename SampleIteratorT, typename CounterT, typename LevelT, typename OffsetT>
CUB_RUNTIME_FUNCTION __forceinline__
hipError_t DispatchRange(
    Int2Type<NUM_CHANNELS>          num_channels,
    Int2Type<NUM_ACTIVE_CHANNELS>   num_active_channels,
    Int2Type<CUB>           dispatch_to,
    int                     timing_timing_iterations,
    size_t                  *d_temp_storage_bytes,
    hipError_t             *d_cdp_error,

    void*               d_temp_storage,
    size_t&             temp_storage_bytes,
    SampleIteratorT     d_samples,                                  ///< [in] The pointer to the multi-channel input sequence of data samples. The samples from different channels are assumed to be interleaved (e.g., an array of 32-bit pixels where each pixel consists of four RGBA 8-bit samples).
    CounterT            *d_histogram[NUM_ACTIVE_CHANNELS],          ///< [out] The pointers to the histogram counter output arrays, one for each active channel.  For channel<sub><em>i</em></sub>, the allocation length of <tt>d_histograms[i]</tt> should be <tt>num_levels[i]</tt> - 1.
    int                 num_levels[NUM_ACTIVE_CHANNELS],            ///< [in] The number of boundaries (levels) for delineating histogram samples in each active channel.  Implies that the number of bins for channel<sub><em>i</em></sub> is <tt>num_levels[i]</tt> - 1.
    LevelT              *d_levels[NUM_ACTIVE_CHANNELS],             ///< [in] The pointers to the arrays of boundaries (levels), one for each active channel.  Bin ranges are defined by consecutive boundary pairings: lower sample value boundaries are inclusive and upper sample value boundaries are exclusive.
    OffsetT             num_row_pixels,                             ///< [in] The number of multi-channel pixels per row in the region of interest
    OffsetT             num_rows,                                   ///< [in] The number of rows in the region of interest
    OffsetT             row_stride_bytes,                                 ///< [in] The number of bytes between starts of consecutive rows in the region of interest
    hipStream_t        stream,
    bool                debug_synchronous)
{
    typedef typename std::iterator_traits<SampleIteratorT>::value_type SampleT;

    hipError_t error = hipSuccess;
    for (int i = 0; i < timing_timing_iterations; ++i)
    {
        error = DeviceHistogram::MultiHistogramRange<NUM_CHANNELS, NUM_ACTIVE_CHANNELS>(
            d_temp_storage,
            temp_storage_bytes,
            d_samples,
            d_histogram,
            num_levels,
            d_levels,
            num_row_pixels,
            num_rows,
            row_stride_bytes,
            stream,
            debug_synchronous);
    }
    return error;
}



//---------------------------------------------------------------------
// CUDA nested-parallelism test kernel
//---------------------------------------------------------------------

/**
 * Simple wrapper kernel to invoke DeviceHistogram
 * /
template <int BINS, int NUM_CHANNELS, int NUM_ACTIVE_CHANNELS, typename SampleT, typename SampleIteratorT, typename CounterT, int ALGORITHM>
__global__ void CnpDispatchKernel(
    Int2Type<ALGORITHM> algorithm,
    int                 timing_timing_iterations,
    size_t              *d_temp_storage_bytes,
    hipError_t         *d_cdp_error,

    void*               d_temp_storage,
    size_t              temp_storage_bytes,
    SampleT             *d_samples,
    SampleIteratorT      d_sample_itr,
    ArrayWrapper<CounterT*, NUM_ACTIVE_CHANNELS> d_out_histograms,
    int                 num_samples,
    bool                debug_synchronous)
{
#ifndef CUB_CDP
    *d_cdp_error = hipErrorNotInitialized;
#else
    *d_cdp_error = Dispatch<BINS, NUM_CHANNELS, NUM_ACTIVE_CHANNELS>(algorithm, Int2Type<false>(), timing_timing_iterations, d_temp_storage_bytes, d_cdp_error, d_temp_storage, temp_storage_bytes, d_samples, d_sample_itr, d_out_histograms.array, num_samples, 0, debug_synchronous);
    *d_temp_storage_bytes = temp_storage_bytes;
#endif
}


/ **
 * Dispatch to CDP kernel
 * /
template <int BINS, int NUM_CHANNELS, int NUM_ACTIVE_CHANNELS, typename SampleT, typename SampleIteratorT, typename CounterT, int ALGORITHM>
hipError_t Dispatch(
    Int2Type<ALGORITHM> algorithm,
    Int2Type<true>      use_cdp,
    int                 timing_timing_iterations,
    size_t              *d_temp_storage_bytes,
    hipError_t         *d_cdp_error,

    void*               d_temp_storage,
    size_t&             temp_storage_bytes,
    SampleT             *d_samples,
    SampleIteratorT      d_sample_itr,
    CounterT        *d_histograms[NUM_ACTIVE_CHANNELS],
    int                 num_samples,
    hipStream_t        stream,
    bool                debug_synchronous)
{
    // Setup array wrapper for histogram channel output (because we can't pass static arrays as kernel parameters)
    ArrayWrapper<CounterT*, NUM_ACTIVE_CHANNELS> d_histo_wrapper;
    for (int CHANNEL = 0; CHANNEL < NUM_ACTIVE_CHANNELS; ++CHANNEL)
        d_histo_wrapper.array[CHANNEL] = d_histograms[CHANNEL];

    // Invoke kernel to invoke device-side dispatch
    CnpDispatchKernel<BINS, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleIteratorT, CounterT, ALGORITHM><<<1,1>>>(algorithm, timing_timing_iterations, d_temp_storage_bytes, d_cdp_error, d_temp_storage, temp_storage_bytes, d_samples, d_sample_itr, d_histo_wrapper, num_samples, debug_synchronous);

    // Copy out temp_storage_bytes
    CubDebugExit(hipMemcpy(&temp_storage_bytes, d_temp_storage_bytes, sizeof(size_t) * 1, hipMemcpyDeviceToHost));

    // Copy out error
    hipError_t retval;
    CubDebugExit(hipMemcpy(&retval, d_cdp_error, sizeof(hipError_t) * 1, hipMemcpyDeviceToHost));
    return retval;
}
*/


//---------------------------------------------------------------------
// Test generation
//---------------------------------------------------------------------

// Searches for bin given a list of bin-boundary levels
template <typename LevelT>
struct SearchTransform
{
    LevelT          *levels;      // Pointer to levels array
    int             num_levels;   // Number of levels in array

    // Functor for converting samples to bin-ids (num_levels is returned if sample is out of range)
    template <typename SampleT>
    int operator()(SampleT sample)
    {
        int bin = int(std::upper_bound(levels, levels + num_levels, (LevelT) sample) - levels - 1);
        if (bin < 0)
        {
            // Sample out of range
            return num_levels;
        }
        return bin;
    }
};


// Scales samples to evenly-spaced bins
template <typename LevelT>
struct ScaleTransform
{
    int    num_levels;  // Number of levels in array
    LevelT max;         // Max sample level (exclusive)
    LevelT min;         // Min sample level (inclusive)
    LevelT scale;       // Bin scaling factor

    void Init(
        int    num_levels,  // Number of levels in array
        LevelT max,         // Max sample level (exclusive)
        LevelT min,         // Min sample level (inclusive)
        LevelT scale)       // Bin scaling factor
    {
        this->num_levels = num_levels;
        this->max = max;
        this->min = min;
        this->scale = scale;
    }

    // Functor for converting samples to bin-ids  (num_levels is returned if sample is out of range)
    template <typename SampleT>
    int operator()(SampleT sample)
    {
        if ((sample < min) || (sample >= max))
        {
            // Sample out of range
            return num_levels;
        }

        return (int) ((((LevelT) sample) - min) / scale);
    }
};

// Scales samples to evenly-spaced bins
template <>
struct ScaleTransform<float>
{
    int   num_levels;  // Number of levels in array
    float max;         // Max sample level (exclusive)
    float min;         // Min sample level (inclusive)
    float scale;       // Bin scaling factor

    void Init(
        int    num_levels,  // Number of levels in array
        float max,         // Max sample level (exclusive)
        float min,         // Min sample level (inclusive)
        float scale)       // Bin scaling factor
    {
        this->num_levels = num_levels;
        this->max = max;
        this->min = min;
        this->scale = 1.0f / scale;
    }

    // Functor for converting samples to bin-ids  (num_levels is returned if sample is out of range)
    template <typename SampleT>
    int operator()(SampleT sample)
    {
        if ((sample < min) || (sample >= max))
        {
            // Sample out of range
            return num_levels;
        }

        return (int) ((((float) sample) - min) * scale);
    }
};


/**
 * Generate sample
 */
template <typename T, typename LevelT>
void Sample(T &datum, LevelT max_level, int entropy_reduction)
{
    unsigned int max = (unsigned int) -1;
    unsigned int bits;
    RandomBits(bits, entropy_reduction);
    float fraction = (float(bits) / max);

    datum = (T) (fraction * max_level);
}


/**
 * Initialize histogram samples
 */
template <
    int             NUM_CHANNELS,
    int             NUM_ACTIVE_CHANNELS,
    typename        LevelT,
    typename        SampleT,
    typename        OffsetT>
void InitializeSamples(
    LevelT          max_level,
    int             entropy_reduction,
    SampleT         *h_samples,
    OffsetT         num_row_pixels,         ///< [in] The number of multi-channel pixels per row in the region of interest
    OffsetT         num_rows,               ///< [in] The number of rows in the region of interest
    OffsetT         row_stride_bytes)       ///< [in] The number of bytes between starts of consecutive rows in the region of interest
{
    // Initialize samples
    for (OffsetT row = 0; row < num_rows; ++row)
    {
        for (OffsetT pixel = 0; pixel < num_row_pixels; ++pixel)
        {
            for (int channel = 0; channel < NUM_ACTIVE_CHANNELS; ++channel)
            {
                // Sample offset
                OffsetT offset = (row * (row_stride_bytes / sizeof(SampleT))) + (pixel * NUM_CHANNELS) + channel;

                // Init sample value
                Sample(h_samples[offset], max_level, entropy_reduction);
                if (g_verbose_input)
                {
                    if (channel > 0) printf("", "");
                    std::cout << CoutCast(h_samples[offset]);
                }
            }
        }
    }
}


/**
 * Initialize histogram solutions
 */
template <
    int             NUM_CHANNELS,
    int             NUM_ACTIVE_CHANNELS,
    typename        CounterT,
    typename        SampleIteratorT,
    typename        TransformOp,
    typename        OffsetT>
void InitializeBins(
    SampleIteratorT h_samples,
    int             num_levels[NUM_ACTIVE_CHANNELS],        ///< [in] The number of boundaries (levels) for delineating histogram samples in each active channel.  Implies that the number of bins for channel<sub><em>i</em></sub> is <tt>num_levels[i]</tt> - 1.
    TransformOp     transform_op[NUM_ACTIVE_CHANNELS],      ///< [in] The lower sample value bound (inclusive) for the lowest histogram bin in each active channel.
    CounterT        *h_histogram[NUM_ACTIVE_CHANNELS],      ///< [out] The pointers to the histogram counter output arrays, one for each active channel.  For channel<sub><em>i</em></sub>, the allocation length of <tt>d_histograms[i]</tt> should be <tt>num_levels[i]</tt> - 1.
    OffsetT         num_row_pixels,                         ///< [in] The number of multi-channel pixels per row in the region of interest
    OffsetT         num_rows,                               ///< [in] The number of rows in the region of interest
    OffsetT         row_stride_bytes)                       ///< [in] The number of bytes between starts of consecutive rows in the region of interest
{
    typedef typename std::iterator_traits<SampleIteratorT>::value_type SampleT;

    // Init bins
    for (int CHANNEL = 0; CHANNEL < NUM_ACTIVE_CHANNELS; ++CHANNEL)
    {
        for (int bin = 0; bin < num_levels[CHANNEL] - 1; ++bin)
        {
            h_histogram[CHANNEL][bin] = 0;
        }
    }

    // Initialize samples
    if (g_verbose_input) printf(""Samples: \\n"");
    for (OffsetT row = 0; row < num_rows; ++row)
    {
        for (OffsetT pixel = 0; pixel < num_row_pixels; ++pixel)
        {
            if (g_verbose_input) printf(""["");
            for (int channel = 0; channel < NUM_ACTIVE_CHANNELS; ++channel)
            {
                // Sample offset
                OffsetT offset = (row * (row_stride_bytes / sizeof(SampleT))) + (pixel * NUM_CHANNELS) + channel;

                // Update sample bin
                int bin = transform_op[channel](h_samples[offset]);
                if (g_verbose_input) printf("" (%d)"", bin); fflush(stdout);
                if ((bin >= 0) && (bin < num_levels[channel] - 1))
                {
                    // valid bin
                    h_histogram[channel][bin]++;
                }
            }
            if (g_verbose_input) printf(""]"");
        }
        if (g_verbose_input) printf(""\\n\\n"");
    }
}



/**
 * Test histogram-even
 */
template <
    Backend         BACKEND,
    int             NUM_CHANNELS,
    int             NUM_ACTIVE_CHANNELS,
    typename        SampleT,
    typename        CounterT,
    typename        LevelT,
    typename        OffsetT,
    typename        SampleIteratorT>
void TestEven(
    LevelT          max_level,
    int             entropy_reduction,
    int             num_levels[NUM_ACTIVE_CHANNELS],            ///< [in] The number of boundaries (levels) for delineating histogram samples in each active channel.  Implies that the number of bins for channel<sub><em>i</em></sub> is <tt>num_levels[i]</tt> - 1.
    LevelT          lower_level[NUM_ACTIVE_CHANNELS],           ///< [in] The lower sample value bound (inclusive) for the lowest histogram bin in each active channel.
    LevelT          upper_level[NUM_ACTIVE_CHANNELS],           ///< [in] The upper sample value bound (exclusive) for the highest histogram bin in each active channel.
    OffsetT         num_row_pixels,                             ///< [in] The number of multi-channel pixels per row in the region of interest
    OffsetT         num_rows,                                   ///< [in] The number of rows in the region of interest
    OffsetT         row_stride_bytes,                           ///< [in] The number of bytes between starts of consecutive rows in the region of interest
    SampleIteratorT h_samples,
    SampleIteratorT d_samples)
{
    OffsetT total_samples = num_rows * (row_stride_bytes / sizeof(SampleT));

    printf(""\\n----------------------------\\n"");
    printf(""%s cub::DeviceHistogramEven (%s) %d pixels (%d height, %d width, %d-byte row stride), %d %d-byte %s samples (entropy reduction %d), %s counters, %d/%d channels, max sample "",
        (BACKEND == CDP) ? ""CDP CUB"" : (BACKEND == NPP) ? ""NPP"" : ""CUB"",
        (IsPointer<SampleIteratorT>::VALUE) ? ""pointer"" : ""iterator"",
        (int) (num_row_pixels * num_rows),
        (int) num_rows,
        (int) num_row_pixels,
        (int) row_stride_bytes,
        (int) total_samples,
        (int) sizeof(SampleT),
        typeid(SampleT).name(),
        entropy_reduction,
        typeid(CounterT).name(),
        NUM_ACTIVE_CHANNELS,
        NUM_CHANNELS);
    std::cout << CoutCast(max_level) << ""\\n"";
    for (int channel = 0; channel < NUM_ACTIVE_CHANNELS; ++channel)
        std::cout << ""\\n\\tChannel "" << channel << "": "" << num_levels[channel] - 1 << "" bins ["" << lower_level[channel] << "", "" << upper_level[channel] << "")\\n"";
    fflush(stdout);

    // Allocate and initialize host and device data

    typedef SampleT Foo;        // rename type to quelch gcc warnings (bug?)
    CounterT*                   h_histogram[NUM_ACTIVE_CHANNELS];
    ScaleTransform<LevelT>      transform_op[NUM_ACTIVE_CHANNELS];

    for (int channel = 0; channel < NUM_ACTIVE_CHANNELS; ++channel)
    {
        int bins = num_levels[channel] - 1;
        h_histogram[channel] = new CounterT[bins];

        transform_op[channel].Init(
            num_levels[channel],
            upper_level[channel],
            lower_level[channel],
            ((upper_level[channel] - lower_level[channel]) / bins));
    }

    InitializeBins<NUM_CHANNELS, NUM_ACTIVE_CHANNELS>(
        h_samples, num_levels, transform_op, h_histogram, num_row_pixels, num_rows, row_stride_bytes);

    // Allocate and initialize device data

    CounterT* d_histogram[NUM_ACTIVE_CHANNELS];
    for (int channel = 0; channel < NUM_ACTIVE_CHANNELS; ++channel)
    {
        CubDebugExit(g_allocator.DeviceAllocate((void**)&d_histogram[channel], sizeof(CounterT) * (num_levels[channel] - 1)));
        CubDebugExit(hipMemset(d_histogram[channel], 0, sizeof(CounterT) * (num_levels[channel] - 1)));
    }

    // Allocate CDP device arrays
    size_t          *d_temp_storage_bytes = NULL;
    hipError_t     *d_cdp_error = NULL;
    CubDebugExit(g_allocator.DeviceAllocate((void**)&d_temp_storage_bytes,  sizeof(size_t) * 1));
    CubDebugExit(g_allocator.DeviceAllocate((void**)&d_cdp_error,           sizeof(hipError_t) * 1));

    // Allocate temporary storage
    void            *d_temp_storage = NULL;
    size_t          temp_storage_bytes = 0;

    DispatchEven(
        Int2Type<NUM_CHANNELS>(), Int2Type<NUM_ACTIVE_CHANNELS>(), Int2Type<BACKEND>(), 1, d_temp_storage_bytes, d_cdp_error,
        d_temp_storage, temp_storage_bytes,
        d_samples, d_histogram, num_levels, lower_level, upper_level,
        num_row_pixels, num_rows, row_stride_bytes,
        0, true);

    // Allocate temporary storage with ""canary"" zones
    int     canary_bytes    = 256;
    char    canary_token    = 8;
    char*   canary_zone     = new char[canary_bytes];

    memset(canary_zone, canary_token, canary_bytes);
    CubDebugExit(g_allocator.DeviceAllocate(&d_temp_storage, temp_storage_bytes + (canary_bytes * 2)));
    CubDebugExit(hipMemset(d_temp_storage, canary_token, temp_storage_bytes + (canary_bytes * 2)));

    // Run warmup/correctness iteration
    DispatchEven(
        Int2Type<NUM_CHANNELS>(), Int2Type<NUM_ACTIVE_CHANNELS>(), Int2Type<BACKEND>(), 1, d_temp_storage_bytes, d_cdp_error,
        ((char *) d_temp_storage) + canary_bytes, temp_storage_bytes,
        d_samples, d_histogram, num_levels, lower_level, upper_level,
        num_row_pixels, num_rows, row_stride_bytes,
        0, true);

    // Check canary zones
    int error = CompareDeviceResults(canary_zone, (char *) d_temp_storage, canary_bytes, true, g_verbose);
    AssertEquals(0, error);
    error = CompareDeviceResults(canary_zone, ((char *) d_temp_storage) + canary_bytes + temp_storage_bytes, canary_bytes, true, g_verbose);
    AssertEquals(0, error);

    // Flush any stdout/stderr
    CubDebugExit(hipPeekAtLastError());
    CubDebugExit(hipDeviceSynchronize());
    fflush(stdout);
    fflush(stderr);

    // Check for correctness (and display results, if specified)
    for (int channel = 0; channel < NUM_ACTIVE_CHANNELS; ++channel)
    {
        int channel_error = CompareDeviceResults(h_histogram[channel], d_histogram[channel], num_levels[channel] - 1, true, g_verbose);
        printf(""\\tChannel %d %s"", channel, channel_error ? ""FAIL"" : ""PASS\\n"");
        error |= channel_error;
    }

    // Performance
    GpuTimer gpu_timer;
    gpu_timer.Start();

    DispatchEven(
        Int2Type<NUM_CHANNELS>(), Int2Type<NUM_ACTIVE_CHANNELS>(), Int2Type<BACKEND>(), g_timing_iterations, d_temp_storage_bytes, d_cdp_error,
        d_temp_storage, temp_storage_bytes,
        d_samples, d_histogram, num_levels, lower_level, upper_level,
        num_row_pixels, num_rows, row_stride_bytes,
        0, false);

    gpu_timer.Stop();
    float elapsed_millis = gpu_timer.ElapsedMillis();

    // Display performance
    if (g_timing_iterations > 0)
    {
        float avg_millis = elapsed_millis / g_timing_iterations;
        float giga_rate = float(total_samples) / avg_millis / 1000.0f / 1000.0f;
        float giga_bandwidth = giga_rate * sizeof(SampleT);
        printf(""\\t%.3f avg ms, %.3f billion samples/s, %.3f billion bins/s, %.3f billion pixels/s, %.3f logical GB/s"",
            avg_millis,
            giga_rate,
            giga_rate * NUM_ACTIVE_CHANNELS / NUM_CHANNELS,
            giga_rate / NUM_CHANNELS,
            giga_bandwidth);
    }

    printf(""\\n\\n"");

    for (int channel = 0; channel < NUM_ACTIVE_CHANNELS; ++channel)
    {
        if (h_histogram[channel])
            delete[] h_histogram[channel];

        if (d_histogram[channel])
            CubDebugExit(g_allocator.DeviceFree(d_histogram[channel]));
    }

    if (d_temp_storage_bytes) CubDebugExit(g_allocator.DeviceFree(d_temp_storage_bytes));
    if (d_cdp_error) CubDebugExit(g_allocator.DeviceFree(d_cdp_error));
    if (d_temp_storage) CubDebugExit(g_allocator.DeviceFree(d_temp_storage));

    // Correctness asserts
    AssertEquals(0, error);
}


/**
 * Test histogram-even (native pointer input)
 */
template <
    Backend         BACKEND,
    int             NUM_CHANNELS,
    int             NUM_ACTIVE_CHANNELS,
    typename        SampleT,
    typename        CounterT,
    typename        LevelT,
    typename        OffsetT>
void TestEvenNative(
    LevelT          max_level,
    int             entropy_reduction,
    int             num_levels[NUM_ACTIVE_CHANNELS],            ///< [in] The number of boundaries (levels) for delineating histogram samples in each active channel.  Implies that the number of bins for channel<sub><em>i</em></sub> is <tt>num_levels[i]</tt> - 1.
    LevelT          lower_level[NUM_ACTIVE_CHANNELS],           ///< [in] The lower sample value bound (inclusive) for the lowest histogram bin in each active channel.
    LevelT          upper_level[NUM_ACTIVE_CHANNELS],           ///< [in] The upper sample value bound (exclusive) for the highest histogram bin in each active channel.
    OffsetT         num_row_pixels,                             ///< [in] The number of multi-channel pixels per row in the region of interest
    OffsetT         num_rows,                                   ///< [in] The number of rows in the region of interest
    OffsetT         row_stride_bytes)                                 ///< [in] The number of bytes between starts of consecutive rows in the region of interest
{
    OffsetT total_samples = num_rows * (row_stride_bytes / sizeof(SampleT));

    // Allocate and initialize host sample data
    typedef SampleT Foo;        // rename type to quelch gcc warnings (bug?)
    SampleT*                    h_samples = new Foo[total_samples];

    InitializeSamples<NUM_CHANNELS, NUM_ACTIVE_CHANNELS>(
        max_level, entropy_reduction, h_samples, num_row_pixels, num_rows, row_stride_bytes);

    // Allocate and initialize device data
    SampleT* d_samples = NULL;
    CubDebugExit(g_allocator.DeviceAllocate((void**)&d_samples, sizeof(SampleT) * total_samples));
    CubDebugExit(hipMemcpy(d_samples, h_samples, sizeof(SampleT) * total_samples, hipMemcpyHostToDevice));

    TestEven<BACKEND, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleT, CounterT, LevelT, OffsetT>(
        max_level, entropy_reduction, num_levels, lower_level, upper_level,
        num_row_pixels, num_rows, row_stride_bytes,
        h_samples, d_samples);

    // Cleanup
    if (h_samples) delete[] h_samples;
    if (d_samples) CubDebugExit(g_allocator.DeviceFree(d_samples));
}


/**
 * Test histogram-even (native pointer input)
 */
template <
    Backend         BACKEND,
    int             NUM_CHANNELS,
    int             NUM_ACTIVE_CHANNELS,
    typename        SampleT,
    typename        CounterT,
    typename        LevelT,
    typename        OffsetT>
void TestEvenIterator(
    LevelT          max_level,
    int             entropy_reduction,
    int             num_levels[NUM_ACTIVE_CHANNELS],            ///< [in] The number of boundaries (levels) for delineating histogram samples in each active channel.  Implies that the number of bins for channel<sub><em>i</em></sub> is <tt>num_levels[i]</tt> - 1.
    LevelT          lower_level[NUM_ACTIVE_CHANNELS],           ///< [in] The lower sample value bound (inclusive) for the lowest histogram bin in each active channel.
    LevelT          upper_level[NUM_ACTIVE_CHANNELS],           ///< [in] The upper sample value bound (exclusive) for the highest histogram bin in each active channel.
    OffsetT         num_row_pixels,                             ///< [in] The number of multi-channel pixels per row in the region of interest
    OffsetT         num_rows,                                   ///< [in] The number of rows in the region of interest
    OffsetT         row_stride_bytes)                                 ///< [in] The number of bytes between starts of consecutive rows in the region of interest
{
    SampleT sample = (SampleT) lower_level[0];
    ConstantInputIterator<SampleT> sample_itr(sample);

    TestEven<BACKEND, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleT, CounterT, LevelT, OffsetT>(
        max_level, entropy_reduction, num_levels, lower_level, upper_level,
        num_row_pixels, num_rows, row_stride_bytes,
        sample_itr, sample_itr);

}


/**
 * Test histogram-range
 */
template <
    Backend         BACKEND,
    int             NUM_CHANNELS,
    int             NUM_ACTIVE_CHANNELS,
    typename        SampleT,
    typename        CounterT,
    typename        LevelT,
    typename        OffsetT>
void TestRange(
    LevelT          max_level,
    int             entropy_reduction,
    int             num_levels[NUM_ACTIVE_CHANNELS],            ///< [in] The number of boundaries (levels) for delineating histogram samples in each active channel.  Implies that the number of bins for channel<sub><em>i</em></sub> is <tt>num_levels[i]</tt> - 1.
    LevelT*         levels[NUM_ACTIVE_CHANNELS],                ///< [in] The lower sample value bound (inclusive) for the lowest histogram bin in each active channel.
    OffsetT         num_row_pixels,                             ///< [in] The number of multi-channel pixels per row in the region of interest
    OffsetT         num_rows,                                   ///< [in] The number of rows in the region of interest
    OffsetT         row_stride_bytes)                                 ///< [in] The number of bytes between starts of consecutive rows in the region of interest
{
    OffsetT total_samples = num_rows * (row_stride_bytes / sizeof(SampleT));

    printf(""\\n----------------------------\\n"");
    printf(""%s cub::DeviceHistogramRange %d pixels (%d height, %d width, %d-byte row stride), %d %d-byte %s samples (entropy reduction %d), %s counters, %d/%d channels, max sample "",
        (BACKEND == CDP) ? ""CDP CUB"" : (BACKEND == NPP) ? ""NPP"" : ""CUB"",
        (int) (num_row_pixels * num_rows),
        (int) num_rows,
        (int) num_row_pixels,
        (int) row_stride_bytes,
        (int) total_samples,
        (int) sizeof(SampleT),
        typeid(SampleT).name(),
        entropy_reduction,
        typeid(CounterT).name(),
        NUM_ACTIVE_CHANNELS,
        NUM_CHANNELS);
    std::cout << CoutCast(max_level) << ""\\n"";
    for (int channel = 0; channel < NUM_ACTIVE_CHANNELS; ++channel)
    {
        printf(""Channel %d: %d bins ["", channel, num_levels[channel] - 1);
        std::cout << levels[channel][0];
        for (int level = 1; level < num_levels[channel]; ++level)
            std::cout << "", "" << levels[channel][level];
        printf(""]\\n"");
    }
    fflush(stdout);

    // Allocate and initialize host and device data
    typedef SampleT Foo;        // rename type to quelch gcc warnings (bug?)
    SampleT*                    h_samples = new Foo[total_samples];
    CounterT*                   h_histogram[NUM_ACTIVE_CHANNELS];
    SearchTransform<LevelT>     transform_op[NUM_ACTIVE_CHANNELS];

    for (int channel = 0; channel < NUM_ACTIVE_CHANNELS; ++channel)
    {
        transform_op[channel].levels = levels[channel];
        transform_op[channel].num_levels = num_levels[channel];

        int bins = num_levels[channel] - 1;
        h_histogram[channel] = new CounterT[bins];
    }

    InitializeSamples<NUM_CHANNELS, NUM_ACTIVE_CHANNELS>(
        max_level, entropy_reduction, h_samples, num_row_pixels, num_rows, row_stride_bytes);

    InitializeBins<NUM_CHANNELS, NUM_ACTIVE_CHANNELS>(
        h_samples, num_levels, transform_op, h_histogram, num_row_pixels, num_rows, row_stride_bytes);

    // Allocate and initialize device data
    SampleT*        d_samples = NULL;
    LevelT*         d_levels[NUM_ACTIVE_CHANNELS];
    CounterT*       d_histogram[NUM_ACTIVE_CHANNELS];

    CubDebugExit(g_allocator.DeviceAllocate((void**)&d_samples, sizeof(SampleT) * total_samples));
    CubDebugExit(hipMemcpy(d_samples, h_samples, sizeof(SampleT) * total_samples, hipMemcpyHostToDevice));

    for (int channel = 0; channel < NUM_ACTIVE_CHANNELS; ++channel)
    {
        CubDebugExit(g_allocator.DeviceAllocate((void**)&d_levels[channel], sizeof(LevelT) * num_levels[channel]));
        CubDebugExit(hipMemcpy(d_levels[channel], levels[channel],         sizeof(LevelT) * num_levels[channel], hipMemcpyHostToDevice));

        int bins = num_levels[channel] - 1;
        CubDebugExit(g_allocator.DeviceAllocate((void**)&d_histogram[channel],  sizeof(CounterT) * bins));
        CubDebugExit(hipMemset(d_histogram[channel], 0,                        sizeof(CounterT) * bins));
    }

    // Allocate CDP device arrays
    size_t          *d_temp_storage_bytes = NULL;
    hipError_t     *d_cdp_error = NULL;

    CubDebugExit(g_allocator.DeviceAllocate((void**)&d_temp_storage_bytes,  sizeof(size_t) * 1));
    CubDebugExit(g_allocator.DeviceAllocate((void**)&d_cdp_error,           sizeof(hipError_t) * 1));

    // Allocate temporary storage
    void            *d_temp_storage = NULL;
    size_t          temp_storage_bytes = 0;

    DispatchRange(
        Int2Type<NUM_CHANNELS>(), Int2Type<NUM_ACTIVE_CHANNELS>(), Int2Type<BACKEND>(), 1, d_temp_storage_bytes, d_cdp_error,
        d_temp_storage, temp_storage_bytes,
        d_samples, d_histogram, num_levels, d_levels,
        num_row_pixels, num_rows, row_stride_bytes,
        0, true);

    // Allocate temporary storage with ""canary"" zones
    int     canary_bytes    = 256;
    char    canary_token    = 9;
    char*   canary_zone     = new char[canary_bytes];

    memset(canary_zone, canary_token, canary_bytes);
    CubDebugExit(g_allocator.DeviceAllocate(&d_temp_storage, temp_storage_bytes + (canary_bytes * 2)));
    CubDebugExit(hipMemset(d_temp_storage, canary_token, temp_storage_bytes + (canary_bytes * 2)));

    // Run warmup/correctness iteration
    DispatchRange(
        Int2Type<NUM_CHANNELS>(), Int2Type<NUM_ACTIVE_CHANNELS>(), Int2Type<BACKEND>(), 1, d_temp_storage_bytes, d_cdp_error,
        ((char *) d_temp_storage) + canary_bytes, temp_storage_bytes,
        d_samples, d_histogram, num_levels, d_levels,
        num_row_pixels, num_rows, row_stride_bytes,
        0, true);

    // Check canary zones
    int error = CompareDeviceResults(canary_zone, (char *) d_temp_storage, canary_bytes, true, g_verbose);
    AssertEquals(0, error);
    error = CompareDeviceResults(canary_zone, ((char *) d_temp_storage) + canary_bytes + temp_storage_bytes, canary_bytes, true, g_verbose);
    AssertEquals(0, error);

    // Flush any stdout/stderr
    CubDebugExit(hipPeekAtLastError());
    CubDebugExit(hipDeviceSynchronize());
    fflush(stdout);
    fflush(stderr);

    // Check for correctness (and display results, if specified)
    for (int channel = 0; channel < NUM_ACTIVE_CHANNELS; ++channel)
    {
        int channel_error = CompareDeviceResults(h_histogram[channel], d_histogram[channel], num_levels[channel] - 1, true, g_verbose);
        printf(""\\tChannel %d %s"", channel, channel_error ? ""FAIL"" : ""PASS\\n"");
        error |= channel_error;
    }

    // Performance
    GpuTimer gpu_timer;
    gpu_timer.Start();

    DispatchRange(
        Int2Type<NUM_CHANNELS>(), Int2Type<NUM_ACTIVE_CHANNELS>(), Int2Type<BACKEND>(), g_timing_iterations, d_temp_storage_bytes, d_cdp_error,
        d_temp_storage, temp_storage_bytes,
        d_samples, d_histogram, num_levels, d_levels,
        num_row_pixels, num_rows, row_stride_bytes,
        0, false);

    gpu_timer.Stop();
    float elapsed_millis = gpu_timer.ElapsedMillis();

    // Display performance
    if (g_timing_iterations > 0)
    {
        float avg_millis = elapsed_millis / g_timing_iterations;
        float giga_rate = float(total_samples) / avg_millis / 1000.0f / 1000.0f;
        float giga_bandwidth = giga_rate * sizeof(SampleT);
        printf(""\\t%.3f avg ms, %.3f billion samples/s, %.3f billion bins/s, %.3f billion pixels/s, %.3f logical GB/s"",
            avg_millis,
            giga_rate,
            giga_rate * NUM_ACTIVE_CHANNELS / NUM_CHANNELS,
            giga_rate / NUM_CHANNELS,
            giga_bandwidth);
    }

    printf(""\\n\\n"");

    // Cleanup
    if (h_samples) delete[] h_samples;

    for (int channel = 0; channel < NUM_ACTIVE_CHANNELS; ++channel)
    {
        if (h_histogram[channel])
            delete[] h_histogram[channel];

        if (d_histogram[channel])
            CubDebugExit(g_allocator.DeviceFree(d_histogram[channel]));

        if (d_levels[channel])
            CubDebugExit(g_allocator.DeviceFree(d_levels[channel]));
    }

    if (d_samples) CubDebugExit(g_allocator.DeviceFree(d_samples));
    if (d_temp_storage_bytes) CubDebugExit(g_allocator.DeviceFree(d_temp_storage_bytes));
    if (d_cdp_error) CubDebugExit(g_allocator.DeviceFree(d_cdp_error));
    if (d_temp_storage) CubDebugExit(g_allocator.DeviceFree(d_temp_storage));

    // Correctness asserts
    AssertEquals(0, error);
}


/**
 * Test histogram-even
 */
template <
    Backend         BACKEND,
    typename        SampleT,
    int             NUM_CHANNELS,
    int             NUM_ACTIVE_CHANNELS,
    typename        CounterT,
    typename        LevelT,
    typename        OffsetT>
void TestEven(
    OffsetT         num_row_pixels,
    OffsetT         num_rows,
    OffsetT         row_stride_bytes,
    int             entropy_reduction,
    int             num_levels[NUM_ACTIVE_CHANNELS],
    LevelT          max_level,
    int             max_num_levels)
{
    LevelT lower_level[NUM_ACTIVE_CHANNELS];
    LevelT upper_level[NUM_ACTIVE_CHANNELS];

    // Find smallest level increment
    int max_bins = max_num_levels - 1;
    LevelT min_level_increment = max_level / max_bins;

    // Set upper and lower levels for each channel
    for (int channel = 0; channel < NUM_ACTIVE_CHANNELS; ++channel)
    {
        int num_bins = num_levels[channel] - 1;
        lower_level[channel] = (max_level - (num_bins * min_level_increment)) / 2;
        upper_level[channel] = (max_level + (num_bins * min_level_increment)) / 2;
    }

    // Test pointer-based samples
    TestEvenNative<BACKEND, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleT, CounterT, LevelT, OffsetT>(
        max_level, entropy_reduction, num_levels, lower_level, upper_level, num_row_pixels, num_rows, row_stride_bytes);

    // Test iterator-based samples (CUB-only)
    TestEvenIterator<CUB, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleT, CounterT, LevelT, OffsetT>(
        max_level, entropy_reduction, num_levels, lower_level, upper_level, num_row_pixels, num_rows, row_stride_bytes);
}



/**
 * Test histogram-range
 */
template <
    Backend         BACKEND,
    typename        SampleT,
    int             NUM_CHANNELS,
    int             NUM_ACTIVE_CHANNELS,
    typename        CounterT,
    typename        LevelT,
    typename        OffsetT>
void TestRange(
    OffsetT         num_row_pixels,
    OffsetT         num_rows,
    OffsetT         row_stride_bytes,
    int             entropy_reduction,
    int             num_levels[NUM_ACTIVE_CHANNELS],
    LevelT          max_level,
    int             max_num_levels)
{
    // Find smallest level increment
    int max_bins = max_num_levels - 1;
    LevelT min_level_increment = max_level / max_bins;

    LevelT* levels[NUM_ACTIVE_CHANNELS];
    for (int channel = 0; channel < NUM_ACTIVE_CHANNELS; ++channel)
    {
        levels[channel] = new LevelT[num_levels[channel]];

        int num_bins = num_levels[channel] - 1;
        LevelT lower_level = (max_level - (num_bins * min_level_increment)) / 2;

        for (int level = 0; level < num_levels[channel]; ++level)
            levels[channel][level] = lower_level + (level * min_level_increment);
    }

    TestRange<BACKEND, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, SampleT, CounterT, LevelT, OffsetT>(
        max_level, entropy_reduction, num_levels, levels, num_row_pixels, num_rows, row_stride_bytes);

    for (int channel = 0; channel < NUM_ACTIVE_CHANNELS; ++channel)
        delete[] levels[channel];

}



/**
 * Test different entrypoints
 */
template <
    typename        SampleT,
    int             NUM_CHANNELS,
    int             NUM_ACTIVE_CHANNELS,
    typename        CounterT,
    typename        LevelT,
    typename        OffsetT>
void Test(
    OffsetT         num_row_pixels,
    OffsetT         num_rows,
    OffsetT         row_stride_bytes,
    int             entropy_reduction,
    int             num_levels[NUM_ACTIVE_CHANNELS],
    LevelT          max_level,
    int             max_num_levels)
{
    TestEven<CUB, SampleT, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, CounterT, LevelT, OffsetT>(
        num_row_pixels, num_rows, row_stride_bytes, entropy_reduction, num_levels, max_level, max_num_levels);

    TestRange<CUB, SampleT, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, CounterT, LevelT, OffsetT>(
        num_row_pixels, num_rows, row_stride_bytes, entropy_reduction, num_levels, max_level, max_num_levels);
}


/**
 * Test different number of levels
 */
template <
    typename        SampleT,
    int             NUM_CHANNELS,
    int             NUM_ACTIVE_CHANNELS,
    typename        CounterT,
    typename        LevelT,
    typename        OffsetT>
void Test(
    OffsetT         num_row_pixels,
    OffsetT         num_rows,
    OffsetT         row_stride_bytes,
    int             entropy_reduction,
    LevelT          max_level,
    int             max_num_levels)
{
    int num_levels[NUM_ACTIVE_CHANNELS];

// Unnecessary testing
//    // All the same level
//    for (int channel = 0; channel < NUM_ACTIVE_CHANNELS; ++channel)
//    {
//        num_levels[channel] = max_num_levels;
//    }
//    Test<SampleT, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, CounterT, LevelT, OffsetT>(
//        num_row_pixels, num_rows, row_stride_bytes, entropy_reduction, num_levels, max_level, max_num_levels);

    // All different levels
    num_levels[0] = max_num_levels;
    for (int channel = 1; channel < NUM_ACTIVE_CHANNELS; ++channel)
    {
        num_levels[channel] = (num_levels[channel - 1] / 2) + 1;
    }
    Test<SampleT, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, CounterT, LevelT, OffsetT>(
        num_row_pixels, num_rows, row_stride_bytes, entropy_reduction, num_levels, max_level, max_num_levels);
}



/**
 * Test different entropy-levels
 */
template <
    typename        SampleT,
    int             NUM_CHANNELS,
    int             NUM_ACTIVE_CHANNELS,
    typename        CounterT,
    typename        LevelT,
    typename        OffsetT>
void Test(
    OffsetT         num_row_pixels,
    OffsetT         num_rows,
    OffsetT         row_stride_bytes,
    LevelT          max_level,
    int             max_num_levels)
{
    Test<SampleT, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, CounterT, LevelT, OffsetT>(
        num_row_pixels, num_rows, row_stride_bytes, 0,   max_level, max_num_levels);

    Test<SampleT, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, CounterT, LevelT, OffsetT>(
        num_row_pixels, num_rows, row_stride_bytes, -1,  max_level, max_num_levels);

    Test<SampleT, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, CounterT, LevelT, OffsetT>(
        num_row_pixels, num_rows, row_stride_bytes, 5,   max_level, max_num_levels);
}


/**
 * Test different row strides
 */
template <
    typename        SampleT,
    int             NUM_CHANNELS,
    int             NUM_ACTIVE_CHANNELS,
    typename        CounterT,
    typename        LevelT,
    typename        OffsetT>
void Test(
    OffsetT         num_row_pixels,
    OffsetT         num_rows,
    LevelT          max_level,
    int             max_num_levels)
{
    OffsetT row_stride_bytes = num_row_pixels * NUM_CHANNELS * sizeof(SampleT);

    // No padding
    Test<SampleT, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, CounterT, LevelT, OffsetT>(
        num_row_pixels, num_rows, row_stride_bytes, max_level, max_num_levels);

    // 13 samples padding
    Test<SampleT, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, CounterT, LevelT, OffsetT>(
        num_row_pixels, num_rows, row_stride_bytes + (13 * sizeof(SampleT)), max_level, max_num_levels);
}


/**
 * Test different problem sizes
 */
template <
    typename        SampleT,
    int             NUM_CHANNELS,
    int             NUM_ACTIVE_CHANNELS,
    typename        CounterT,
    typename        LevelT,
    typename        OffsetT>
void Test(
    LevelT          max_level,
    int             max_num_levels)
{
    // 0 row/col images
    Test<SampleT, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, CounterT, LevelT, OffsetT>(
        OffsetT(1920), OffsetT(0), max_level, max_num_levels);
    Test<SampleT, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, CounterT, LevelT, OffsetT>(
        OffsetT(0), OffsetT(0), max_level, max_num_levels);

    // 1080 image
    Test<SampleT, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, CounterT, LevelT, OffsetT>(
        OffsetT(1920), OffsetT(1080), max_level, max_num_levels);

    // Sample different aspect ratios sizes
    for (OffsetT rows = 1; rows < 1000000; rows *= 1000)
    {
        for (OffsetT cols = 1; cols < (1000000 / rows); cols *= 1000)
        {
            Test<SampleT, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, CounterT, LevelT, OffsetT>(
                cols, rows, max_level, max_num_levels);
        }
    }

    // Randomly select linear problem size between 1:10,000,000
    unsigned int max_int = (unsigned int) -1;
    for (int i = 0; i < 4; ++i)
    {
        unsigned int num_items;
        RandomBits(num_items);
        num_items = (unsigned int) ((double(num_items) * double(10000000)) / double(max_int));
        num_items = CUB_MAX(1, num_items);

        Test<SampleT, NUM_CHANNELS, NUM_ACTIVE_CHANNELS, CounterT, LevelT, OffsetT>(
            OffsetT(num_items), 1, max_level, max_num_levels);
    }
}



/**
 * Test different channel interleavings (valid specialiation)
 */
template <
    typename        SampleT,
    typename        CounterT,
    typename        LevelT,
    typename        OffsetT>
void TestChannels(
    LevelT          max_level,
    int             max_num_levels,
    Int2Type<true>  is_valid_tag)
{
    Test<SampleT, 1, 1, CounterT, LevelT, OffsetT>(max_level, max_num_levels);
    Test<SampleT, 4, 3, CounterT, LevelT, OffsetT>(max_level, max_num_levels);
    Test<SampleT, 3, 3, CounterT, LevelT, OffsetT>(max_level, max_num_levels);
    Test<SampleT, 4, 4, CounterT, LevelT, OffsetT>(max_level, max_num_levels);
}


/**
 * Test different channel interleavings (invalid specialiation)
 */
template <
    typename        SampleT,
    typename        CounterT,
    typename        LevelT,
    typename        OffsetT>
void TestChannels(
    LevelT          max_level,
    int             max_num_levels,
    Int2Type<false> is_valid_tag)
{}



//---------------------------------------------------------------------
// Main
//---------------------------------------------------------------------




/**
 * Main
 */
int main(int argc, char** argv)
{
    int num_row_pixels = -1;
    int entropy_reduction = 0;
    int num_rows = 1;

    // Initialize command line
    CommandLineArgs args(argc, argv);
    g_verbose = args.CheckCmdLineFlag(""v"");
    g_verbose_input = args.CheckCmdLineFlag(""v2"");
    args.GetCmdLineArgument(""n"", num_row_pixels);

    int row_stride_pixels = num_row_pixels;

    args.GetCmdLineArgument(""rows"", num_rows);
    args.GetCmdLineArgument(""stride"", row_stride_pixels);
    args.GetCmdLineArgument(""i"", g_timing_iterations);
    args.GetCmdLineArgument(""repeat"", g_repeat);
    args.GetCmdLineArgument(""entropy"", entropy_reduction);
#if defined(QUICK_TEST) || defined(QUICKER_TEST)
    bool compare_npp = args.CheckCmdLineFlag(""npp"");
#endif


    // Print usage
    if (args.CheckCmdLineFlag(""help""))
    {
        printf(""%s ""
            ""[--n=<pixels per row> ""
            ""[--rows=<number of rows> ""
            ""[--stride=<row stride in pixels> ""
            ""[--i=<timing iterations> ""
            ""[--device=<device-id>] ""
            ""[--repeat=<repetitions of entire test suite>]""
            ""[--entropy=<entropy-reduction factor (default 0)>]""
            ""[--v] ""
            ""[--cdp]""
            ""[--npp]""
            ""\\n"", argv[0]);
        exit(0);
    }

    // Initialize device
    CubDebugExit(args.DeviceInit());

    // Get ptx version
    int ptx_version;
    CubDebugExit(PtxVersion(ptx_version));

    if (num_row_pixels < 0)
    {
        num_row_pixels      = 1920 * 1080;
        row_stride_pixels   = num_row_pixels;
    }

#if defined(QUICKER_TEST)

    // Compile/run quick tests
    {
        // HistogramEven: unsigned char 256 bins
        typedef unsigned char       SampleT;
        typedef int                 LevelT;

        LevelT  max_level           = 256;
        int     num_levels[1]       = {257};
        int     row_stride_bytes    = sizeof(SampleT) * row_stride_pixels * 1;

        TestEven<CUB, SampleT, 1, 1, int, LevelT, int>(num_row_pixels, num_rows, row_stride_bytes, entropy_reduction, num_levels, max_level, num_levels[0]);
        if (compare_npp)
            TestEven<NPP, SampleT, 1, 1, int, LevelT, int>(num_row_pixels, num_rows, row_stride_bytes, entropy_reduction, num_levels, max_level, num_levels[0]);
    }


#elif defined(QUICK_TEST)

    // Compile/run quick tests
    {
        // HistogramEven: unsigned char 256 bins
        typedef unsigned char       SampleT;
        typedef int                 LevelT;

        LevelT  max_level           = 256;
        int     num_levels[1]       = {257};
        int     row_stride_bytes    = sizeof(SampleT) * row_stride_pixels * 1;

        TestEven<CUB, SampleT, 1, 1, int, LevelT, int>(num_row_pixels, num_rows, row_stride_bytes, entropy_reduction, num_levels, max_level, num_levels[0]);
        if (compare_npp)
            TestEven<NPP, SampleT, 1, 1, int, LevelT, int>(num_row_pixels, num_rows, row_stride_bytes, entropy_reduction, num_levels, max_level, num_levels[0]);
    }

    {
        // HistogramEven: 4/4 multichannel Unsigned char 256 bins
        typedef unsigned char       SampleT;
        typedef int                 LevelT;

        LevelT  max_level           = 256;
        int     num_levels[4]       = {257, 257, 257, 257};
        int     row_stride_bytes    = sizeof(SampleT) * row_stride_pixels * 4;

        TestEven<CUB, SampleT, 4, 4, int, LevelT, int>(num_row_pixels, num_rows, row_stride_bytes, entropy_reduction, num_levels, max_level, num_levels[0]);
    }

    {
        // HistogramEven: 3/4 multichannel Unsigned char 256 bins
        typedef unsigned char       SampleT;
        typedef int                 LevelT;

        LevelT  max_level           = 256;
        int     num_levels[3]       = {257, 257, 257};
        int     row_stride_bytes    = sizeof(SampleT) * row_stride_pixels * 4;

        TestEven<CUB, SampleT, 4, 3, int, LevelT, int>(num_row_pixels, num_rows, row_stride_bytes, entropy_reduction, num_levels, max_level, num_levels[0]);
        if (compare_npp)
            TestEven<NPP, SampleT, 4, 3, int, LevelT, int>(num_row_pixels, num_rows, row_stride_bytes, entropy_reduction, num_levels, max_level, num_levels[0]);
    }

    {
        // HistogramEven: short [0,1024] 256 bins
        typedef unsigned short      SampleT;
        typedef unsigned short      LevelT;

        LevelT  max_level           = 1024;
        int     num_levels[1]       = {257};
        int     row_stride_bytes    = sizeof(SampleT) * row_stride_pixels * 1;

        TestEven<CUB, SampleT, 1, 1, int, LevelT, int>(num_row_pixels, num_rows, row_stride_bytes, entropy_reduction, num_levels, max_level, num_levels[0]);
    }

    {
        // HistogramEven: float [0,1.0] 256 bins
        typedef float               SampleT;
        typedef float               LevelT;

        LevelT  max_level           = 1.0;
        int     num_levels[1]       = {257};
        int     row_stride_bytes    = sizeof(SampleT) * row_stride_pixels * 1;

        TestEven<CUB, SampleT, 1, 1, int, LevelT, int>(num_row_pixels, num_rows, row_stride_bytes, entropy_reduction, num_levels, max_level, num_levels[0]);
    }

    {
        // HistogramEven: 3/4 multichannel float [0,1.0] 256 bins
        typedef float               SampleT;
        typedef float               LevelT;

         LevelT  max_level           = 1.0;
         int     num_levels[3]       = {257, 257, 257};
         int     row_stride_bytes    = sizeof(SampleT) * row_stride_pixels * 4;

         TestEven<CUB, SampleT, 4, 3, int, LevelT, int>(num_row_pixels, num_rows, row_stride_bytes, entropy_reduction, num_levels, max_level, num_levels[0]);
    }

    {
        // HistogramRange: signed char 256 bins
        typedef signed char         SampleT;
        typedef int                 LevelT;

        LevelT  max_level           = 256;
        int     num_levels[1]       = {257};
        int     row_stride_bytes    = sizeof(SampleT) * row_stride_pixels * 1;

        TestRange<CUB, SampleT, 1, 1, int, LevelT, int>(num_row_pixels, num_rows, row_stride_bytes, entropy_reduction, num_levels, max_level, num_levels[0]);
    }

    {
        // HistogramRange: 3/4 channel, unsigned char, varied bins (256, 128, 64)
        typedef unsigned char       SampleT;
        typedef int                 LevelT;

        LevelT  max_level           = 256;
        int     num_levels[3]       = {257, 129, 65};
        int     row_stride_bytes    = sizeof(SampleT) * row_stride_pixels * 4;

        TestRange<CUB, SampleT, 4, 3, int, LevelT, int>(num_row_pixels, num_rows, row_stride_bytes, entropy_reduction, num_levels, max_level, num_levels[0]);
    }

    if (ptx_version > 120)                          // Don't check doubles on PTX120 or below because they're down-converted
    {
        // HistogramEven: double [0,1.0] 64 bins
        typedef double              SampleT;
        typedef double              LevelT;

        LevelT  max_level           = 1.0;
        int     num_levels[1]       = {65};
        int     row_stride_bytes    = sizeof(SampleT) * row_stride_pixels * 1;

        TestEven<CUB, SampleT, 1, 1, int, LevelT, int>(num_row_pixels, num_rows, row_stride_bytes, entropy_reduction, num_levels, max_level, num_levels[0]);
    }

    {
        // HistogramEven: short [0,1024] 512 bins
        typedef unsigned short      SampleT;
        typedef unsigned short      LevelT;

        LevelT  max_level           = 1024;
        int     num_levels[1]       = {513};
        int     row_stride_bytes    = sizeof(SampleT) * row_stride_pixels * 1;

        TestEven<CUB, SampleT, 1, 1, int, LevelT, int>(num_row_pixels, num_rows, row_stride_bytes, entropy_reduction, num_levels, max_level, num_levels[0]);
    }

#else

    // Compile/run thorough tests
    for (int i = 0; i <= g_repeat; ++i)
    {
        TestChannels <unsigned char,    int, int,   int>(256,   256 + 1, Int2Type<true>());
        TestChannels <signed char,      int, int,   int>(256,   256 + 1, Int2Type<true>());
        TestChannels <unsigned short,   int, int,   int>(128,   128 + 1, Int2Type<true>());
        TestChannels <unsigned short,   int, int,   int>(8192,  8192 + 1, Int2Type<true>());
        TestChannels <float,            int, float, int>(1.0,   256 + 1, Int2Type<true>());

		// Test down-conversion of size_t offsets to int
        TestChannels <unsigned char,    int, int,   long long>(256, 256 + 1, Int2Type<(sizeof(size_t) != sizeof(int))>());
    }

#endif

    return 0;
}

",16335,True,2992.49123584779,median
"class ZCL_EXCEL_CONVERTER definition
  public
  create public .

*""* public components of class ZCL_EXCEL_CONVERTER
*""* do not include other source files here!!!
public section.
  type-pools ABAP .

  class-methods CLASS_CONSTRUCTOR .
  methods ASK_OPTION
    returning
      value(RS_OPTION) type ZEXCEL_S_CONVERTER_OPTION
    raising
      ZCX_EXCEL .
  methods CONVERT
    importing
      !IS_OPTION type ZEXCEL_S_CONVERTER_OPTION optional
      !IO_ALV type ref to OBJECT optional
      !IT_TABLE type STANDARD TABLE optional
      !I_ROW_INT type I default 1
      !I_COLUMN_INT type I default 1
      !I_TABLE type FLAG optional
      !I_STYLE_TABLE type ZEXCEL_TABLE_STYLE optional
      !IO_WORKSHEET type ref to ZCL_EXCEL_WORKSHEET optional
    changing
      !CO_EXCEL type ref to ZCL_EXCEL optional
    raising
      ZCX_EXCEL .
  methods CREATE_PATH
    returning
      value(R_PATH) type STRING .
  methods GET_FILE
    exporting
      !E_BYTECOUNT type I
      !ET_FILE type SOLIX_TAB
      !E_FILE type XSTRING .
  methods GET_OPTION
    returning
      value(RS_OPTION) type ZEXCEL_S_CONVERTER_OPTION .
  methods OPEN_FILE .
  methods SET_OPTION
    importing
      !IS_OPTION type ZEXCEL_S_CONVERTER_OPTION .
  methods WRITE_FILE
    importing
      !I_PATH type STRING optional .
*""* protected components of class ZCL_EXCEL_CONVERTER
*""* do not include other source files here!!!
protected section.

  types:
    BEGIN OF t_relationship,
           id     TYPE string,
           type   TYPE string,
           target TYPE string,
         END OF t_relationship .
  types:
    BEGIN OF t_fileversion,
            appname       TYPE string,
            lastedited    TYPE string,
            lowestedited  TYPE string,
            rupbuild      TYPE string,
            codename      TYPE string,
       END OF t_fileversion .
  types:
    BEGIN OF t_sheet,
              name    TYPE string,
              sheetid TYPE string,
              id      TYPE string,
         END OF t_sheet .
  types:
    BEGIN OF t_workbookpr,
              codename            TYPE string,
              defaultthemeversion TYPE string,
         END OF t_workbookpr .
  types:
    BEGIN OF t_sheetpr,
              codename            TYPE string,
         END OF t_sheetpr .

  data W_ROW_INT type ZEXCEL_CELL_ROW value 1. ""#EC NOTEXT .  .  .  .  .  .  .  .  .  . "" .
  data W_COL_INT type ZEXCEL_CELL_COLUMN value 1. ""#EC NOTEXT .  .  .  .  .  .  .  .  .  . "" .
*""* private components of class ZCL_EXCEL_CONVERTER
*""* do not include other source files here!!!
private section.

  data WO_EXCEL type ref to ZCL_EXCEL .
  data WO_WORKSHEET type ref to ZCL_EXCEL_WORKSHEET .
  data WO_AUTOFILTER type ref to ZCL_EXCEL_AUTOFILTER .
  data WO_TABLE type ref to DATA .
  data WO_DATA type ref to DATA .
  data WT_FIELDCATALOG type ZEXCEL_T_CONVERTER_FCAT .
  data WS_LAYOUT type ZEXCEL_S_CONVERTER_LAYO .
  data WT_COLORS type ZEXCEL_T_CONVERTER_COL .
  data WT_FILTER type ZEXCEL_T_CONVERTER_FIL .
  class-data WT_OBJECTS type TT_ALV_TYPES .
  class-data W_FCOUNT type NUMC3 .
  data WT_SORT_VALUES type TT_SORT_VALUES .
  data WT_SUBTOTAL_ROWS type TT_SUBTOTAL_ROWS .
  data WT_STYLES type TT_STYLES .
  constants C_TYPE_HDR type CHAR1 value 'H'. ""#EC NOTEXT
  constants C_TYPE_STR type CHAR1 value 'P'. ""#EC NOTEXT
  constants C_TYPE_NOR type CHAR1 value 'N'. ""#EC NOTEXT
  constants C_TYPE_SUB type CHAR1 value 'S'. ""#EC NOTEXT
  constants C_TYPE_TOT type CHAR1 value 'T'. ""#EC NOTEXT
  data WT_COLOR_STYLES type TT_COLOR_STYLES .
  class-data WS_OPTION type ZEXCEL_S_CONVERTER_OPTION .
  class-data WS_INDX type INDX .

  class-methods INIT_OPTION .
  methods BIND_TABLE
    importing
      !I_STYLE_TABLE type ZEXCEL_TABLE_STYLE
    returning
      value(R_FREEZE_COL) type INT1
    raising
      ZCX_EXCEL .
  methods BIND_CELLS
    returning
      value(R_FREEZE_COL) type INT1
    raising
      ZCX_EXCEL .
  methods CLEAN_FIELDCATALOG .
  methods CREATE_COLOR_STYLE
    importing
      !I_STYLE type ZEXCEL_CELL_STYLE
      !IS_COLORS type ZEXCEL_S_CONVERTER_COL
    returning
      value(RO_STYLE) type ref to ZCL_EXCEL_STYLE .
  methods CREATE_FORMULAR_SUBTOTAL
    importing
      !I_ROW_INT_START type ZEXCEL_CELL_ROW
      !I_ROW_INT_END type ZEXCEL_CELL_ROW
      !I_COLUMN type ZEXCEL_CELL_COLUMN_ALPHA
      !I_TOTALS_FUNCTION type ZEXCEL_TABLE_TOTALS_FUNCTION
    returning
      value(R_FORMULA) type STRING .
  methods CREATE_FORMULAR_TOTAL
    importing
      !I_ROW_INT type ZEXCEL_CELL_ROW
      !I_COLUMN type ZEXCEL_CELL_COLUMN_ALPHA
      !I_TOTALS_FUNCTION type ZEXCEL_TABLE_TOTALS_FUNCTION
    returning
      value(R_FORMULA) type STRING .
  methods CREATE_STYLE_HDR
    importing
      !I_ALIGNMENT type ZEXCEL_ALIGNMENT optional
    returning
      value(RO_STYLE) type ref to ZCL_EXCEL_STYLE .
  methods CREATE_STYLE_NORMAL
    importing
      !I_ALIGNMENT type ZEXCEL_ALIGNMENT optional
      !I_INTTYPE type INTTYPE optional
      !I_DECIMALS type INT1 optional
    returning
      value(RO_STYLE) type ref to ZCL_EXCEL_STYLE .
  methods CREATE_STYLE_STRIPPED
    importing
      !I_ALIGNMENT type ZEXCEL_ALIGNMENT optional
      !I_INTTYPE type INTTYPE optional
      !I_DECIMALS type INT1 optional
    returning
      value(RO_STYLE) type ref to ZCL_EXCEL_STYLE .
  methods CREATE_STYLE_SUBTOTAL
    importing
      !I_ALIGNMENT type ZEXCEL_ALIGNMENT optional
      !I_INTTYPE type INTTYPE optional
      !I_DECIMALS type INT1 optional
    returning
      value(RO_STYLE) type ref to ZCL_EXCEL_STYLE .
  methods CREATE_STYLE_TOTAL
    importing
      !I_ALIGNMENT type ZEXCEL_ALIGNMENT optional
      !I_INTTYPE type INTTYPE optional
      !I_DECIMALS type INT1 optional
    returning
      value(RO_STYLE) type ref to ZCL_EXCEL_STYLE .
  methods CREATE_TABLE .
  methods CREATE_TEXT_SUBTOTAL
    importing
      !I_VALUE type ANY
      !I_TOTALS_FUNCTION type ZEXCEL_TABLE_TOTALS_FUNCTION
    returning
      value(R_TEXT) type STRING .
  methods CREATE_WORKSHEET
    importing
      !I_TABLE type FLAG default 'X'
      !I_STYLE_TABLE type ZEXCEL_TABLE_STYLE
    raising
      ZCX_EXCEL .
  methods EXECUTE_CONVERTER
    importing
      !IO_OBJECT type ref to OBJECT
      !IT_TABLE type STANDARD TABLE
    raising
      ZCX_EXCEL .
  methods GET_COLOR_STYLE
    importing
      !I_ROW type ZEXCEL_CELL_ROW
      !I_FIELDNAME type FIELDNAME
      !I_STYLE type ZEXCEL_CELL_STYLE
    returning
      value(R_STYLE) type ZEXCEL_CELL_STYLE .
  methods GET_FUNCTION_NUMBER
    importing
      !I_TOTALS_FUNCTION type ZEXCEL_TABLE_TOTALS_FUNCTION
    returning
      value(R_FUNCTION_NUMBER) type INT1 .
  methods GET_STYLE
    importing
      !I_TYPE type CHAR1
      !I_ALIGNMENT type ZEXCEL_ALIGNMENT default SPACE
      !I_INTTYPE type INTTYPE default SPACE
      !I_DECIMALS type INT1 default 0
    returning
      value(R_STYLE) type ZEXCEL_CELL_STYLE .
  methods LOOP_NORMAL
    importing
      !I_ROW_INT type ZEXCEL_CELL_ROW
      !I_COL_INT type ZEXCEL_CELL_COLUMN
    returning
      value(R_FREEZE_COL) type INT1
    raising
      ZCX_EXCEL .
  methods LOOP_SUBTOTAL
    importing
      !I_ROW_INT type ZEXCEL_CELL_ROW
      !I_COL_INT type ZEXCEL_CELL_COLUMN
    returning
      value(R_FREEZE_COL) type INT1
    raising
      ZCX_EXCEL .
  methods SET_AUTOFILTER_AREA .
  methods SET_CELL_FORMAT
    importing
      !I_INTTYPE type INTTYPE
      !I_DECIMALS type INT1
    returning
      value(R_FORMAT) type ZEXCEL_NUMBER_FORMAT .
  methods SET_FIELDCATALOG .
ENDCLASS.



CLASS ZCL_EXCEL_CONVERTER IMPLEMENTATION.


METHOD ask_option.
  DATA: ls_sval TYPE sval,
        lt_sval TYPE STANDARD TABLE OF sval,
        l_returncode TYPE string,
        lt_fields    TYPE ddfields,
        ls_fields    TYPE dfies.

  FIELD-SYMBOLS: <fs> TYPE any.

  rs_option = ws_option.

  CALL FUNCTION 'DDIF_FIELDINFO_GET'
    EXPORTING
      tabname        = 'ZEXCEL_S_CONVERTER_OPTION'
    TABLES
      dfies_tab      = lt_fields
    EXCEPTIONS
      not_found      = 1
      internal_error = 2
      OTHERS         = 3.
  IF sy-subrc <> 0.
    MESSAGE ID sy-msgid TYPE sy-msgty NUMBER sy-msgno
            WITH sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4.
  ENDIF.

  LOOP AT lt_fields INTO ls_fields.
    ASSIGN COMPONENT ls_fields-fieldname OF STRUCTURE ws_option TO <fs>.
    IF sy-subrc = 0.
      CLEAR ls_sval.
      ls_sval-tabname      = ls_fields-tabname.
      ls_sval-fieldname    = ls_fields-fieldname.
      ls_sval-value        = <fs>.
      ls_sval-field_attr   = space.
      ls_sval-field_obl    = space.
      ls_sval-comp_code    = space.
      ls_sval-fieldtext    = ls_fields-scrtext_m.
      ls_sval-comp_tab     = space.
      ls_sval-comp_field   = space.
      ls_sval-novaluehlp   = space.
      INSERT ls_sval INTO TABLE lt_sval.
    ENDIF.
  ENDLOOP.

  CALL FUNCTION 'POPUP_GET_VALUES'
    EXPORTING
      popup_title     = 'Excel creation options'(008)
    IMPORTING
      returncode      = l_returncode
    TABLES
      fields          = lt_sval
    EXCEPTIONS
      error_in_fields = 1
      OTHERS          = 2.
  IF sy-subrc <> 0.
    MESSAGE ID sy-msgid TYPE sy-msgty NUMBER sy-msgno
            WITH sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4.
  ELSE.
    IF l_returncode = 'A'.
      RAISE EXCEPTION TYPE zcx_excel.
    ELSE.
      LOOP AT lt_sval INTO ls_sval.
        ASSIGN COMPONENT ls_sval-fieldname OF STRUCTURE ws_option TO <fs>.
        IF sy-subrc = 0.
          <fs> = ls_sval-value.
        ENDIF.
      ENDLOOP.
      set_option( is_option = ws_option ) .
      rs_option = ws_option.
    ENDIF.
  ENDIF.
ENDMETHOD.


method BIND_CELLS.

* Do we need subtotals with grouping
  READ TABLE wt_fieldcatalog TRANSPORTING NO FIELDS WITH KEY is_subtotalled = abap_true.
  IF sy-subrc = 0  .
    r_freeze_col = loop_subtotal( i_row_int = w_row_int
                                  i_col_int  = w_col_int ) .
  ELSE.
    r_freeze_col = loop_normal( i_row_int = w_row_int
                                i_col_int = w_col_int ) .
  ENDIF.

  endmethod.


METHOD bind_table.
  DATA: lt_field_catalog  TYPE zexcel_t_fieldcatalog,
        ls_field_catalog  TYPE zexcel_s_fieldcatalog,
        ls_fcat           TYPE zexcel_s_converter_fcat,
        lo_column         TYPE REF TO zcl_excel_column,
        lo_row            TYPE REF TO zcl_excel_row,
        lv_col_int        TYPE zexcel_cell_column,
        lv_col_alpha      TYPE zexcel_cell_column_alpha,
        ls_settings       TYPE zexcel_s_table_settings,
        lv_line           TYPE i.

  FIELD-SYMBOLS: <fs_tab>         TYPE ANY TABLE.

  ASSIGN wo_data->* TO <fs_tab> .

  ls_settings-table_style      = i_style_table.
  ls_settings-top_left_column  = zcl_excel_common=>convert_column2alpha( ip_column = w_col_int ).
  ls_settings-top_left_row     = w_row_int.
  ls_settings-show_row_stripes = ws_layout-is_stripped.

  DESCRIBE TABLE  wt_fieldcatalog  LINES lv_line.
  lv_line = lv_line + 1 + w_col_int.
  ls_settings-bottom_right_column = zcl_excel_common=>convert_column2alpha( ip_column = lv_line ).

  DESCRIBE TABLE <fs_tab> LINES lv_line.
  ls_settings-bottom_right_row = lv_line + 1 + w_row_int.
  SORT wt_fieldcatalog BY position.
  LOOP AT wt_fieldcatalog INTO ls_fcat.
    MOVE-CORRESPONDING ls_fcat TO ls_field_catalog.
    ls_field_catalog-dynpfld = abap_true.
    INSERT ls_field_catalog INTO TABLE lt_field_catalog.
  ENDLOOP.

  wo_worksheet->bind_table(
    EXPORTING
      ip_table          = <fs_tab>
      it_field_catalog  = lt_field_catalog
      is_table_settings = ls_settings
    IMPORTING
      es_table_settings = ls_settings
         ).
  LOOP AT wt_fieldcatalog INTO ls_fcat.
    lv_col_int = w_col_int + ls_fcat-position - 1.
    lv_col_alpha = zcl_excel_common=>convert_column2alpha( lv_col_int ).
* Freeze panes
    IF ls_fcat-fix_column = abap_true.
      ADD 1 TO r_freeze_col.
    ENDIF.
* Now let's check for optimized
    IF ls_fcat-is_optimized = abap_true.
      lo_column = wo_worksheet->get_column( ip_column = lv_col_alpha ).
      lo_column->set_auto_size( ip_auto_size = abap_true ) .
    ENDIF.
* Now let's check for visible
    IF ls_fcat-is_hidden = abap_true.
      lo_column = wo_worksheet->get_column( ip_column = lv_col_alpha ).
      lo_column->set_visible( ip_visible = abap_false ) .
    ENDIF.
  ENDLOOP.

ENDMETHOD.


method CLASS_CONSTRUCTOR.
  DATA: ls_objects TYPE ts_alv_types.
  DATA: ls_option TYPE zexcel_s_converter_option,
        l_uname TYPE sy-uname.

  GET PARAMETER ID 'ZUS' FIELD l_uname.
  IF l_uname IS INITIAL OR l_uname = space.
    l_uname = sy-uname.
  ENDIF.

* Object CL_GUI_ALV_GRID
  ls_objects-seoclass  = 'CL_GUI_ALV_GRID'.
  ls_objects-clsname   = 'ZCL_EXCEL_CONVERTER_ALV_GRID'.
  INSERT ls_objects INTO TABLE wt_objects.

* Object CL_SALV_TABLE
  ls_objects-seoclass  = 'CL_SALV_TABLE'.
  ls_objects-clsname   = 'ZCL_EXCEL_CONVERTER_SALV_TABLE'.
  INSERT ls_objects INTO TABLE wt_objects.

* Object CL_SALV_RESULT
  ls_objects-seoclass  = 'CL_SALV_EX_RESULT_DATA_TABLE '.
  ls_objects-clsname   = 'ZCL_EXCEL_CONVERTER_RESULT_EX'.
  INSERT ls_objects INTO TABLE wt_objects.
* Object CL_SALV_WD_RESULT
  ls_objects-seoclass  = 'CL_SALV_WD_RESULT_DATA_TABLE '.
  ls_objects-clsname   = 'ZCL_EXCEL_CONVERTER_RESULT_WD'.
  INSERT ls_objects INTO TABLE wt_objects.

  CONCATENATE 'EXCEL_' sy-uname INTO ws_indx-srtfd.

  IMPORT p1 = ls_option FROM DATABASE indx(xl) TO ws_indx ID ws_indx-srtfd.

  IF sy-subrc = 0.
    ws_option = ls_option.
  ELSE.
    init_option( ) .
  ENDIF.

  endmethod.


method CLEAN_FIELDCATALOG.
  DATA: l_position TYPE int1.

  FIELD-SYMBOLS: <fs_sfcat>   TYPE zexcel_s_converter_fcat.

  SORT wt_fieldcatalog BY position col_id.

  CLEAR l_position.
  LOOP AT wt_fieldcatalog ASSIGNING <fs_sfcat>.
    ADD 1 TO l_position.
    <fs_sfcat>-position = l_position.
* Default stype with alignment and format
    <fs_sfcat>-style_hdr      = get_style( i_type      = c_type_hdr
                                           i_alignment = <fs_sfcat>-alignment ).
    IF ws_layout-is_stripped = abap_true.
      <fs_sfcat>-style_stripped = get_style( i_type      = c_type_str
                                             i_alignment = <fs_sfcat>-alignment
                                             i_inttype   = <fs_sfcat>-inttype
                                             i_decimals  = <fs_sfcat>-decimals   ).
    ENDIF.
    <fs_sfcat>-style_normal   = get_style( i_type      = c_type_nor
                                           i_alignment = <fs_sfcat>-alignment
                                           i_inttype   = <fs_sfcat>-inttype
                                           i_decimals  = <fs_sfcat>-decimals   ).
    <fs_sfcat>-style_subtotal = get_style( i_type      = c_type_sub
                                           i_alignment = <fs_sfcat>-alignment
                                           i_inttype   = <fs_sfcat>-inttype
                                           i_decimals  = <fs_sfcat>-decimals   ).
    <fs_sfcat>-style_total    = get_style( i_type      = c_type_tot
                                           i_alignment = <fs_sfcat>-alignment
                                           i_inttype   = <fs_sfcat>-inttype
                                           i_decimals  = <fs_sfcat>-decimals   ).
  ENDLOOP.

  endmethod.


method CONVERT.

  IF is_option IS SUPPLIED.
    ws_option = is_option.
  ENDIF.

  execute_converter( EXPORTING io_object   = io_alv
                               it_table    = it_table ) .

  IF io_worksheet IS SUPPLIED AND io_worksheet IS BOUND.
    wo_worksheet = io_worksheet.
  ENDIF.
  IF co_excel IS SUPPLIED.
    IF co_excel IS NOT BOUND.
      CREATE OBJECT co_excel.
      co_excel->zif_excel_book_properties~creator = sy-uname.
    ENDIF.
    wo_excel = co_excel.
  ENDIF.

* Move table to data object and clean it up
  IF wt_fieldcatalog IS NOT INITIAL.
    create_table( ).
  ELSE.
    wo_data = wo_table .
  ENDIF.

  IF wo_excel IS NOT BOUND.
    CREATE OBJECT wo_excel.
    wo_excel->zif_excel_book_properties~creator = sy-uname.
  ENDIF.
  IF wo_worksheet IS NOT BOUND.
    "" Get active sheet
    wo_worksheet = wo_excel->get_active_worksheet( ).
    wo_worksheet->set_title( ip_title = 'Sheet1'(001) ).
  ENDIF.

  IF i_row_int <= 0.
    w_row_int = 1.
  ELSE.
    w_row_int = i_row_int.
  ENDIF.
  IF i_column_int <= 0.
    w_col_int = 1.
  ELSE.
    w_col_int = i_column_int.
  ENDIF.

  create_worksheet( i_table       = i_table
                    i_style_table = i_style_table ) .

  endmethod.


method CREATE_COLOR_STYLE.
  DATA: ls_styles TYPE ts_styles.
  DATA: lo_style TYPE REF TO zcl_excel_style.

  READ TABLE wt_styles INTO ls_styles WITH KEY guid = i_style.
  IF sy-subrc = 0.
    lo_style                 = wo_excel->add_new_style( ).
*    lo_style->borders        = ls_styles-style->borders.
*    lo_style->protection     = ls_styles-style->protection.
    lo_style->font->bold                 = ls_styles-style->font->bold.
    lo_style->alignment->horizontal      = ls_styles-style->alignment->horizontal.
    lo_style->number_format->format_code = ls_styles-style->number_format->format_code.

    lo_style->font->color-rgb      = is_colors-fontcolor.
    lo_style->fill->filltype       = zcl_excel_style_fill=>c_fill_solid.
    lo_style->fill->fgcolor-rgb    = is_colors-fillcolor.

    ro_style = lo_style.
  ENDIF.
  endmethod.


method CREATE_FORMULAR_SUBTOTAL.
  data: l_row_alpha_start type string,
        l_row_alpha_end   type string,
        l_func_num        type string.

  l_row_alpha_start   = i_row_int_start.
  l_row_alpha_end     = i_row_int_end.

  l_func_num = get_function_number( i_totals_function = i_totals_function ).
  concatenate 'SUBTOTAL(' l_func_num ',' i_column l_row_alpha_start ':' i_column l_row_alpha_end ')' into r_formula.
  endmethod.


method CREATE_FORMULAR_TOTAL.
  data: l_row_alpha    type string,
        l_row_e_alpha  type string.

  l_row_alpha   = w_row_int + 1.
  l_row_e_alpha = i_row_int.

  concatenate i_totals_function '(' i_column l_row_alpha ':' i_column l_row_e_alpha ')' into r_formula.
  endmethod.


method CREATE_PATH.
  DATA:   l_sep                   TYPE c ,
          l_path                  TYPE string,
          l_return                TYPE i .

  CLEAR r_path.

  "" Save the file
  cl_gui_frontend_services=>get_sapgui_workdir(
    CHANGING
      sapworkdir            = l_path
        EXCEPTIONS
          get_sapworkdir_failed = 1
          cntl_error            = 2
          error_no_gui          = 3
          not_supported_by_gui  = 4
         ).
  IF sy-subrc <> 0.
*       MESSAGE ID SY-MSGID TYPE SY-MSGTY NUMBER SY-MSGNO
*                  WITH SY-MSGV1 SY-MSGV2 SY-MSGV3 SY-MSGV4.
    CONCATENATE 'Excel_' w_fcount '.xlsx' INTO r_path.
  ELSE.
    DO.
      ADD 1 TO w_fcount.
*-obtain file separator character---------------------------------------
      CALL METHOD cl_gui_frontend_services=>get_file_separator
        CHANGING
          file_separator       = l_sep
        EXCEPTIONS
          cntl_error           = 1
          error_no_gui         = 2
          not_supported_by_gui = 3
          OTHERS               = 4.

      IF sy-subrc <> 0.
        l_sep = ''.
      ENDIF.

      CONCATENATE l_path l_sep 'Excel_' w_fcount '.xlsx' INTO r_path.

      IF cl_gui_frontend_services=>file_exist( file  = r_path ) = abap_true.
        cl_gui_frontend_services=>file_delete( EXPORTING filename = r_path
                                               CHANGING  rc       = l_return
                                               EXCEPTIONS OTHERS  = 1 ).
        IF sy-subrc = 0 .
          RETURN.
        ENDIF.
      ELSE.
        RETURN.
      ENDIF.
    ENDDO.
  ENDIF.

  endmethod.


method CREATE_STYLE_HDR.
  data: lo_style type ref to zcl_excel_style.

  lo_style                       = wo_excel->add_new_style( ).
  lo_style->font->bold           = abap_true.
  lo_style->font->color-rgb      = zcl_excel_style_color=>c_white.
  lo_style->fill->filltype       = zcl_excel_style_fill=>c_fill_solid.
  lo_style->fill->fgcolor-rgb    = 'FF4F81BD'.
  if i_alignment is supplied and i_alignment is not initial.
    lo_style->alignment->horizontal = i_alignment.
  endif.
  ro_style = lo_style .
  endmethod.


method CREATE_STYLE_NORMAL.
  DATA:   lo_style    TYPE REF TO zcl_excel_style,
          l_format    TYPE zexcel_number_format.

  IF i_inttype IS SUPPLIED AND i_inttype IS NOT INITIAL.
    l_format = set_cell_format(  i_inttype  = i_inttype
                                 i_decimals = i_decimals ) .
  ENDIF.
  IF l_format IS NOT INITIAL OR
     ( i_alignment IS SUPPLIED AND i_alignment IS NOT INITIAL ) .

    lo_style                       = wo_excel->add_new_style( ).

    IF i_alignment IS SUPPLIED AND i_alignment IS NOT INITIAL.
      lo_style->alignment->horizontal = i_alignment.
    ENDIF.

    IF l_format IS NOT INITIAL.
      lo_style->number_format->format_code = l_format.
    ENDIF.

    ro_style = lo_style .

  ENDIF.
  endmethod.


method CREATE_STYLE_STRIPPED.
  data:   lo_style    type ref to zcl_excel_style.
  data:  l_format    type zexcel_number_format.

  lo_style                       = wo_excel->add_new_style( ).
  lo_style->fill->filltype       = zcl_excel_style_fill=>c_fill_solid.
  lo_style->fill->fgcolor-rgb    = 'FFDBE5F1'.
  if i_alignment is supplied and i_alignment is not initial.
    lo_style->alignment->horizontal = i_alignment.
  endif.
  if i_inttype is supplied and i_inttype is not initial.
    l_format = set_cell_format(  i_inttype  = i_inttype
                                 i_decimals = i_decimals ) .
    if l_format is not initial.
      lo_style->number_format->format_code = l_format.
    endif.
  endif.
  ro_style = lo_style.

  endmethod.


method CREATE_STYLE_SUBTOTAL.
  data:   lo_style    type ref to zcl_excel_style.
  data:  l_format    type zexcel_number_format.

  lo_style                       = wo_excel->add_new_style( ).
  lo_style->font->bold           = abap_true.

  if i_alignment is supplied and i_alignment is not initial.
    lo_style->alignment->horizontal = i_alignment.
  endif.
  if i_inttype is supplied and i_inttype is not initial.
    l_format = set_cell_format(  i_inttype  = i_inttype
                                 i_decimals = i_decimals ) .
    if l_format is not initial.
      lo_style->number_format->format_code = l_format.
    endif.
  endif.

  ro_style = lo_style .

  endmethod.


method CREATE_STYLE_TOTAL.
  DATA:   lo_style    TYPE REF TO zcl_excel_style.
  DATA:  l_format    TYPE zexcel_number_format.

  lo_style                                   = wo_excel->add_new_style( ).
  lo_style->font->bold                       = abap_true.

  CREATE OBJECT lo_style->borders->top.
  lo_style->borders->top->border_style       = zcl_excel_style_border=>c_border_thin.
  lo_style->borders->top->border_color-rgb   = zcl_excel_style_color=>c_black.

  CREATE OBJECT lo_style->borders->right.
  lo_style->borders->right->border_style       = zcl_excel_style_border=>c_border_none.
  lo_style->borders->right->border_color-rgb   = zcl_excel_style_color=>c_black.

  CREATE OBJECT lo_style->borders->down.
  lo_style->borders->down->border_style      = zcl_excel_style_border=>c_border_double.
  lo_style->borders->down->border_color-rgb  = zcl_excel_style_color=>c_black.

  CREATE OBJECT lo_style->borders->left.
  lo_style->borders->left->border_style       = zcl_excel_style_border=>c_border_none.
  lo_style->borders->left->border_color-rgb   = zcl_excel_style_color=>c_black.

  IF i_alignment IS SUPPLIED AND i_alignment IS NOT INITIAL.
    lo_style->alignment->horizontal = i_alignment.
  ENDIF.
  IF i_inttype IS SUPPLIED AND i_inttype IS NOT INITIAL.
    l_format = set_cell_format(  i_inttype  = i_inttype
                                 i_decimals = i_decimals ) .
    IF l_format IS NOT INITIAL.
      lo_style->number_format->format_code = l_format.
    ENDIF.
  ENDIF.

  ro_style = lo_style .

  endmethod.


method CREATE_TABLE.
  TYPES: BEGIN OF ts_output,
           fieldname TYPE fieldname,
           function  TYPE funcname,
         END OF ts_output.

  DATA: lo_data TYPE REF TO data.
  DATA: lo_addit                TYPE REF TO cl_abap_elemdescr,
        lt_components_tab       TYPE cl_abap_structdescr=>component_table,
        ls_components           TYPE abap_componentdescr,
        lo_table                TYPE REF TO cl_abap_tabledescr,
        lo_struc                TYPE REF TO cl_abap_structdescr.

  FIELD-SYMBOLS: <fs_scat>  TYPE zexcel_s_converter_fcat,
                 <fs_stab>  TYPE ANY,
                 <fs_ttab>  TYPE STANDARD TABLE,
                 <fs>       TYPE ANY,
                 <fs_table> TYPE STANDARD TABLE.

  SORT wt_fieldcatalog BY position.
  ASSIGN wo_table->* TO <fs_table>.

  READ TABLE <fs_table> ASSIGNING <fs_stab> INDEX 1.
  IF sy-subrc EQ 0 .
    LOOP AT wt_fieldcatalog ASSIGNING <fs_scat>.
      ASSIGN COMPONENT <fs_scat>-columnname OF STRUCTURE <fs_stab> TO <fs>.
      IF sy-subrc = 0.
        ls_components-name   = <fs_scat>-columnname.
        TRY.
            lo_addit            ?= cl_abap_typedescr=>describe_by_data( <fs> ).
          CATCH cx_sy_move_cast_error.
            CLEAR lo_addit.
            DELETE TABLE wt_fieldcatalog FROM <fs_scat>.
        ENDTRY.
        IF lo_addit IS BOUND.
          ls_components-type   = lo_addit           .
          INSERT ls_components INTO TABLE lt_components_tab.
        ENDIF.
      ENDIF.
    ENDLOOP.
    IF lt_components_tab IS NOT INITIAL.
      ""create new line type
      TRY.
          lo_struc = cl_abap_structdescr=>create( P_COMPONENTS = lt_components_tab
                                                  P_STRICT     = abap_false ).
        CATCH cx_sy_struct_creation.
          RETURN.  "" We can not do anything in this case.
      ENDTRY.

      lo_table = cl_abap_tabledescr=>create( lo_struc ).

      CREATE DATA wo_data   TYPE HANDLE lo_table.
      CREATE DATA lo_data   TYPE HANDLE lo_struc.

      ASSIGN wo_data->* TO <fs_ttab>.
      ASSIGN lo_data->* TO <fs_stab>.
      LOOP AT <fs_table>  ASSIGNING <fs>.
        CLEAR <fs_stab>.
        MOVE-CORRESPONDING <fs> TO <fs_stab>.
        APPEND <fs_stab> TO <fs_ttab>.
      ENDLOOP.
    ENDIF.
  ENDIF.

  endmethod.


METHOD create_text_subtotal.
  DATA: l_string(256) TYPE c,
        l_func   TYPE string.

  CASE i_totals_function.
    WHEN zcl_excel_table=>totals_function_sum.     "" Total
      l_func = 'Total'(003).
    WHEN zcl_excel_table=>totals_function_min.     "" Minimum
      l_func = 'Minimum'(004).
    WHEN zcl_excel_table=>totals_function_max.     "" Maximum
      l_func = 'Maximum'(005).
    WHEN zcl_excel_table=>totals_function_average. "" Mean Value
      l_func = 'Average'(006).
    WHEN zcl_excel_table=>totals_function_count.   "" Count
      l_func = 'Count'(007).
    WHEN OTHERS.
      CLEAR l_func.
  ENDCASE.

  MOVE i_value TO l_string.

  CONCATENATE l_string l_func INTO r_text SEPARATED BY space.

ENDMETHOD.


method CREATE_WORKSHEET.
  DATA: l_freeze_col TYPE i.

  IF wo_data IS BOUND AND wo_worksheet IS BOUND.

    wo_worksheet->zif_excel_sheet_properties~summarybelow = zif_excel_sheet_properties=>c_below_on. "" By default is on

    IF wt_fieldcatalog IS INITIAL.
      set_fieldcatalog( ) .
    ELSE.
      clean_fieldcatalog( ) .
    ENDIF.

    IF i_table = abap_true.
      l_freeze_col = bind_table( i_style_table = i_style_table ) .
    ELSE.
* Let's check for filter.
      IF wt_filter IS NOT INITIAL.
        wo_autofilter = wo_excel->add_new_autofilter( io_sheet = wo_worksheet ).
        l_freeze_col = bind_cells( ) .
        set_autofilter_area( ) .
      ELSE.
        l_freeze_col = bind_cells( ) .
      ENDIF.

    ENDIF.

* Check for freeze panes
    IF ws_layout-is_fixed = abap_true.
      IF l_freeze_col = 0.
        l_freeze_col = w_col_int.
      ENDIF.
      wo_worksheet->freeze_panes( EXPORTING ip_num_columns = l_freeze_col
                                            ip_num_rows    = w_row_int ) .
    ENDIF.
  ENDIF.

  endmethod.


method EXECUTE_CONVERTER.
  DATA: lo_if                   TYPE REF TO zif_excel_converter,
        ls_types                TYPE ts_alv_types,
        lo_addit                TYPE REF TO cl_abap_classdescr,
        lo_addit_superclass     type ref to cl_abap_classdescr.

  IF io_object IS BOUND.
    TRY.
        lo_addit            ?= cl_abap_typedescr=>describe_by_object_ref( io_object ).
      CATCH cx_sy_move_cast_error.
        RAISE EXCEPTION TYPE zcx_excel.
    ENDTRY.
    ls_types-seoclass = lo_addit->get_relative_name( ).
    READ TABLE wt_objects INTO ls_types WITH TABLE KEY seoclass = ls_types-seoclass.
    if sy-subrc ne 0.
      do.
        free lo_addit_superclass.
        lo_addit_superclass = lo_addit->get_super_class_type( ).
        if lo_addit_superclass is initial.
          sy-subrc = '4'.
          exit.
        endif.
        lo_addit = lo_addit_superclass.
        ls_types-seoclass = lo_addit->get_relative_name( ).
        read table wt_objects into ls_types with table key seoclass = ls_types-seoclass.
        if sy-subrc eq 0.
          exit.
        endif.
      enddo.
    endif.
    if sy-subrc = 0.
      CREATE OBJECT lo_if type (ls_types-clsname).
      lo_if->create_fieldcatalog(
        exporting
          is_option       = ws_option
          io_object       = io_object
          it_table        = it_table
        importing
          es_layout       = ws_layout
          et_fieldcatalog = wt_fieldcatalog
          eo_table        = wo_table
          et_colors       = wt_colors
          et_filter       = wt_filter
          ).
*  data lines of highest level.
      if ws_layout-max_subtotal_level > 0. add 1 to ws_layout-max_subtotal_level. endif.
    else.
      RAISE EXCEPTION type zcx_excel.
    endif.
  else.
    refresh wt_fieldcatalog.
    get reference of it_table into wo_table.
  endif.
endmethod.


method GET_COLOR_STYLE.
  DATA: ls_colors         TYPE zexcel_s_converter_col,
        ls_color_styles   TYPE ts_color_styles,
        lo_style          TYPE REF TO zcl_excel_style.

  r_style = i_style. "" Default we change nothing

  IF wt_colors IS NOT INITIAL.
* Full line has color
    READ TABLE wt_colors INTO ls_colors WITH KEY rownumber   = i_row
                                                 columnname  = space.
    IF sy-subrc = 0.
      READ TABLE wt_color_styles INTO ls_color_styles WITH KEY guid_old  = i_style
                                                               fontcolor = ls_colors-fontcolor
                                                               fillcolor = ls_colors-fillcolor.
      IF sy-subrc = 0.
        r_style = ls_color_styles-style_new->get_guid( ).
      ELSE.
        lo_style = create_color_style( i_style          = i_style
                                       is_colors        = ls_colors ) .
        r_style = lo_style->get_guid( ) .
        ls_color_styles-guid_old  = i_style.
        ls_color_styles-fontcolor = ls_colors-fontcolor.
        ls_color_styles-fillcolor = ls_colors-fillcolor.
        ls_color_styles-style_new = lo_style.
        INSERT ls_color_styles INTO TABLE wt_color_styles.
      ENDIF.
    ELSE.
* Only field has color
      READ TABLE wt_colors INTO ls_colors WITH KEY rownumber   = i_row
                                                   columnname  = i_fieldname.
      IF sy-subrc = 0.
        READ TABLE wt_color_styles INTO ls_color_styles WITH KEY guid_old  = i_style
                                                                 fontcolor = ls_colors-fontcolor
                                                                 fillcolor = ls_colors-fillcolor.
        IF sy-subrc = 0.
          r_style = ls_color_styles-style_new->get_guid( ).
        ELSE.
          lo_style = create_color_style( i_style          = i_style
                                         is_colors        = ls_colors ) .
          ls_color_styles-guid_old  = i_style.
          ls_color_styles-fontcolor = ls_colors-fontcolor.
          ls_color_styles-fillcolor = ls_colors-fillcolor.
          ls_color_styles-style_new = lo_style.
          INSERT ls_color_styles INTO TABLE wt_color_styles.
          r_style = ls_color_styles-style_new->get_guid( ).
        ENDIF.
      ELSE.
        r_style = i_style.
      ENDIF.
    ENDIF.
  ELSE.
    r_style = i_style.
  ENDIF.

  endmethod.


method GET_FILE.
  data: lo_excel_writer         type ref to zif_excel_writer.

  data: ls_seoclass type seoclass.


  if wo_excel is bound.
    create object lo_excel_writer type zcl_excel_writer_2007.
    e_file = lo_excel_writer->write_file( wo_excel ).

    select single * into ls_seoclass
      from seoclass
      where clsname = 'CL_BCS_CONVERT'.

    if sy-subrc = 0.
      call method (ls_seoclass-clsname)=>xstring_to_solix
        exporting
          iv_xstring = e_file
        receiving
          et_solix   = et_file.
      e_bytecount = xstrlen( e_file ).
    else.
      "" Convert to binary
      call function 'SCMS_XSTRING_TO_BINARY'
        exporting
          buffer        = e_file
        importing
          output_length = e_bytecount
        tables
          binary_tab    = et_file.
    endif.
  endif.

  endmethod.


method GET_FUNCTION_NUMBER.
*Number	Function
*1  AVERAGE
*2  COUNT
*3  COUNTA
*4  MAX
*5  MIN
*6  PRODUCT
*7  STDEV
*8  STDEVP
*9  SUM
*10  VAR
*11  VARP

  case i_totals_function.
    when ZCL_EXCEL_TABLE=>TOTALS_FUNCTION_SUM.     "" Total
      r_function_number = 9.
    when ZCL_EXCEL_TABLE=>TOTALS_FUNCTION_MIN.     "" Minimum
      r_function_number = 5.
    when ZCL_EXCEL_TABLE=>TOTALS_FUNCTION_MAX.     "" Maximum
      r_function_number = 4.
    when ZCL_EXCEL_TABLE=>TOTALS_FUNCTION_AVERAGE. "" Mean Value
      r_function_number = 1.
    when ZCL_EXCEL_TABLE=>TOTALS_FUNCTION_count.   "" Count
      r_function_number = 2.
    when others.
      clear r_function_number.
  endcase.
  endmethod.


method GET_OPTION.

  rs_option = ws_option.

  endmethod.


method GET_STYLE.
  DATA:   ls_styles TYPE ts_styles,
          lo_style  TYPE REF TO zcl_excel_style.

  CLEAR r_style.

  READ TABLE wt_styles INTO ls_styles WITH TABLE KEY type      = i_type
                                                     alignment = i_alignment
                                                     inttype   = i_inttype
                                                     decimals  = i_decimals.
  IF sy-subrc = 0.
    r_style = ls_styles-guid.
  ELSE.
    CASE i_type.
      WHEN c_type_hdr. "" Header
        lo_style = create_style_hdr( i_alignment = i_alignment ).
      WHEN c_type_str. ""Stripped
        lo_style   = create_style_stripped( i_alignment = i_alignment
                                            i_inttype   = i_inttype
                                            i_decimals  = i_decimals   ).
      WHEN c_type_nor. ""Normal
        lo_style   = create_style_normal( i_alignment = i_alignment
                                          i_inttype   = i_inttype
                                          i_decimals  = i_decimals   ).
      WHEN c_type_sub. ""Subtotals
        lo_style   = create_style_subtotal( i_alignment = i_alignment
                                            i_inttype   = i_inttype
                                            i_decimals  = i_decimals   ).
      WHEN c_type_tot. ""Totals
        lo_style   = create_style_total( i_alignment = i_alignment
                                         i_inttype   = i_inttype
                                         i_decimals  = i_decimals   ).
    ENDCASE.
    IF lo_style IS NOT INITIAL.
      r_style = lo_style->get_guid( ).
      ls_styles-type       = i_type.
      ls_styles-alignment  = i_alignment.
      ls_styles-inttype    = i_inttype.
      ls_styles-decimals   = i_decimals.
      ls_styles-guid       = r_style.
      ls_styles-style      = lo_style.
      INSERT ls_styles INTO TABLE wt_styles.
    ENDIF.
  ENDIF.
  endmethod.


method INIT_OPTION.

  ws_option-filter = abap_true.
  ws_option-hidenc = abap_true.
  ws_option-subtot = abap_true.

  endmethod.


method LOOP_NORMAL.
  DATA: l_row_int_end     TYPE zexcel_cell_row,
        l_row_int         TYPE zexcel_cell_row,
        l_col_int         TYPE zexcel_cell_column,
        l_col_alpha       TYPE zexcel_cell_column_alpha,
        l_cell_value      TYPE zexcel_cell_value,
        l_s_color         TYPE abap_bool,
        lo_column         TYPE REF TO zcl_excel_column,
        lo_row            TYPE REF TO zcl_excel_row,
        l_formula         TYPE zexcel_cell_formula,
        l_style           TYPE zexcel_cell_style,
        l_cells           TYPE i,
        l_count           TYPE i,
        l_table_row       TYPE i.

  FIELD-SYMBOLS: <fs_stab>        TYPE ANY,
                 <fs_tab>         TYPE STANDARD TABLE,
                 <fs_sfcat>       TYPE zexcel_s_converter_fcat,
                 <fs_fldval>      TYPE ANY.

  ASSIGN wo_data->* TO <fs_tab> .

  DESCRIBE TABLE wt_fieldcatalog LINES l_cells.
  DESCRIBE TABLE <fs_tab> LINES l_count.
  l_cells = l_cells * l_count.

* It is better to loop column by column
  LOOP AT wt_fieldcatalog ASSIGNING <fs_sfcat>.
    l_row_int = i_row_int.
    l_col_int = i_col_int + <fs_sfcat>-position - 1.

*   Freeze panes
    IF <fs_sfcat>-fix_column = abap_true.
      ADD 1 TO r_freeze_col.
    ENDIF.
    l_s_color = abap_true.

    l_col_alpha = zcl_excel_common=>convert_column2alpha( l_col_int ).

*   Only if the Header is required create it.
    IF ws_option-hidehd IS INITIAL.
      "" First of all write column header
      l_cell_value = <fs_sfcat>-scrtext_m.
      wo_worksheet->set_cell( ip_column    = l_col_alpha
                              ip_row       = l_row_int
                              ip_value     = l_cell_value
                              ip_style     = <fs_sfcat>-style_hdr ).
      ADD 1 TO l_row_int.
    ENDIF.
    LOOP AT <fs_tab> ASSIGNING <fs_stab>.
      l_table_row = sy-tabix.
* Now the cell values
      ASSIGN COMPONENT <fs_sfcat>-columnname OF STRUCTURE <fs_stab> TO <fs_fldval>.
* Now let's write the cell values
      IF ws_layout-is_stripped = abap_true AND l_s_color = abap_true.
        l_style = get_color_style( i_row       = l_table_row
                                   i_fieldname = <fs_sfcat>-columnname
                                   i_style     = <fs_sfcat>-style_stripped  ).
        wo_worksheet->set_cell( ip_column    = l_col_alpha
                                ip_row       = l_row_int
                                ip_value     = <fs_fldval>
                                ip_style     = l_style ).
        CLEAR l_s_color.
      ELSE.
        l_style = get_color_style( i_row       = l_table_row
                                   i_fieldname = <fs_sfcat>-columnname
                                   i_style     = <fs_sfcat>-style_normal  ).
        wo_worksheet->set_cell( ip_column    = l_col_alpha
                                ip_row       = l_row_int
                                ip_value     = <fs_fldval>
                                ip_style     = l_style  ).
        l_s_color = abap_true.
      ENDIF.
      READ TABLE wt_filter TRANSPORTING NO FIELDS WITH TABLE KEY rownumber  = l_table_row
                                                                 columnname = <fs_sfcat>-columnname.
      IF sy-subrc = 0.
        wo_worksheet->get_cell( EXPORTING
                                   ip_column    = l_col_alpha
                                   ip_row       = l_row_int
                                IMPORTING
                                   ep_value     = l_cell_value ).
        wo_autofilter->set_value( i_column = l_col_int
                                  i_value  = l_cell_value ).
      ENDIF.
      ADD 1 TO l_row_int.
    ENDLOOP.
* Now let's check for optimized
    IF <fs_sfcat>-is_optimized = abap_true .
      lo_column = wo_worksheet->get_column( ip_column = l_col_alpha ).
      lo_column->set_auto_size( ip_auto_size = abap_true ) .
    ENDIF.
* Now let's check for visible
    IF <fs_sfcat>-is_hidden = abap_true.
      lo_column = wo_worksheet->get_column( ip_column = l_col_alpha ).
      lo_column->set_visible( ip_visible = abap_false ) .
    ENDIF.
* Now let's check for total versus subtotal.
    IF <fs_sfcat>-totals_function IS NOT INITIAL.
      l_row_int_end = l_row_int - 1.

      l_formula = create_formular_total( i_row_int         = l_row_int_end
                                         i_column          = l_col_alpha
                                         i_totals_function = <fs_sfcat>-totals_function ).
      wo_worksheet->set_cell( ip_column    = l_col_alpha
                              ip_row       = l_row_int
                              ip_formula   = l_formula
                              ip_style     = <fs_sfcat>-style_total ).
    ENDIF.
  ENDLOOP.
  endmethod.


method LOOP_SUBTOTAL.

  DATA: l_row_int_start   TYPE zexcel_cell_row,
        l_row_int_end     TYPE zexcel_cell_row,
        l_row_int         TYPE zexcel_cell_row,
        l_col_int         TYPE zexcel_cell_column,
        l_col_alpha       TYPE zexcel_cell_column_alpha,
        l_col_alpha_start TYPE zexcel_cell_column_alpha,
        l_cell_value      TYPE zexcel_cell_value,
        l_s_color         TYPE abap_bool,
        lo_column         TYPE REF TO zcl_excel_column,
        lo_row            TYPE REF TO zcl_excel_row,
        l_formula         TYPE zexcel_cell_formula,
        l_style           TYPE zexcel_cell_style,
        l_text            TYPE string,
        ls_sort_values    TYPE ts_sort_values,
        ls_subtotal_rows  TYPE ts_subtotal_rows,
        l_sort_level      TYPE int4,
        l_hidden          TYPE int4,
        l_line            TYPE i,
        l_cells           TYPE i,
        l_count           TYPE i,
        l_table_row       TYPE i,
        lt_fcat           TYPE zexcel_t_converter_fcat.

  FIELD-SYMBOLS: <fs_stab>        TYPE ANY,
                 <fs_tab>         TYPE STANDARD TABLE,
                 <fs_sfcat>       TYPE zexcel_s_converter_fcat,
                 <fs_fldval>      TYPE ANY,
                 <fs_sortval>     TYPE ANY,
                 <fs_sortv>       TYPE ts_sort_values.

  ASSIGN wo_data->* TO <fs_tab> .

  REFRESH: wt_sort_values,
           wt_subtotal_rows.

  DESCRIBE TABLE wt_fieldcatalog LINES l_cells.
  DESCRIBE TABLE <fs_tab> LINES l_count.
  l_cells = l_cells * l_count.

  READ TABLE <fs_tab> ASSIGNING <fs_stab> INDEX 1.
  IF sy-subrc = 0.
    l_row_int = i_row_int + 1.
    lt_fcat =  wt_fieldcatalog.
    SORT lt_fcat BY sort_level DESCENDING.
    LOOP AT lt_fcat ASSIGNING <fs_sfcat> WHERE is_subtotalled = abap_true.
      ASSIGN COMPONENT <fs_sfcat>-columnname OF STRUCTURE <fs_stab> TO <fs_fldval>.
      ls_sort_values-fieldname    = <fs_sfcat>-columnname.
      ls_sort_values-row_int      = l_row_int.
      ls_sort_values-sort_level   = <fs_sfcat>-sort_level.
      ls_sort_values-is_collapsed = <fs_sfcat>-is_collapsed.
      CREATE DATA ls_sort_values-value LIKE <fs_fldval>.
      ASSIGN ls_sort_values-value->* TO <fs_sortval>.
      <fs_sortval> =  <fs_fldval>.
      INSERT ls_sort_values INTO TABLE wt_sort_values.
    ENDLOOP.
  ENDIF.
  l_row_int = i_row_int.
* Let's check if we need to hide a sort level.
  DESCRIBE TABLE wt_sort_values LINES l_line.
  IF  l_line <= 1.
    CLEAR l_hidden.
  ELSE.
    LOOP AT wt_sort_values INTO ls_sort_values WHERE is_collapsed = abap_false.
      IF l_hidden < ls_sort_values-sort_level.
        l_hidden = ls_sort_values-sort_level.
      ENDIF.
    ENDLOOP.
  ENDIF.
  ADD 1 TO l_hidden. "" As this is the first level we show.
* First loop without formular only addtional rows with subtotal text.
  LOOP AT <fs_tab> ASSIGNING <fs_stab>.
    ADD 1 TO l_row_int.  "" 1 is for header row.
    l_row_int_start = l_row_int.
    SORT lt_fcat BY sort_level DESCENDING.
    LOOP AT lt_fcat ASSIGNING <fs_sfcat> WHERE is_subtotalled = abap_true.
      l_col_int   = i_col_int + <fs_sfcat>-position - 1.
      l_col_alpha = zcl_excel_common=>convert_column2alpha( l_col_int ).
* Now the cell values
      ASSIGN COMPONENT <fs_sfcat>-columnname OF STRUCTURE <fs_stab> TO <fs_fldval>.
      IF sy-subrc = 0.
        READ TABLE wt_sort_values ASSIGNING <fs_sortv> WITH TABLE KEY fieldname = <fs_sfcat>-columnname.
        IF sy-subrc = 0.
          ASSIGN <fs_sortv>-value->* TO <fs_sortval>.
          IF <fs_sortval> <> <fs_fldval> OR <fs_sortv>-new = abap_true.
* First let's remmember the subtotal values as it has to appear later.
            ls_subtotal_rows-row_int       = l_row_int.
            ls_subtotal_rows-row_int_start = <fs_sortv>-row_int.
            ls_subtotal_rows-columnname    = <fs_sfcat>-columnname.
            INSERT ls_subtotal_rows INTO TABLE wt_subtotal_rows.
* Now let's write the subtotal line
            l_cell_value = create_text_subtotal( i_value = <fs_sortval>
                                   i_totals_function     = <fs_sfcat>-totals_function ).
            wo_worksheet->set_cell( ip_column    = l_col_alpha
                                    ip_row       = l_row_int
                                    ip_value     = l_cell_value
                                    ip_abap_type = cl_abap_typedescr=>typekind_string
                                    ip_style     = <fs_sfcat>-style_subtotal  ).
            lo_row = wo_worksheet->get_row( ip_row = l_row_int ).
            lo_row->set_outline_level( ip_outline_level = <fs_sfcat>-sort_level ) .
            IF <fs_sfcat>-is_collapsed = abap_true.
              IF <fs_sfcat>-sort_level >  l_hidden.
                lo_row->set_visible( ip_visible =  abap_false ) .
              ENDIF.
              lo_row->set_collapsed( ip_collapsed =  <fs_sfcat>-is_collapsed ) .
            ENDIF.
* Now let's change the key
            ADD 1 TO l_row_int.
            <fs_sortval> =  <fs_fldval>.
            <fs_sortv>-new = abap_false.
            l_line = <fs_sortv>-sort_level.
            LOOP AT wt_sort_values ASSIGNING <fs_sortv> WHERE sort_level >= l_line.
              <fs_sortv>-row_int = l_row_int.
            ENDLOOP.
          ENDIF.
        ENDIF.
      ENDIF.
    ENDLOOP.
  ENDLOOP.
  ADD 1 TO l_row_int.
  l_row_int_start = l_row_int.
  SORT lt_fcat BY sort_level DESCENDING.
  LOOP AT lt_fcat ASSIGNING <fs_sfcat> WHERE is_subtotalled = abap_true.
    l_col_int   = i_col_int + <fs_sfcat>-position - 1.
    l_col_alpha = zcl_excel_common=>convert_column2alpha( l_col_int ).
    READ TABLE wt_sort_values ASSIGNING <fs_sortv> WITH TABLE KEY fieldname = <fs_sfcat>-columnname.
    IF sy-subrc = 0.
      ASSIGN <fs_sortv>-value->* TO <fs_sortval>.
      ls_subtotal_rows-row_int       = l_row_int.
      ls_subtotal_rows-row_int_start = <fs_sortv>-row_int.
      ls_subtotal_rows-columnname    = <fs_sfcat>-columnname.
      INSERT ls_subtotal_rows INTO TABLE wt_subtotal_rows.
* First let's write the value as it has to appear.
      l_cell_value = create_text_subtotal( i_value = <fs_sortval>
                             i_totals_function     = <fs_sfcat>-totals_function ).
      wo_worksheet->set_cell( ip_column    = l_col_alpha
                              ip_row       = l_row_int
                              ip_value     = l_cell_value
                              ip_abap_type = cl_abap_typedescr=>typekind_string
                              ip_style     = <fs_sfcat>-style_subtotal ).

      l_sort_level = <fs_sfcat>-sort_level.
      lo_row = wo_worksheet->get_row( ip_row = l_row_int ).
      lo_row->set_outline_level( ip_outline_level = l_sort_level ) .
      IF <fs_sfcat>-is_collapsed = abap_true.
        IF <fs_sfcat>-sort_level >  l_hidden.
          lo_row->set_visible( ip_visible =  abap_false ) .
        ENDIF.
        lo_row->set_collapsed( ip_collapsed =  <fs_sfcat>-is_collapsed ) .
      ENDIF.
      ADD 1 TO l_row_int.
    ENDIF.
  ENDLOOP.
* Let's write the Grand total
  l_sort_level = 0.
  lo_row = wo_worksheet->get_row( ip_row = l_row_int ).
  lo_row->set_outline_level( ip_outline_level = l_sort_level ) .
*  lo_row_dim->set_collapsed( ip_collapsed =  <fs_sfcat>-is_collapsed ) . Not on grand total

  l_text    = create_text_subtotal( i_value = 'Grand'(002)
                                    i_totals_function     = <fs_sfcat>-totals_function ).

  l_col_alpha_start = zcl_excel_common=>convert_column2alpha( i_col_int ).
  wo_worksheet->set_cell( ip_column    = l_col_alpha_start
                          ip_row       = l_row_int
                          ip_value     = l_text
                          ip_abap_type = cl_abap_typedescr=>typekind_string
                          ip_style     = <fs_sfcat>-style_subtotal ).

* It is better to loop column by column second time around
* Second loop with formular and data.
  LOOP AT wt_fieldcatalog ASSIGNING <fs_sfcat>.
    l_row_int = i_row_int.
    l_col_int = i_col_int + <fs_sfcat>-position - 1.
* Freeze panes
    IF <fs_sfcat>-fix_column = abap_true.
      ADD 1 TO r_freeze_col.
    ENDIF.
    l_s_color = abap_true.
    l_col_alpha = zcl_excel_common=>convert_column2alpha( l_col_int ).
    "" First of all write column header
    l_cell_value = <fs_sfcat>-scrtext_m.
    wo_worksheet->set_cell( ip_column    = l_col_alpha
                            ip_row       = l_row_int
                            ip_value     = l_cell_value
                            ip_abap_type = cl_abap_typedescr=>typekind_string
                            ip_style     = <fs_sfcat>-style_hdr ).
    ADD 1 TO l_row_int.
    LOOP AT <fs_tab> ASSIGNING <fs_stab>.
      l_table_row = sy-tabix.
* Now the cell values
      ASSIGN COMPONENT <fs_sfcat>-columnname OF STRUCTURE <fs_stab> TO <fs_fldval>.
* Let's check for subtotal lines
      DO.
        READ TABLE wt_subtotal_rows TRANSPORTING NO FIELDS WITH TABLE KEY row_int = l_row_int.
        IF sy-subrc = 0.
          IF <fs_sfcat>-is_subtotalled = abap_false AND
             <fs_sfcat>-totals_function IS NOT INITIAL.
            DO.
              READ TABLE wt_subtotal_rows INTO ls_subtotal_rows WITH TABLE KEY row_int    = l_row_int.
              IF sy-subrc = 0.
                l_row_int_start = ls_subtotal_rows-row_int_start.
                l_row_int_end   = l_row_int - 1.

                l_formula = create_formular_subtotal( i_row_int_start   = l_row_int_start
                                                      i_row_int_end     = l_row_int_end
                                                      i_column          = l_col_alpha
                                                      i_totals_function = <fs_sfcat>-totals_function ).
                wo_worksheet->set_cell( ip_column    = l_col_alpha
                                        ip_row       = l_row_int
                                        ip_formula   = l_formula
                                        ip_style     = <fs_sfcat>-style_subtotal ).
                IF <fs_sfcat>-is_collapsed = abap_true.
                  lo_row = wo_worksheet->get_row( ip_row = l_row_int ).
                  lo_row->set_collapsed( ip_collapsed =  <fs_sfcat>-is_collapsed ).
                  IF <fs_sfcat>-sort_level >  l_hidden.
                    lo_row->set_visible( ip_visible =  abap_false ) .
                  ENDIF.
                ENDIF.
                ADD 1 TO l_row_int.
              ELSE.
                EXIT.
              ENDIF.
            ENDDO.
          ELSE.
            ADD 1 TO l_row_int.
          ENDIF.
        ELSE.
          EXIT.
        ENDIF.
      ENDDO.
* Let's set the row dimension values
      lo_row = wo_worksheet->get_row( ip_row = l_row_int ).
      lo_row->set_outline_level( ip_outline_level = ws_layout-max_subtotal_level ) .
      IF <fs_sfcat>-is_collapsed  = abap_true.
        lo_row->set_visible( ip_visible =  abap_false ) .
        lo_row->set_collapsed( ip_collapsed =  <fs_sfcat>-is_collapsed ) .
      ENDIF.
* Now let's write the cell values
      IF ws_layout-is_stripped = abap_true AND l_s_color = abap_true.
        l_style = get_color_style( i_row       = l_table_row
                                   i_fieldname = <fs_sfcat>-columnname
                                   i_style     = <fs_sfcat>-style_stripped  ).
        wo_worksheet->set_cell( ip_column    = l_col_alpha
                                ip_row       = l_row_int
                                ip_value     = <fs_fldval>
                                ip_style     = l_style ).
        CLEAR l_s_color.
      ELSE.
        l_style = get_color_style( i_row       = l_table_row
                                   i_fieldname = <fs_sfcat>-columnname
                                   i_style     = <fs_sfcat>-style_normal  ).
        wo_worksheet->set_cell( ip_column    = l_col_alpha
                                ip_row       = l_row_int
                                ip_value     = <fs_fldval>
                                ip_style     = l_style   ).
        l_s_color = abap_true.
      ENDIF.
      READ TABLE wt_filter TRANSPORTING NO FIELDS WITH TABLE KEY rownumber  = l_table_row
                                                                 columnname = <fs_sfcat>-columnname.
      IF sy-subrc = 0.
        wo_worksheet->get_cell( EXPORTING
                                   ip_column    = l_col_alpha
                                   ip_row       = l_row_int
                                IMPORTING
                                   ep_value     = l_cell_value ).
        wo_autofilter->set_value( i_column = l_col_int
                                  i_value  = l_cell_value ).
      ENDIF.
      ADD 1 TO l_row_int.
    ENDLOOP.
* Let's check for subtotal lines
    DO.
      READ TABLE wt_subtotal_rows TRANSPORTING NO FIELDS WITH TABLE KEY row_int = l_row_int.
      IF sy-subrc = 0.
        IF <fs_sfcat>-is_subtotalled = abap_false AND
           <fs_sfcat>-totals_function IS NOT INITIAL.
          DO.
            READ TABLE wt_subtotal_rows INTO ls_subtotal_rows WITH TABLE KEY row_int    = l_row_int.
            IF sy-subrc = 0.
              l_row_int_start = ls_subtotal_rows-row_int_start.
              l_row_int_end   = l_row_int - 1.

              l_formula = create_formular_subtotal( i_row_int_start   = l_row_int_start
                                                    i_row_int_end     = l_row_int_end
                                                    i_column          = l_col_alpha
                                                    i_totals_function = <fs_sfcat>-totals_function ).
              wo_worksheet->set_cell( ip_column    = l_col_alpha
                                      ip_row       = l_row_int
                                      ip_formula   = l_formula
                                      ip_style     = <fs_sfcat>-style_subtotal ).
              IF <fs_sfcat>-is_collapsed = abap_true.
                lo_row = wo_worksheet->get_row( ip_row = l_row_int ).
                lo_row->set_collapsed( ip_collapsed =  <fs_sfcat>-is_collapsed ).
              ENDIF.
              ADD 1 TO l_row_int.
            ELSE.
              EXIT.
            ENDIF.
          ENDDO.
        ELSE.
          ADD 1 TO l_row_int.
        ENDIF.
      ELSE.
        EXIT.
      ENDIF.
    ENDDO.
* Now let's check for Grand total
    IF <fs_sfcat>-is_subtotalled = abap_false AND
       <fs_sfcat>-totals_function IS NOT INITIAL.
      l_row_int_start = i_row_int + 1.
      l_row_int_end   = l_row_int - 1.

      l_formula = create_formular_subtotal( i_row_int_start   = l_row_int_start
                                            i_row_int_end     = l_row_int_end
                                            i_column          = l_col_alpha
                                            i_totals_function = <fs_sfcat>-totals_function ).
      wo_worksheet->set_cell( ip_column    = l_col_alpha
                              ip_row       = l_row_int
                              ip_formula   = l_formula
                              ip_style     = <fs_sfcat>-style_subtotal ).
    ENDIF.
* Now let's check for optimized
    IF <fs_sfcat>-is_optimized = abap_true.
      lo_column = wo_worksheet->get_column( ip_column = l_col_alpha ).
      lo_column->set_auto_size( ip_auto_size = abap_true ) .
    ENDIF.
* Now let's check for visible
    IF <fs_sfcat>-is_hidden = abap_true.
      lo_column = wo_worksheet->get_column( ip_column = l_col_alpha ).
      lo_column->set_visible( ip_visible = abap_false ) .
    ENDIF.
  ENDLOOP.

  endmethod.


method OPEN_FILE.
  data: l_bytecount             type i,
        lt_file                 type solix_tab,
        l_dir                   type string.

  field-symbols: <fs_data> type any table.

  assign wo_data->* to <fs_data>.

* catch zcx_excel .
*endtry.
  if wo_excel is bound.
    get_file( importing e_bytecount  = l_bytecount
                        et_file      = lt_file ) .

    l_dir =  create_path( ) .

    cl_gui_frontend_services=>gui_download( exporting bin_filesize = l_bytecount
                                                      filename     = l_dir
                                                      filetype     = 'BIN'
                                             changing data_tab     = lt_file ).
    cl_gui_frontend_services=>execute(
      exporting
        document               = l_dir
*        application            =
*        parameter              =
*        default_directory      =
*        maximized              =
*        minimized              =
*        synchronous            =
*        operation              = 'OPEN'
      exceptions
        cntl_error             = 1
        error_no_gui           = 2
        bad_parameter          = 3
        file_not_found         = 4
        path_not_found         = 5
        file_extension_unknown = 6
        error_execute_failed   = 7
        synchronous_failed     = 8
        not_supported_by_gui   = 9
           ).
    if sy-subrc <> 0.
      message id sy-msgid type sy-msgty number sy-msgno
                 with sy-msgv1 sy-msgv2 sy-msgv3 sy-msgv4.
    endif.

  endif.


  endmethod.


method SET_AUTOFILTER_AREA.
  DATA: ls_area TYPE zexcel_s_autofilter_area,
        l_lines TYPE i,
        lt_values TYPE zexcel_t_autofilter_values,
        ls_values TYPE zexcel_s_autofilter_values.

* Let's check for filter.
  IF wo_autofilter IS BOUND.
    ls_area-row_start = 1.
    lt_values = wo_autofilter->get_values( ) .
    SORT lt_values BY column ASCENDING.
    DESCRIBE TABLE lt_values LINES l_lines.
    READ TABLE lt_values INTO ls_values INDEX 1.
    IF sy-subrc = 0.
      ls_area-col_start = ls_values-column.
    ENDIF.
    READ TABLE lt_values INTO ls_values INDEX l_lines.
    IF sy-subrc = 0.
      ls_area-col_end = ls_values-column.
    ENDIF.
    wo_autofilter->set_filter_area( is_area = ls_area ) .
  ENDIF.

  endmethod.


method SET_CELL_FORMAT.
  DATA:  l_format    TYPE zexcel_number_format.

  CLEAR r_format.
  CASE i_inttype.
    WHEN cl_abap_typedescr=>typekind_date.
      r_format = wo_worksheet->get_default_excel_date_format( ).
    WHEN cl_abap_typedescr=>typekind_time.
      r_format = wo_worksheet->get_default_excel_time_format( ).
    WHEN cl_abap_typedescr=>typekind_float OR cl_abap_typedescr=>typekind_packed.
      IF i_decimals > 0 .
        l_format = '#,##0.'.
        DO i_decimals TIMES.
          CONCATENATE l_format '0' INTO l_format.
        ENDDO.
        r_format = l_format.
      ENDIF.
    WHEN cl_abap_typedescr=>typekind_int OR cl_abap_typedescr=>typekind_int1 OR cl_abap_typedescr=>typekind_int2.
      r_format = '#,##0'.
  ENDCASE.

  endmethod.


method SET_FIELDCATALOG.

  DATA: lr_data             TYPE REF TO data,
        lo_structdescr      TYPE REF TO cl_abap_structdescr,
        lt_dfies            TYPE ddfields,
        ls_dfies            TYPE dfies.
  DATA: ls_fcat             TYPE zexcel_s_converter_fcat.

  FIELD-SYMBOLS: <fs_tab>         TYPE ANY TABLE.

  ASSIGN wo_data->* TO <fs_tab> .

  CREATE DATA lr_data LIKE LINE OF <fs_tab>.

  lo_structdescr ?= cl_abap_structdescr=>describe_by_data_ref( lr_data ).

  lt_dfies = zcl_excel_common=>describe_structure( io_struct = lo_structdescr ).

  LOOP AT lt_dfies INTO ls_dfies.
    MOVE-CORRESPONDING ls_dfies TO ls_fcat.
    ls_fcat-columnname = ls_dfies-fieldname.
    INSERT ls_fcat INTO TABLE wt_fieldcatalog.
  ENDLOOP.

  clean_fieldcatalog( ).

  endmethod.


method SET_OPTION.

  IF ws_indx-begdt IS INITIAL.
    ws_indx-begdt = sy-datum.
  ENDIF.

  ws_indx-aedat = sy-datum.
  ws_indx-usera = sy-uname.
  ws_indx-pgmid = sy-cprog.

  EXPORT p1 = is_option TO DATABASE indx(xl) FROM ws_indx ID ws_indx-srtfd.

  IF sy-subrc = 0.
    ws_option = is_option.
  ENDIF.

  endmethod.


method WRITE_FILE.
  data: l_bytecount             type i,
      lt_file                 type solix_tab,
      l_dir                   type string.

  field-symbols: <fs_data> type any table.

  assign wo_data->* to <fs_data>.

* catch zcx_excel .
*endtry.
  if wo_excel is bound.
    get_file( importing e_bytecount  = l_bytecount
                        et_file      = lt_file ) .
    if i_path is initial.
      l_dir =  create_path( ) .
    else.
      l_dir = i_path.
    endif.
    cl_gui_frontend_services=>gui_download( exporting bin_filesize = l_bytecount
                                                      filename     = l_dir
                                                      filetype     = 'BIN'
                                             changing data_tab     = lt_file ).
  endif.
  endmethod.
ENDCLASS.
",15407,True,3074.749211673071,median
"= iGrad - User Guide
:site-section: UserGuide
:toc:
:toc-title:
:toc-placement: preamble
:toclevels: 3
:sectnums:
:imagesDir: images
:stylesDir: stylesheets
:xrefstyle: full
:experimental:
ifdef::env-github[]
:tip-caption: :bulb:
:note-caption: :information_source:
:important-caption: :heavy_exclamation_mark:
:caution-caption: :fire:
:warning-caption: :warning:
:icons: :font:
endif::[]
:repoURL: https://github.com/AY1920S2-CS2103T-F09-3/main

By: `Team-iGrad`      Since: `Feb 2020`

== Introduction

Welcome! Thanks for choosing to use iGrad. This official iGrad User Guide will help guide you as you explore the ways you can
track your graduation!

== Quick Start

*Follow the steps below to get started with iGrad:*

1. Ensure that you have Java 11 installed on your computer. Java 11 is bundled together with the Java Development Kit and can be found link:https://www.oracle.com/java/technologies/javase-jdk11-downloads.html[here]

2. Download our latest link:https://github.com/AY1920S2-CS2103T-F09-3/main/releases[release]!

3. Copy or move the downloaded file into an *empty* folder.
+
IMPORTANT: Ensure that the folder is empty! Doing otherwise might result in unexpected errors.

4. Simply double-click on the file to begin! We hope we make tracking your graduation a breeze!


== How to use this guide

You may proceed to <<Command List>> if you would like to learn how to use each of the commands, and <<Cheat Sheet>>
if you would just like a list of all the commands for easy reference.

The figure below explains the symbols used throughout the user guide.

WARNING: Specifies the constraints of the command or situation.

NOTE: Specifies expected command outcomes.

TIP: Specifies extra tips you can use when navigating through our app.

IMPORTANT: Specifies important things to take note of

// tag::nat-ug[]
== Features

Section by: https://github.com/nathanaelseen[Nathanael Seen]

This segment highlights three key features iGrad offers to NUS students, namely;
a Course Planner, an MCs Tracker, and a CAP Tracker.

If you would like a more in-depth overview of the actual components of our application, please
refer to the next section; <<Components>>, for more details.

==== Course Planner
_iGrad_ was built with every NUS student in mind. Our flexible course planner allows you to plan
a course of your own dreams, be it those of you doing a single degree programme,
a double degree programme, and even a concurrent degree programme.

With our course planner, you would be able to enter your current course details such as your
*modules* and the various degree *requirements* by which those modules are mapped.

(For instance, the _Computer Science_ course has the various
*modules*, highlighted in [blue]#blue#, and degree *requirements*, boxed in [red]#red#):

anchor:figure-a-anchor[]

.Computer science degree requirements
image::../images/user-guide/components/graduation_degree_requirements.png[]

==== MCs Tracker

We are sick of counting our MCs at the beginning of every semester; be it counting the
total course MCs left before you can graduate, or tracking the number of MCs left
for those invidual degree requirements (boxed in [green]#green#,
in xref:figure-a-anchor[_Figure 1_]).

With our MCs feature, you would be able to easily keep track of how close you are to
graduation, as all this information is automatically updated and recomputed, each time you have
completed a certain module.

==== CAP Tracker
No more googling for CAP calculators. iGrad's CAP tracker helps you keeps track of your current CAP at
every step of your journey in your course. In addition, it even offers predictive features so you know how
well you have to do in order to achieve your dream CAP.

==== Everything Integrated into One Application
But the best part is that these features are all integrated into our application; _iGrad_.
And with all these important pieces of information in one place, you would never go amiss keeping
track of all your graduation requirements.

== Components
This segment details the various components of _iGrad_. As shown in _Figure 2_ below,
these components follow a hierachical structure, exactly like how an NUS course is structured.

anchor:figure-b-anchor[]

.Hierachical overview of iGrad components
image::../images/user-guide/components/hierachical_structure.png[]

Here is how our application looks like (on a typical usage):

.iGrad application screenshot
image::../images/user-guide/components/app_screenshot_ui.png[]

The following is the same screenshot of our application, but with the various components
of our application highlighted:

.iGrad components screenshot
image::../images/user-guide/components/app_screenshot_ui_components_highlighted.png[]

As per the screenshot above (in _figure 4_):

* xref:Course[Course] is indicated in [blue]#blue#,
* xref:Degree Requirements[Degree Requirements] is indicated in [red]#red#, and
* xref:Modules[Modules] is indicated in [yellow]#yellow#

You may refer to xref:figure-b-anchor[_Figure 2_], if you would like a quick recap on the
hierarchical structuring of these components.

==== Course

A course is simply a group of degree requirements.

It contains important information such as your current CAP, total number of MCs
you have completed thus far, and semesters left before you can graduate.

In short, it helps you keep track of your overall degree progress.

==== Degree Requirements

Under a course are the various degree requirements, such as the ones shown in
xref:figure-b-anchor[_Figure 2_] above; _Computer Science Foundation_,
_Mathematics and Sciences_, and _Unrestricted Electives_.

Each requirement comprises of the modules you need to complete in order to fulfill that particular
requirement.

Additionally, each requirement consists of important information such as
the number of MCs you have already fulfilled.

==== Modules

Finally, modules are the basic building block of all the other components.

These could be modules you have taken, modules you are currently taking and modules that
you plan to take.

Each module allows recording of other optional information, such as indicating the grade you
have obtained for those modules.

//end::nat-ug[]

//tag::walkthrough[]
== Walkthrough

Section by: https://github.com/dargohzy[Daryl] & https://github.com/teriaiw[Teri]

This segment details a simple tutorial on how to use the application. It provides a step-by-step guide on how to
utilise the main components of the application, and covers the following:

* Choosing an `Avatar`
* Adding a `Course`
* Adding a course `Requirement`
* Adding a `Module`
* Assigning a `Module` to a `Requirement`
* Adding additional details to a `Module`
* Marking as `Module` as done and assigning a `Grade` to it
* Tracking your academic progress: `MCs` and `CAP`
* Exporting your data

Here is a 10-step guide on how to use `iGrad`.

=== Start up the application

Section by: https://github.com/dargohzy[Daryl]

- Open up the application by opening the `iGrad.jar` file.
- Select an avatar by typing its name before pressing enter.
- The avatar will act as your guide for the application.
+
image::../images/user-guide/walkthrough1.png[]

=== Enter your course details

Section by: https://github.com/dargohzy[Daryl]

- Course refers to the name of the course you are currently enrolled in.
- Enter the name of your course in the format: `course add n/COURSE_NAME s/TOTAL_SEMESTERS`
- E.g. `course add n/Computer Science s/2`
+
image::../images/user-guide/walkthrough2.1.png[]
+
image::../images/user-guide/walkthrough2.2.png[]

=== Key in your graduation requirements

Section by: https://github.com/dargohzy[Daryl]

- Requirements refer to degree requirements needed in the entered course.
- Enter your course graduation requirements in the format: `requirement add t/REQUIREMENT_TITLE u/MCS_REQUIRED`
- E.g. `requirement add n/General Education u/20`
+
image::../images/user-guide/walkthrough3.1.png[]
+
image::../images/user-guide/walkthrough3.2.png[]

=== Add modules to the tracker

Section by: https://github.com/dargohzy[Daryl]

- Modules refer to modules that you have taken or are planning to take.
- Enter modules into the system in the format: `module add n/MODULE_CODE t/MODULE_TITLE u/MCs`
- E.g. `module add n/GER1000 t/Quantitative Reasoning u/4`
+
image::../images/user-guide/walkthrough4.1.png[]
+
image::../images/user-guide/walkthrough4.2.png[]

=== Assign your modules

Section by: https://github.com/dargohzy[Daryl]

- Assign modules under their respective requirements.
- Enter assign in the format: `requirement assign REQUIREMENT_CODE n/MODULE_CODE`
- Note: Requirement codes are generated by the system.
- E.g. `requirement assign GE0 n/GER1000`
+
image::../images/user-guide/walkthrough5.1.png[]
+
image::../images/user-guide/walkthrough5.2.png[]

=== Key in additional details for your modules

Section by: https://github.com/teriaiw[Teri]

- Edit modules with additional information such as Semester. Other information that has already be input can be
  edited as well.
- Enter edit to be done to the module in the format: `module edit MODULE_CODE s/SEMESTER`
- Note: For Semester, it has to follow the format of `Y_S_`
- E.g. `module edit GER1000 s/Y1S1`
+
image::../images/user-guide/walkthrough6.1.png[]
+
image::../images/user-guide/walkthrough6.2.png[]

=== Mark a module as done and assign a grade to it

Section by: https://github.com/teriaiw[Teri]

- A module is considered as done when a grade is assigned to it.
- Enter grade for the module in the format: `module done MODULE_CODE g/GRADE`
- E.g. `module done GER1000 g/A+`
+
image::../images/user-guide/walkthrough7.1.png[]
+
image::../images/user-guide/walkthrough7.2.png[]

=== Track your MCs

Section by: https://github.com/teriaiw[Teri]

- MCs refer to Module Credits.
- MCs are automatically tracked and updated.
- Total MCs count is the total of all requirement MCs.
- MCs are fulfilled when modules that are within a requirement are marked done.
+
image::../images/user-guide/walkthrough8.png[]

=== View your CAP

Section by: https://github.com/teriaiw[Teri]

- CAP refers to Cumulative Average Points and is out of 5 (max).
- CAP is automatically tracked and updated.
- CAP is updated whenever a module within a requirement is marked done with a grade.
+
image::../images/user-guide/walkthrough9.png[]


=== Export your data

Section by: https://github.com/teriaiw[Teri]

- Data of your entire study plan can to exported to a comma-separated values (.csv) file.
- Export your data in the format: `export`
- Note: Data file can be found in the same folder as this application.
+
image::../images/user-guide/walkthrough10.1.png[]
+
image::../images/user-guide/walkthrough10.2.png[]
+
image::../images/user-guide/walkthrough10.3.png[]
//end::walkthrough[]

== Command List
Section by: https://github.com/yjskrs[Yijie]

This section provides a detailed breakdown of the various commands you may use in iGrad.
Please read <<Command Format>> to understand how our commands work!

//tag::command-yijie[]
=== Command Format
Section by: https://github.com/yjskrs[Yijie]

This section explains the syntax for the commands in iGrad. You may move onto xref:helpSection[] if you are already
familiar with our syntax which involves the command word(s), prefixes, parameters, specifiers and flags.

The table below summarises the components of our syntax, using `module` commands as example.

[#tableCommandFormatComponents]
.Command Format Components
|===
|Component |Description |Example

|Command Word(s) |Command words tell iGrad what command you are trying to perform. |E.g. `module add`.
|Prefix |Prefixes tell iGrad what kind of information you are trying to key in.
A prefix consists of an alphabet followed by a forward slash (i.e. `/`).
|E.g. `t/` is the prefix for `TITLE`.
|Parameter |Parameters tell iGrad the information you want to key in. Parameters are specified in *uppercase*.
Parameters come directly after a prefix, and you can chain prefix-parameters pairs.
|E.g. In `t/TITLE`, `TITLE` is the parameter where you can key in your desired title.
|Specifier |Specifiers inform iGrad of the item you want to edit or delete. To differentiate them from the
properties of the item you are trying to modify, they do not come with prefixes.
|E.g. In the `module edit CS2103T t/Hardware Engineering` command, `CS2103T` is the module we are trying to edit,
and `Hardware Engineering` is what we want to set as the new module title.
|Flag |Flags tell iGrad to use a different version of the command.
Flags consist of a dash (i.e. `-`) followed by an alphabet.
Flags can only be indicated at the end of the command.
|E.g. `module add n/CS2101 -a` adds a module by pulling its data from NUSMods.
|===

We have also listed all the parameters and their corresponding prefixes in the table below.
If square brackets (i.e. `[` `]`) are specified around a parameter-prefix pair, this means
that the parameter-prefix pair is optional. However, do note that if all parameter-prefix pairs
are indicated with square brackets, this means that at least one of them must be provided. Parameter-prefix
pairs which can be entered multiple times in a single command are also indicated by ellipses
(i.e. `...`) behind the parameter.

[#tableParameterPrefixPairs]
.Parameter Prefix Pairs
|===
|Parameter | Prefix

|`NAME` or `CODE`|`n/`
|`TITLE`|`t/`
|`CREDITS`|`u/`
|`SEMESTER`|`s/`
|`GRADE`|`g/`
|`CAP`|`c/`
|===

The two flags used in iGrad are listed in the table below.

[#tableFlags]
.Flags
|===
|Flag | Purpose
|`-a`| Informs iGrad to use automated module adding by pulling data of modules from NUSMods. Only used in the xref:ModuleAutoAddCommand[ModuleAutoAdd] command.
|`-o`| Informs iGrad to use the or option when filtering modules. Only used in the xref:ModuleFilterCommand[ModuleFilter] command.
|===

//end::command-yijie[]

[#helpSection]
=== Help
Section by: https://github.com/yjskrs[Yijie]

This command opens up a help window for easy reference on the list of commands that can be used in iGrad.
A link is also provided to direct users to the user guide for more detailed explanations.

[#tableHelpQuickReference]
.Help Quick Reference
|===
|Purpose | Opens a help window with a list of commands
|Syntax| `help`
|Example | `help`

|===

[#courseSection]
=== Course
Section by: https://github.com/yjskrs[Yijie]

This section details each command used in manipulating the course. All course commands begin with the identifier
`course`, followed by the action, e.g. `set`.

All course commands use the same parameters, as listed in the table below:
[#tableCourseParameters]
.Course Parameters
|===
|Name| Description | Example | Restrictions

|`COURSE_NAME`| The course name | Computer Science |-
|`SEMESTER`| The total number of semesters you will be spending in NUS | 8 |Must be a number less than 100.
|===

If the parameter restrictions are not strictly adhered to when issuing a course command, or if
iGrad cannot find what you're looking for, you might come across a common error.
The following error is generic and may be encountered when dealing with any course command:

[#tableCourseParametersErrorReference]
.Course Parameters Error Reference
|===
|Parameter |Error Name

|`COURSE_CREDITS`| Invalid Course Credits
|===

This error can be resolved by adhering to the restriction detailed in <<tableCourseParameters>>

==== Course Set

This command sets the course.

[#CourseSetQuickReference]
.Course Set Quick Reference
|===
|Purpose | Sets the course
|Syntax| `course set n/COURSE_NAME s/SEMESTERS`
|Example | `course set n/Computer Science s/8`
|===

*How it Works*

When you type in this command, we take the values given for the `COURSE_NAME` and `SEMESTERS`
and fill in those fields for your course. We do not check if the given course refers
to actual courses in NUS. However, restrictions stated in the xref:tableRequirementParameters[Requirement Parameters]
table still apply.

<<CourseSetErrorReference>> lists errors you might encounter after issuing this command:

[#CourseSetErrorReference]
.Course Set Error Reference
|===
|Name | Message| Explanation| Solution

|Parameters Not Provided Error |All fields to be filled, course set n/COURSE_NAME s/SEMESTERS
|Not all parameters needed to set the course have been provided
|Provide all parameters prepended with their prefixes
|===

*Tutorial*

Follow these steps to get a clearer idea of how this command works.
[NOTE]
For this tutorial, actual values will be given instead of placeholders.
You may undo changes made from this tutorial by using the appropriate command.

1. Ensure that you do not have a course yet. You may do so by deleting the existing course
with the `course delete` command.

2. Type the following into the command box:
`course set n/Computer Science s/8`, and press enter.

3. The message in the response box should change and you should see the course name and semesters
updated in the top left corner panel.

==== Course Edit

This command edits the editable fields in a course which include the `COURSE_NAME` and `SEMESTERS`.

IMPORTANT: Course name does not need to be specified.

[#CourseEditQuickReference]
.Course Edit Quick Reference
|===
|Purpose | Edits the course
|Syntax| `course edit [n/COURSE_NAME] [s/SEMESTERS]`
|Example | `course edit n/Engineering s/8`
|===

*How it Works*

When you issue the command, we replace the fields provided with the given values. You are able to
change the values as you wish as long as they follow the restrictions as listed in the parameters table.

<<CourseEditErrorReference>> lists the errors you might encounter after issuing this command:

[#CourseEditErrorReference]
.Course Edit Error Reference
|===
|Name| Message| Explanation |Solution

|Parameters Not Provided Or Not Modified |At least one field to edit must be provided
|Parameters needed to edit the course are not provided
|Try specifying either the name or the credits, or provide a value that is different from the existing one
|===

*Tutorial*

[NOTE]
For this tutorial, actual values will be given instead of placeholders.
You may undo or delete objects created from this tutorial by using the appropriate commands.

1. Ensure that you have a course set.

2. Type the following into the command box:
`course edit n/Computer Science s/8`, and press enter.

3. The message in the response box should change and you should see the course name and semesters
updated in the top left corner panel.

==== Course Delete

This command *deletes the course as well as all other information stored* in iGrad. Please use with caution!

IMPORTANT: Course name does not need to be specified.

[#CourseDeleteQuickReference]
.Course Delete Quick Reference
|===
|Purpose | Deletes the course
|Syntax| `course delete`
|Example | `course delete`
|===

*Tutorial*

[NOTE]
You may undo changes made from this tutorial by using the appropriate command.

1. Ensure that you have a course set.

2. Type the following into the command box:
`course delete`, and press enter.

3. The message in the response box should change and you should see the course name and semesters
disappear, as well as all other information in iGrad.

//tag::requirement-yijie[]
[#requirementSection]
=== Requirement
Section by: https://github.com/yjskrs[Yijie]

This section details each command used in manipulating requirements. All requirement commands begin with the identifier
`requirement`, followed by the action, e.g. `add`.

All requirement commands use the same parameters, as listed in the table below:

[#tableRequirementParameters]
.Requirement Parameters
|===
|Name| Description | Example | Restrictions

|`REQUIREMENT_CODE`| A requirement's unique identifier, automagically generated by iGrad based on the requirement title | CSF0 |-
|`REQUIREMENT_TITLE`| A requirement's title | Computer Science Foundation |Must contain at least one alphabet
|`REQUIREMENT_CREDITS`| The number of http://www.nus.edu.sg/registrar/academic-information-policies/graduate/modular-system[modular credits] needed to fulfill the requirement | 32 | Must be a positive number less than or equal to 10,000
|`MODULE_CODE`| A module's module code, used when assigning or unassigning modules to and from a requirement | CS2103T | Detailed restrictions are specified xref:tableModuleParameters[here], but the requirement-specific restriction is that the module must already be added to iGrad.
|===

If the parameter restrictions are not strictly adhered to when issuing a requirement command, or if
iGrad cannot find what you're looking for, you might come across some common errors.
The following errors are generic and may be encountered when dealing with any requirement command:

[#tableRequirementParametersErrorReference]
.Requirement Parameters Error Reference
|===
|Parameter |Error Name

|`REQUIREMENT_CODE`| Invalid Requirement Code
|`REQUIREMENT_TITLE`| Invalid Requirement Title
|`REQUIREMENT_CREDITS`| Invalid Requirement Credits
|===

These errors can all be resolved by adhering to the restrictions detailed in <<tableRequirementParameters>>

==== Requirement Add

This command adds a requirement to the requirement list.

[#RequirementAddQuickReference]
.Requirement Add Quick Reference
|===
|Purpose | Adds a requirement
|Syntax| `requirement add t/REQUIREMENT_TITLE u/REQUIREMENT_CREDITS`
|Example | `requirement add t/Computer Science Foundation u/32`
|===

*How it Works*

When you type in this command, we take the values given for the `REQUIREMENT_TITLE` and `REQUIREMENT_CREDITS`
and fill in those fields for your requirement. We do not check if the given requirement title or credits refer
to actual requirements as stated on NUS websites. However, restrictions stated in the
xref:tableRequirementParameters[Requirement Parameters] table still apply.

<<RequirementAddErrorReference>> lists errors you might encounter after issuing this command:

[#RequirementAddErrorReference]
.Requirement Add Error Reference
|===
|Name | Message| Explanation| Solution

|Parameters Not Provided Error |Added requirement must be provided with arguments t/TITLE u/CREDITS
|Not all parameters needed to add a requirement are provided |Provide all parameters prepended with their prefixes
|===

*Tutorial*

Follow these steps to get a clearer idea of how this command works.
[NOTE]
For this tutorial, actual values will be given instead of placeholders.
You may undo changes made from this tutorial by using the appropriate command.

1. Type the following into the command box:
`requirement add t/Computer Science Foundation u/32`, and press enter

2. The message in the response box should change and you should see the following in the requirement panel:

+
.Requirement ""Computer Science Foundation"" successfully added
image::../images/user-guide/requirementCommand/requirementAddSuccess.png[]

==== Requirement Edit

This command edits the editable fields in a requirement which include the `REQUIREMENT_TITLE` and `REQUIREMENT_CREDITS`.
The `REQUIREMENT_CODE` is not editable as it is a unique identifier assigned by iGrad.

[#RequirementEditQuickReference]
.Requirement Edit Quick Reference
|===
|Purpose | Edits a requirement
|Syntax| `requirement edit REQUIREMENT_CODE [t/REQUIREMENT_TITLE] [u/REQUIREMENT_CREDITS]`
|Example | `requirement edit CSF0 t/Engineering Foundation u/40`
|===

*How it Works*

IMPORTANT: Please type the requirement code in uppercase.

When you issue the command, we replace the fields provided with the given values. You are able to
change the values as you wish as long as they follow the restrictions as listed in the parameters table.

<<RequirementEditErrorReference>> lists the errors you might encounter after issuing this command:

[#RequirementEditErrorReference]
.Requirement Edit Error Reference
|===
|Name| Message| Explanation |Solution

|Requirement Not Found Error |The requirement code provided is invalid
|The requirement you are attempting to edit does not exist
|Try changing the requirement code to one that you can find in the list, or add a new one instead
|Parameters Not Provided Or Not Modified |At least one field to edit must be provided
|Parameters needed to edit the requirement are not provided
|Try specifying either the title or the credits, or provide a value that is different from the existing one
|===

*Tutorial*

[NOTE]
For this tutorial, actual values will be given instead of placeholders.
You may undo or delete objects created from this tutorial by using the appropriate commands.

1. Ensure that you have the requirement ""Computer Science Foundation"", coded CSF0, in the list.

2. Type the following into the command box: `requirement edit CSF0 t/Engineering Foundation u/40`, and press enter.

3. The message in the response box should change and you should see the following updated in the list:

+
.Requirement ""Computer Science Foundation"" successfully edited
image::../images/user-guide/requirementCommand/requirementEditSuccess.png[]

==== Requirement Delete

This command deletes a requirement from the list.

[#RequirementDeleteQuickReference]
.Requirement Delete Quick Reference
|===
|Purpose | Deletes a requirement
|Syntax| `requirement delete REQUIREMENT_CODE`
|Example | `module delete CSF0`
|===

*How it Works*

The requirement that you wish to delete is completely removed from the list.
[WARNING]
Restoring the requirement is only possible using the `undo` command which would only work if `delete` was the last issued command.

<<RequirementDeleteErrorReference>> lists the errors you might encounter after issuing this command:

[#RequirementDeleteErrorReference]
.Requirement Delete Error Reference
|===
|Name| Message| Explanation |Solution

|Requirement Not Found Error |The requirement code provided is invalid
| The requirement you are attempting to delete does not exist in the list
| Your problem is your solution!
|===

*Tutorial*
[NOTE]
For this tutorial, actual values will be given instead of placeholders.
You may undo objects deleted from this tutorial by using the appropriate command.

1. Ensure that you have the requirement with requirement code ""CSF0"" in the list.

2. Type the following into the command box: `requirement delete CSF0`, and hit enter.

2. The message in the response box should change and you should see that the requirement CSF0
disappears from the list.
//end::requirement-yijie[]

==== Requirement Assign

This command assigns one or more than one module to a requirement.

[#RequirementAssignQuickReference]
.Requirement Assign Quick Reference
|===
|Purpose | Assigns module(s) to a requirement
|Syntax| `requirement assign REQUIREMENT_CODE n/MODULE_CODE ...`
|Example | `requirement assign CSF0 n/CS2103T n/CS2101`
|===

*How it Works*

IMPORTANT: The module must already be added in iGrad for this command to work!
Refer to <<ModuleAddCommand>> to find out how to add a module.

<<RequirementAssignErrorReference>> lists the errors you might encounter after issuing this command:

[#RequirementAssignErrorReference]
.Requirement Assign Error Reference
|===
|Name |Message| Explanation |Solution

|Requirement Not Found Error |The requirement code provided is invalid
|The requirement you are attempting to assign to does not exist
|Try changing the requirement code to one that you can find in the list
|Module Not Found Error |The module does not exit in system
|The module you are attempting to assign does not exist
|You need to first add the module!
|Module Already Assigned Error |The module is already assigned under the requirement
|The module has been assigned to the requirement
|Try assigning a different module instead
|===

*Tutorial*

[NOTE]
For this tutorial, actual values will be given instead of placeholders.
You may undo changes made from this tutorial by using the appropriate command.

1. Ensure that you have the requirement ""Computer Science Foundation"", coded CSF0, in the list.

2. Type the following into the command box: `requirement assign CSF0 n/CS2103T n/CS2101`, and press enter.

3. The message in the response box should change and you should see the following updated in the list:

+
.Modules successfully assigned to requirement ""Computer Science Foundation""
image::../images/user-guide/requirementCommand/requirementAssignSuccess.png[]

==== Requirement Unassign

This command unassigns one or more than one module from a requirement.

[#RequirementUnassignQuickReference]
.Requirement Unassign Quick Reference
|===
|Purpose | Unassign module(s) from a requirement
|Syntax| `requirement unassign REQUIREMENT_CODE n/MODULE_CODE ...`
|Example | `requirement unassign CSF0 n/CS2103T n/CS2101`
|===

*How it Works*

IMPORTANT: The module must already be assigned to the requirement for this command to work!

<<RequirementUnassignErrorReference>> lists the errors you might encounter after issuing this command:

[#RequirementUnassignErrorReference]
.Requirement Unassign Error Reference
|===
|Name |Message| Explanation |Solution

|Requirement Not Found Error |The requirement code provided is invalid
|The requirement you are attempting to unassign from does not exist
|Try changing the requirement code to one that you can find in the list
|Module Not Found Error |The module does not exit in system
|The module you are attempting to unassign does not exist
|You can add the module if you want
|===

*Tutorial*

[NOTE]
For this tutorial, actual values will be given instead of placeholders.
You may undo changes made from this tutorial by using the appropriate command.

1. Ensure that you have the requirement ""Computer Science Foundation"", coded CSF0, in the list, with modules CS2103T and CS2101 assigned to it.

2. Type the following into the command box: `requirement unassign CSF0 n/CS2103T n/CS2101`, and press enter.

3. The message in the response box should change and you should see the modules disappear from the requirement.

// tag::module[]

=== Module
Section by: https://github.com/waynewee[Wayne]

This section details each command used to manipulate modules. All module commands begin with the identifier
`module` followed by the action e.g. `add`.

All module commands use the same parameters, listed in the table below:

[#tableModuleParameters]
.Module Parameters
|===
|Name| Description | Example | Restrictions

|`MODULE_CODE` | A module's unique identifier | CS2103T | Must have two letters in the front, four numbers in the middle with an optional letter at the back
|`MODULE_TITLE`| A module's title | Software Engineering |-
|`MODULE_CREDITS`| The number of http://www.nus.edu.sg/registrar/academic-information-policies/graduate/modular-system[modular credits] a module is worth | 4 | Must be a number
|`SEMESTER`| An academic semester. There are two semesters in a year | Y1S1 | Must be in the format Y?S* where ? represents a digit from 0 - 4 and * represents a digit from 1 -2
|`GRADE` | A module's grade | A+ | Must be one of the following:  A+, A, A-, B+, B-, C+, C, D, D+, F, S, U |
|===

If, when issuing a command, the parameter restrictions are not strictly adhered to,
you might come across some common errors.
The following errors are generic and may be encountered when dealing with any module command:

[#tableModuleParametersErrorReference]
.Module Parameters Error Reference
|===
|Parameter|Error Message

|`MODULE_CODE`| The Module Code provided for the module is invalid!
|`MODULE_CREDITS`| The Module Credits provided for the module is invalid!
|`SEMESTER`| The Semester provided for the module is invalid!
|`GRADE`| The Grade provided for the module is invalid!
|===

These errors can all be resolved by adhering to the restrictions detailed in <<tableModuleParameters>>

[#ModuleAddCommand]
==== Module Add
Section by: https://github.com/waynewee[Wayne]

This command adds a module to the module list.

[#ModuleAddQuickReference]
.Module Add Quick Reference
|===
|Purpose | Adds a module
|Syntax| `module add n/MODULE_CODE t/MODULE_TITLE u/MODULE_CREDITS [s/SEMESTER]`
|Example | `module add n/CS2103T t/Software Engineering u/4 s/Y1S1`
|===

*How it Works*

When you type in this command, we take the given values for the `MODULE_CODE`, `MODULE_TITLE`, `MODULE_CREDITS` and optionally, the `SEMESTER`,
and fill in those fields. We do not check if the given `MODULE_CODE` or `MODULE_TITLE` refer to actual modules offered by NUS. However, the restrictions stated in the module parameters table still apply.

<<ModuleAddErrorReference>> lists errors you might encounter after issuing this command:

[#ModuleAddErrorReference]
.Module Add Error Reference
|===
|Name | Message| Explanation| Solution

|Duplicate Module Error |Sorry, this module already exists in the course book. | The module you are attempting to add already exists in the module list| Delete the existing module in the list and try again|
|===


*Tutorial*

Follow these steps to get a clearer idea of how this command works
[NOTE]
For this tutorial, actual values will be given instead of placeholders. Undo or Delete objects created from this tutorial by using the appropriate commands


1. Check that you do not have the modules with `MODULE_CODE` CS2103T and CS2101 in your list of modules

2. Type the following into the command box
`module add n/CS2103T u/4 t/Software Engineering` and press enter

3.  Type the following into the command box
`module add n/CS2101 u/4 t/Effective Communication for Computing Professionals` and press enter

4. The message in the response box should change and you should see the following in the module panel:

+
.Modules CS2103T and CS2101 successfully added
image::../images/user-guide\\moduleAutoAddCommand\\two_modules.png[]

//tag::wayne-ug[]
[#ModuleAutoAddCommand]
==== Module Auto Add
Section by: https://github.com/waynewee[Wayne]

This command adds a module to the module list. The module information is taken
from the https://api.nusmods.com/[NUSMods API] and includes the `MODULE_CODE`, `MODULE_TITLE`
and `MODULE_CREDITS`.

[#ModuleAutoAddQuickReference]
.Module Auto Add Quick Reference
|===
|Purpose | Adds a module from NUSMods
|Syntax| `module add n/MODULE_CODE_A n/MODULE_CODE_B -a`
|Example | `module add n/CS2103T n/CS2101 -a`
|===

*How it Works*

IMPORTANT: Do not miss out the `-a` flag

When you type in this command, a request is made to https://api.nusmods.com/[NUSMods API]. More specifically, we visit the
module page and ask for the information provided there. An example page can be found https://api.nusmods.com/2018-2019/modules/CS2103T/[here].

[NOTE]
We try to get the module information from the current academic year. However,
this might not always be possible as NUS might not have released
the module details. As a contingency, we retrieve the module information from the
previous academic year.

In general, using this command speeds up the process of module addition greatly. However, as we have to make
a request to an external webpage, the time taken to process the request might be considerably longer.

[WARNING]
After issuing the command, the app might seem to freeze. Not to worry! It is merely processing your request. Please be patient when executing this command, especially when attempting to add a large number of modules.

This command also supports _batch processing_ and you can add multiple modules, with the necessary information all
filled in, by issuing a single command. In the case where adding a single module in a batch of modules raises an error,
we skip that module and let you know what went wrong.

[TIP]
You can add up to 10 modules at once! Try this: `module add n/CS1101 n/CS1231 n/CS2030 n/CS2040 n/CS2100 n/CS2103T n/CS2105 n/CS2106 n/CS3230 n/CS3219 -a`

<<ModuleAutoAddErrorReference>> lists the errors you might encounter after issuing this command:

[#ModuleAutoAddErrorReference]
.Module Auto Add Error Reference
|===
|Name| Message| Explanation |Solution

|Duplicate Module Error | Duplicate Detected| Sorry, this module already exists in the course book.| Delete the existing module in the list and try again
|Module Not Found Error| Module Not Found| Sorry, I was unable to find this module. Is your internet down? |  Use the command <<ModuleAddCommand>> instead
|Module Overload Error | Module Overload Error| Please do not attempt to add more then 10 modules. | Divide the list of modules into smaller batches of size less than 10 and try again
|Connection Error| Connection Error| Sorry, I was unable to find this module. Is your internet down? | Whilst all other commands work offline. You need an internet connection to issue this command. Go online before trying again
|===

*Tutorial*

Follow these steps to get a clearer idea of how this command works

[NOTE]
For this tutorial, actual values will be given instead of placeholders. Undo or Delete objects created from this tutorial by using the appropriate commands

1. Check that you do not have the modules with `MODULE_CODE` CS2103T and CS2101 in your list of modules

2. Type the following into the command box
`module add n/CS2103T n/CS2101 -a` and press enter

3. Wait for up to 5 seconds

4. The message in the response box should change and you should see the following in the module panel

+
.Modules CS2103T and CS2101 successfully added from NUSMods
image::../images/user-guide\\moduleAutoAddCommand\\two_modules.png[]

*Additional Information*

We are also able to retrieve information pertaining to a module's prerequisites and preclusions. However, as our app can function as a module planner
in addition to tracking your graduation requirements, we do not prevent you from adding modules that have unfulfilled prerequisites but instead, simply show a warning.

WARNING: As the prerequisites and preclusions from NUSMods do not follow any standard formatting, the warning messages shown might not
always be accurate. This is due to a difficulty of interpreting
the data given by NUSMods. This remains a BETA feature and we hope to upgrade it in time.
// end::wayne-ug[]
==== Module Done
Section by: https://github.com/waynewee[Wayne]

This command marks a module as done by giving it a grade and optionally, a semester.

.Module Done Quick Reference
|===
|Purpose | Marks a module as done
|Syntax| `module done MODULE_CODE g/GRADE [s/SEMESTER]`
|Example | `module done CS2103T g/A s/Y1S1`
|===

*How it Works*

When you issue the command, we give your module the grade, and optionally the semester, that you provided. This helps us keep track of both your CAP and the number
of semesters you have left before graduating.

In order to calculate your CAP, we use a known algorithm which is guaranteed to be accurate. To see what semester you are currently at, we
take the latest semester given to a module which has been marked as done. From that, we are able to tell you how many semesters you have left.

[NOTE]
We do not currently allow the input of special terms. As a workaround, for modules taken
during special term, you could input the most recent semester instead

<<ModuleDoneErrorReference>> lists the errors you might encounter after issuing this command:

[#ModuleDoneErrorReference]
.Module Done Error Reference
|===
|Name| Message| Explanation |Solution

|Module Not Found Error | Sorry, I was unable to find this module. | The module you are attempting to mark as done does not exist in the module list| Add the module you wish to mark as done and try again
|===

*Tutorial*

[NOTE]
For this tutorial, actual values will be given instead of placeholders. Undo or Delete objects created from this tutorial by using the appropriate commands

Ensure that you have the module CS2103T in the module list

1. Type the following into the command box `module done CS2103T g/A s/Y4S1`

2. The message in the response box should change and you should see the following

+
.Modules CS2103T successfully given a grade and a semester
image::../images/user-guide\\moduleAutoAddCommand\\one_module.png[]

==== Module Edit
Section by: https://github.com/waynewee[Wayne]

This command edits the editable fields in a module which include the `MODULE_TITLE`, `MODULE_CREDITS`, `SEMESTER`.
Although it is possible to edit the fields as listed, it is unadvisable unless you made a mistake while keying
in the values.

.Module Edit Quick Reference
|===
|Purpose | Edits a module
|Syntax| `module edit MODULE_CODE [t/MODULE_TITLE] [u/MODULE_CREDITS] [s/SEMESTER]`
|Example | `module edit CS2103T t/Hardware Engineering u/8 s/Y1S2`
|===

*How it Works*

When you issue the command, we replace the fields provided with the given values. You are able to
change the values as you wish as long as they follow the restrictions as listed in the parameters table.

<<ModuleEditErrorReference>> lists the errors you might encounter after issuing this command:

[#ModuleEditErrorReference]
.Module Edit Error Reference
|===
|Name| Message| Explanation |Solution

|Module Not Found Error | Sorry, I was unable to find this module | The module you are attempting to edit does not exist in the module list| Instead of editing a module that does not exist, try adding a new one!
|===

*Tutorial*

[NOTE]
For this tutorial, actual values will be given instead of placeholders. Undo or Delete objects created from this tutorial by using the appropriate commands

Ensure that you have the module CS2103T in the module list

1. Type the following into the command box `module edit CS2103T t/Hardware Engineering s/Y1S1 u/8`

2. The message in the response box should change and you should see the following

+
.Modules CS2103T successfully given a grade and a semester
image::../images/user-guide\\moduleAutoAddCommand\\module_edit.png[]

==== Module Delete
Section by: https://github.com/waynewee[Wayne]

This command deletes a module from the module list.

.Delete Quick Reference
|===
|Purpose | Deletes a module
|Syntax| `module delete MODULE_CODE`https://xxx[]
|Example | `module delete CS2103T`
|===

*How it Works*

The module that you wish to delete is completely removed from the module list.
[WARNING]
Restoring the module is only possible using the `undo` command which would only work if `delete` was the last issued command.

<<ModuleDeleteErrorReference>> lists the errors you might encounter after issuing this command:

[#ModuleDeleteErrorReference]
.Module Delete Error Reference
|===
|Name| Message| Explanation |Solution

|Module Not Found Error | Sorry, I was unable to find this module| The module you are attempting to delete does not exist in the module list| Your problem is your solution!
|===

*Tutorial*
[NOTE]
For this tutorial, actual values will be given instead of placeholders. Undo or Delete objects created from this tutorial by using the appropriate commands

Ensure that you have the module CS2103T in the module list

1. Type the following into the command box `module delete CS2103T`

2. The message in the response box should change and you should see that the module CS2103T disappears from the module list

[#ModuleFilterCommand]
==== Module Filter
Section by: https://github.com/waynewee[Wayne]

This command allows you to find your modules by various parameters. You can filter the
complete module list by `SEMESTER`, `MODULE_CREDITS` and `GRADE`.

.Filter Quick Reference
|===
|Purpose | Displays a module list filtered based on the given parameters
|Syntax| `module filter [s/SEMESTER] [u/MODULE_CREDITS] [g/GRADE] [-o]`
|Example | `module filter s/Y1S1 u/4 g/A -o`
|===

*How it Works*

Two options are provided for you:

[Option 1] Displays modules that match all provided parameters

or

[Option 2] Displays modules that match at least one of the provided parameters.

If the flag `-o` is included at the end of the command, Option 2 will be chosen. Otherwise, the default option is Option 1.

IMPORTANT: In order to display all modules once again, simply type `module filter`. This will display an unfiltered module list containing all modules.

There are no notable errors to list. If wrong parameters are given, the app will simply
display the unfiltered module list. However, you should always take note of what filters are currently in place. If you
are unable to find some modules after using this command, please reset the display by typing in `module filter`.

WARNING: If you
are unable to find some modules after using this command, please reset the display by typing in `module filter`.

*Tutorial*

Ensure that the following modules are in the module list:
|===
|Module Code| Credits|Semester| Grade

|CS2103T|4|Y1S1|A
|CS2101|4|Y1S2|B
|CS2040|6|Y2S1|C
|===

 .. Retrieving modules which have 4 `CREDITS`
 . Type `module filter u/4` into the command box
 . The message in the response box should change and you should see the modules CS2103T and CS2101 in the module panel

 .. Retrieving modules which have either `SEMESTER` Y1S2 or `GRADE` C
. Type `module filter s/Y1S1 g/B -o`
. The message in the response box should change and you should see the modules CS2101 and CS2040 in the module panel


*Additional Information*

[NOTE]
This section contains information which requires prior knowledge of discrete mathematics or more specifically, logical operators

The flag `-o`, is present, sets the logical operator used in concatenating the parameters as _""or""_. The default logical operator used is _""and""_.

'''

=== Export
Section by: https://github.com/waynewee[Wayne]

This command exports your data to a comma-separated values (.csv) file. This file can then be submitted to the relevant
administration for processing of Leave of Absence (LOA), exchange programmes or internship applications.

.Export Quick Reference
|===
|Purpose | Exports your data to a .csv file
|Syntax| `export`
|Example | `export`
|===

*How it Works*

We write your data to a .csv file _study_plan.csv_ using the modules you have added and include the fields `MODULE_CODE`, `MODULE_TITLE`, `SEMESTER` and `CREDITS`.

.Study Plan Example CSV
image::../images/user-guide\\exportCommand\\export_csv_example.png[]

NOTE: Modules that have not been tagged with a semester will not be written

After issuing the command, you will be able to find the file in the same folder as the app's executable.

NOTE: For example, if the app is stored in your Desktop folder, the file _study_plan.csv_ will be created in the Desktop folder as well

<<ExportErrorReference>> lists the errors you might encounter after issuing this command:

[#ExportErrorReference]
.Export Error Reference
|===
|Name| Message| Explanation |Solution

|Write Error | Unable to write to file| Sorry, I was unable to export data to CSV file. Please ensure that you do not have the file 'study_plan.csv' open | Close the file and try again
|Data Not Found Error |Sorry, I couldn't find any modules that are tagged to a semester! I can only export modules that are tagged with a semester. | You do not have any modules tagged with a semester | Tag at least one module with a semester and try again
|===

'''

=== Exit
Section by: https://github.com/waynewee[Wayne]

This command assists you in exiting the program.

.Exit Quick Reference
|===
|Purpose | Exits the program
|Syntax| `exit`
|Example | `exit`
|===

*Additional Information*

You can also exit the program by clicking the close icon on the top right hand corner of the application's window.

## Version 2.0
Section by: https://github.com/waynewee[Wayne]

This sections details features that would be packaged with the next release

=== Module Suggester
Section by: https://github.com/waynewee[Wayne]

Using tried and tested recommendation algorithms such as https://en.wikipedia.org/wiki/Collaborative_filtering[collborative filtering], we would be able to automatically suggest
to you what modules to take next.

.Suggest Quick Reference
|===
|Purpose | Suggests modules to take
|Syntax| `suggest NUMBER_OF_MODULES`
|Example | `suggest 4`
|===

=== Integration with NUSMods
Section by: https://github.com/waynewee[Wayne]

We plan to integrate with popular timetabling application NUSMods so that you can manage all aspects of your academics
in one place.

## FAQs



_I'm not an NUS student. Can I still use iGrad?_

As long as your university follows a similar <<fig-2,hierachical structure>>!
However, we will be unable to provide features such as validation from NUSMods.

_Do I require an online connection to use iGrad?_

Nope! iGrad may be used offline. However, our validation feature which utilises NUSMods would be unavailable,
and you'll have to key in your module details manually.

_Where can I get the icons for the avatars?_

The avatar icons were obtained from https://www.freepik.com/free-vector/hand-drawn-kawaii-characters-collection_4098554.htm#page=1&query=cute%20animals&position=2[Freepik].
All credits go to the original creator.

//tag::cheatsheet[]
== Cheat Sheet

Section by: https://github.com/dargohzy[Daryl]

This segment contains a consolidated view of all the commands utilised in `iGrad`. Commands are split into the following
categories:

* Essential Commands
* Course Commands
* Requirement Commands
* Module Commands


=== Essential Commands
.Essential Commands
|===
|Description | Command

|Open the help window | `help`
|Undo last command | `undo`
|Export data | `export`
|Exit the application | `exit`
|===

=== Course Commands
.Course Commands
|===
|Description | Command

|Add a `Course` |  `course set n/COURSE_NAME s/TOTAL_SEMESTERS`
|Edit the `Course`|  `course edit n/COURSE_NAME s/TOTAL_SEMESTERS`
|Delete the `Course` |  `course delete`
|Find out `CAP` required per semester for desired `CAP` | `course achieve c/DESIRED_CAP s/SEMESTERS_LEFT`

|===

=== Requirement Commands
.Requirement Commands
|===
|Description | Command

|Add a `Requirement` | `requirement add t/REQUIREMENT_TITLE u/MCS_REQUIRED`
|Edit a `Requirement` | `requirement edit REQUIREMENT_CODE u/MCS_REQUIRED`
|Delete a `Requirement` | `requirement delete REQUIREMENT_CODE`
|Assigns the `Module`(s) under the requirement. |`requirement assign REQUIREMENT_CODE [n/MODULE_CODE...]`

|===

=== Module Commands
.Module Commands
|===
|Description | Command

| Add a `Module` | `module add n/MODULE_CODE t/MODULE_TITLE u/MCs [n/DESCRIPTION] [s/SEMESTER] [g/GRADE] [m/MEMO_NOTES]`
| Edit a `Module`| `module edit MODULE_CODE [n/MODULE_CODE] [t/MODULE_TITLE] [u/MCs] [s/SEMESTER] [g/GRADE]`
| Delete a `Module` | `module delete MODULE_CODE`
| Mark a `Module` as done. Counts the modular credits towards academic progress. |  `module done MODULE_CODE [g/GRADE] [s/SEMESTER]`

//end::cheatsheet[]

|===

## Glossary

|===
|Terms |Definition

|Course |A course is the entire programme of studies required to complete a university degree
|Graduation requirement |Requirements specified by the university in order for a student to graduate
|Module |Each module of study has a unique module code consisting of a two- or three-letter prefix that generally denotes the discipline, and four digits, the first of which indicates the level of the module
|Cumulative Average Point (CAP) |The Cumulative Average Point (CAP) is the weighted average grade point of the letter grades of all the modules taken by the students.
|Semester |A semester is a part of the academic year. Each semester typically lasts 13 weeks in NUS.
|Modular Credits (MCs) |A modular credit (MC) is a unit of the effort, stated in terms of time, expected of a typical student in managing his/her workload.
|NUSMods |A timetabling application built for NUS students, by NUS students. Much like this iGrad!

|===
",12254,False,2362.869096943453,median
"= Performance

== Performance/AncestorsInclude

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| No
| Yes (Unsafe)
| 1.7
| -
|===

This cop is used to identify usages of `ancestors.include?` and
change them to use `<=` instead.

=== Safety

This cop is unsafe because it can't tell whether the receiver is a class or an object.
e.g. the false positive was for `Nokogiri::XML::Node#ancestors`.

=== Examples

[source,ruby]
----
# bad
A.ancestors.include?(B)

# good
A <= B
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#ancestorsinclude-vs--code

== Performance/ArraySemiInfiniteRangeSlice

NOTE: Required Ruby version: 2.7

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Disabled
| No
| Yes (Unsafe)
| 1.9
| -
|===

This cop identifies places where slicing arrays with semi-infinite ranges
can be replaced by `Array#take` and `Array#drop`.
This cop was created due to a mistake in microbenchmark and hence is disabled by default.
Refer https://github.com/rubocop/rubocop-performance/pull/175#issuecomment-731892717

=== Safety

This cop is unsafe for string slices because strings do not have `#take` and `#drop` methods.

=== Examples

[source,ruby]
----
# bad
array[..2]
array[...2]
array[2..]
array[2...]
array.slice(..2)

# good
array.take(3)
array.take(2)
array.drop(2)
array.drop(2)
array.take(3)
----

== Performance/BigDecimalWithNumericArgument

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 1.7
| -
|===

This cop identifies places where numeric argument to BigDecimal should be
converted to string. Initializing from String is faster
than from Numeric for BigDecimal.

=== Examples

[source,ruby]
----
# bad
BigDecimal(1, 2)
4.to_d(6)
BigDecimal(1.2, 3, exception: true)
4.5.to_d(6, exception: true)

# good
BigDecimal('1', 2)
BigDecimal('4', 6)
BigDecimal('1.2', 3, exception: true)
BigDecimal('4.5', 6, exception: true)
----

== Performance/BindCall

NOTE: Required Ruby version: 2.7

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 1.6
| -
|===

In Ruby 2.7, `UnboundMethod#bind_call` has been added.

This cop identifies places where `bind(obj).call(args, ...)`
can be replaced by `bind_call(obj, args, ...)`.

The `bind_call(obj, args, ...)` method is faster than
`bind(obj).call(args, ...)`.

=== Examples

[source,ruby]
----
# bad
umethod.bind(obj).call(foo, bar)
umethod.bind(obj).(foo, bar)

# good
umethod.bind_call(obj, foo, bar)
----

== Performance/BlockGivenWithExplicitBlock

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 1.9
| -
|===

This cop identifies unnecessary use of a `block_given?` where explicit check
of block argument would suffice.

=== Examples

[source,ruby]
----
# bad
def method(&block)
  do_something if block_given?
end

# good
def method(&block)
  do_something if block
end

# good - block is reassigned
def method(&block)
  block ||= -> { do_something }
  warn ""Using default ..."" unless block_given?
  # ...
end
----

== Performance/Caller

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.49
| 1.9
|===

This cop identifies places where `caller[n]`
can be replaced by `caller(n..n).first`.

=== Examples

[source,ruby]
----
# bad
caller[1]
caller.first
caller_locations[1]
caller_locations.first

# good
caller(2..2).first
caller(1..1).first
caller_locations(2..2).first
caller_locations(1..1).first
----

== Performance/CaseWhenSplat

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Disabled
| Yes
| Yes (Unsafe)
| 0.34
| 1.13
|===

Reordering `when` conditions with a splat to the end
of the `when` branches can improve performance.

Ruby has to allocate memory for the splat expansion every time
that the `case` `when` statement is run. Since Ruby does not support
fall through inside of `case` `when`, like some other languages do,
the order of the `when` branches should not matter. By placing any
splat expansions at the end of the list of `when` branches we will
reduce the number of times that memory has to be allocated for
the expansion. The exception to this is if multiple of your `when`
conditions can be true for any given condition. A likely scenario for
this defining a higher level when condition to override a condition
that is inside of the splat expansion.

=== Safety

This cop is not unsafe auto-correction because it is not a guaranteed
performance improvement. If the data being processed by the `case` condition is
normalized in a manner that favors hitting a condition in the splat expansion,
it is possible that moving the splat condition to the end will use more memory,
and run slightly slower.
See for more details: https://github.com/rubocop/rubocop/pull/6163

=== Examples

[source,ruby]
----
# bad
case foo
when *condition
  bar
when baz
  foobar
end

case foo
when *[1, 2, 3, 4]
  bar
when 5
  baz
end

# good
case foo
when baz
  foobar
when *condition
  bar
end

case foo
when 1, 2, 3, 4
  bar
when 5
  baz
end
----

== Performance/Casecmp

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| No
| Yes (Unsafe)
| 0.36
| -
|===

This cop identifies places where a case-insensitive string comparison
can better be implemented using `casecmp`.

=== Safety

This cop is unsafe because `String#casecmp` and `String#casecmp?` behave
differently when using Non-ASCII characters.

=== Examples

[source,ruby]
----
# bad
str.downcase == 'abc'
str.upcase.eql? 'ABC'
'abc' == str.downcase
'ABC'.eql? str.upcase
str.downcase == str.downcase

# good
str.casecmp('ABC').zero?
'abc'.casecmp(str).zero?
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#stringcasecmp-vs-stringdowncase---code

== Performance/ChainArrayAllocation

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Disabled
| Yes
| No
| 0.59
| -
|===

This cop is used to identify usages of
Each of these methods (`compact`, `flatten`, `map`) will generate a
new intermediate array that is promptly thrown away. Instead it is
faster to mutate when we know it's safe.

=== Examples

[source,ruby]
----
# bad
array = [""a"", ""b"", ""c""]
array.compact.flatten.map { |x| x.downcase }
----

[source,ruby]
----
# good.
array = [""a"", ""b"", ""c""]
array.compact!
array.flatten!
array.map! { |x| x.downcase }
array
----

=== References

* https://twitter.com/schneems/status/1034123879978029057

== Performance/CollectionLiteralInLoop

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| No
| 1.8
| -
|===

This cop identifies places where Array and Hash literals are used
within loops. It is better to extract them into a local variable or constant
to avoid unnecessary allocations on each iteration.

You can set the minimum number of elements to consider
an offense with `MinSize`.

=== Examples

[source,ruby]
----
# bad
users.select do |user|
  %i[superadmin admin].include?(user.role)
end

# good
admin_roles = %i[superadmin admin]
users.select do |user|
  admin_roles.include?(user.role)
end

# good
ADMIN_ROLES = %i[superadmin admin]
...
users.select do |user|
  ADMIN_ROLES.include?(user.role)
end
----

=== Configurable attributes

|===
| Name | Default value | Configurable values

| MinSize
| `1`
| Integer
|===

== Performance/CompareWithBlock

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.46
| -
|===

This cop identifies places where `sort { |a, b| a.foo <=> b.foo }`
can be replaced by `sort_by(&:foo)`.
This cop also checks `max` and `min` methods.

=== Examples

[source,ruby]
----
# bad
array.sort { |a, b| a.foo <=> b.foo }
array.max { |a, b| a.foo <=> b.foo }
array.min { |a, b| a.foo <=> b.foo }
array.sort { |a, b| a[:foo] <=> b[:foo] }

# good
array.sort_by(&:foo)
array.sort_by { |v| v.foo }
array.sort_by do |var|
  var.foo
end
array.max_by(&:foo)
array.min_by(&:foo)
array.sort_by { |a| a[:foo] }
----

== Performance/ConcurrentMonotonicTime

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 1.12
| -
|===

This cop identifies places where `Concurrent.monotonic_time`
can be replaced by `Process.clock_gettime(Process::CLOCK_MONOTONIC)`.

=== Examples

[source,ruby]
----
# bad
Concurrent.monotonic_time

# good
Process.clock_gettime(Process::CLOCK_MONOTONIC)
----

=== References

* https://github.com/rails/rails/pull/43502

== Performance/ConstantRegexp

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 1.9
| 1.10
|===

This cop finds regular expressions with dynamic components that are all constants.

Ruby allocates a new Regexp object every time it executes a code containing such
a regular expression. It is more efficient to extract it into a constant,
memoize it, or add an `/o` option to perform `#{}` interpolation only once and
reuse that Regexp object.

=== Examples

[source,ruby]
----
# bad
def tokens(pattern)
  pattern.scan(TOKEN).reject { |token| token.match?(/\\A#{SEPARATORS}\\Z/) }
end

# good
ALL_SEPARATORS = /\\A#{SEPARATORS}\\Z/
def tokens(pattern)
  pattern.scan(TOKEN).reject { |token| token.match?(ALL_SEPARATORS) }
end

# good
def tokens(pattern)
  pattern.scan(TOKEN).reject { |token| token.match?(/\\A#{SEPARATORS}\\Z/o) }
end

# good
def separators
  @separators ||= /\\A#{SEPARATORS}\\Z/
end
----

== Performance/Count

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes (Unsafe)
| 0.31
| 1.8
|===

This cop is used to identify usages of `count` on an `Enumerable` that
follow calls to `select`, `find_all`, `filter` or `reject`. Querying logic can instead be
passed to the `count` call.

=== Safety

This cop is unsafe because it has known compatibility issues with `ActiveRecord` and other
frameworks. ActiveRecord's `count` ignores the block that is passed to it.
`ActiveRecord` will ignore the block that is passed to `count`.
Other methods, such as `select`, will convert the association to an
array and then run the block on the array. A simple work around to
make `count` work with a block is to call `to_a.count {...}`.

For example:

[source,ruby]
----
`Model.where(id: [1, 2, 3]).select { |m| m.method == true }.size`
----

becomes:

[source,ruby]
----
`Model.where(id: [1, 2, 3]).to_a.count { |m| m.method == true }`
----

=== Examples

[source,ruby]
----
# bad
[1, 2, 3].select { |e| e > 2 }.size
[1, 2, 3].reject { |e| e > 2 }.size
[1, 2, 3].select { |e| e > 2 }.length
[1, 2, 3].reject { |e| e > 2 }.length
[1, 2, 3].select { |e| e > 2 }.count { |e| e.odd? }
[1, 2, 3].reject { |e| e > 2 }.count { |e| e.even? }
array.select(&:value).count

# good
[1, 2, 3].count { |e| e > 2 }
[1, 2, 3].count { |e| e < 2 }
[1, 2, 3].count { |e| e > 2 && e.odd? }
[1, 2, 3].count { |e| e < 2 && e.even? }
Model.select('field AS field_one').count
Model.select(:value).count
----

== Performance/DeletePrefix

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| No
| Yes (Unsafe)
| 1.6
| 1.11
|===

In Ruby 2.5, `String#delete_prefix` has been added.

This cop identifies places where `gsub(/\\Aprefix/, '')` and `sub(/\\Aprefix/, '')`
can be replaced by `delete_prefix('prefix')`.

This cop has `SafeMultiline` configuration option that `true` by default because
`^prefix` is unsafe as it will behave incompatible with `delete_prefix`
for receiver is multiline string.

The `delete_prefix('prefix')` method is faster than `gsub(/\\Aprefix/, '')`.

=== Safety

This cop is unsafe because `Pathname` has `sub` but not `delete_prefix`.

=== Examples

[source,ruby]
----
# bad
str.gsub(/\\Aprefix/, '')
str.gsub!(/\\Aprefix/, '')

str.sub(/\\Aprefix/, '')
str.sub!(/\\Aprefix/, '')

# good
str.delete_prefix('prefix')
str.delete_prefix!('prefix')
----

==== SafeMultiline: true (default)

[source,ruby]
----
# good
str.gsub(/^prefix/, '')
str.gsub!(/^prefix/, '')
str.sub(/^prefix/, '')
str.sub!(/^prefix/, '')
----

==== SafeMultiline: false

[source,ruby]
----
# bad
str.gsub(/^prefix/, '')
str.gsub!(/^prefix/, '')
str.sub(/^prefix/, '')
str.sub!(/^prefix/, '')
----

=== Configurable attributes

|===
| Name | Default value | Configurable values

| SafeMultiline
| `true`
| Boolean
|===

== Performance/DeleteSuffix

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| No
| Yes (Unsafe)
| 1.6
| 1.11
|===

In Ruby 2.5, `String#delete_suffix` has been added.

This cop identifies places where `gsub(/suffix\\z/, '')` and `sub(/suffix\\z/, '')`
can be replaced by `delete_suffix('suffix')`.

This cop has `SafeMultiline` configuration option that `true` by default because
`suffix$` is unsafe as it will behave incompatible with `delete_suffix?`
for receiver is multiline string.

The `delete_suffix('suffix')` method is faster than `gsub(/suffix\\z/, '')`.

=== Safety

This cop is unsafe because `Pathname` has `sub` but not `delete_suffix`.

=== Examples

[source,ruby]
----
# bad
str.gsub(/suffix\\z/, '')
str.gsub!(/suffix\\z/, '')

str.sub(/suffix\\z/, '')
str.sub!(/suffix\\z/, '')

# good
str.delete_suffix('suffix')
str.delete_suffix!('suffix')
----

==== SafeMultiline: true (default)

[source,ruby]
----
# good
str.gsub(/suffix$/, '')
str.gsub!(/suffix$/, '')
str.sub(/suffix$/, '')
str.sub!(/suffix$/, '')
----

==== SafeMultiline: false

[source,ruby]
----
# bad
str.gsub(/suffix$/, '')
str.gsub!(/suffix$/, '')
str.sub(/suffix$/, '')
str.sub!(/suffix$/, '')
----

=== Configurable attributes

|===
| Name | Default value | Configurable values

| SafeMultiline
| `true`
| Boolean
|===

== Performance/Detect

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes (Unsafe)
| 0.30
| 1.8
|===

This cop is used to identify usages of `first`, `last`, `[0]` or `[-1]`
chained to `select`, `find_all` or `filter` and change them to use
`detect` instead.

=== Safety

This cop is unsafe because is has known compatibility issues with `ActiveRecord` and other
frameworks. `ActiveRecord` does not implement a `detect` method and `find` has its own
meaning. Correcting `ActiveRecord` methods with this cop should be considered unsafe.

=== Examples

[source,ruby]
----
# bad
[].select { |item| true }.first
[].select { |item| true }.last
[].find_all { |item| true }.first
[].find_all { |item| true }.last
[].filter { |item| true }.first
[].filter { |item| true }.last
[].filter { |item| true }[0]
[].filter { |item| true }[-1]

# good
[].detect { |item| true }
[].reverse.detect { |item| true }
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#enumerabledetect-vs-enumerableselectfirst-code

== Performance/DoubleStartEndWith

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.36
| 0.48
|===

This cop checks for double `#start_with?` or `#end_with?` calls
separated by `||`. In some cases such calls can be replaced
with an single `#start_with?`/`#end_with?` call.

`IncludeActiveSupportAliases` configuration option is used to check for
`starts_with?` and `ends_with?`. These methods are defined by Active Support.

=== Examples

[source,ruby]
----
# bad
str.start_with?(""a"") || str.start_with?(Some::CONST)
str.start_with?(""a"", ""b"") || str.start_with?(""c"")
str.end_with?(var1) || str.end_with?(var2)

# good
str.start_with?(""a"", Some::CONST)
str.start_with?(""a"", ""b"", ""c"")
str.end_with?(var1, var2)
----

==== IncludeActiveSupportAliases: false (default)

[source,ruby]
----
# good
str.starts_with?(""a"", ""b"") || str.starts_with?(""c"")
str.ends_with?(var1) || str.ends_with?(var2)

str.starts_with?(""a"", ""b"", ""c"")
str.ends_with?(var1, var2)
----

==== IncludeActiveSupportAliases: true

[source,ruby]
----
# bad
str.starts_with?(""a"", ""b"") || str.starts_with?(""c"")
str.ends_with?(var1) || str.ends_with?(var2)

# good
str.starts_with?(""a"", ""b"", ""c"")
str.ends_with?(var1, var2)
----

=== Configurable attributes

|===
| Name | Default value | Configurable values

| IncludeActiveSupportAliases
| `false`
| Boolean
|===

== Performance/EndWith

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes (Unsafe)
| 0.36
| 1.10
|===

This cop identifies unnecessary use of a regex where `String#end_with?` would suffice.

This cop has `SafeMultiline` configuration option that `true` by default because
`end$` is unsafe as it will behave incompatible with `end_with?`
for receiver is multiline string.

=== Safety

This will change to a new method call which isn't guaranteed to be on the
object. Switching these methods has to be done with knowledge of the types
of the variables which rubocop doesn't have.

=== Examples

[source,ruby]
----
# bad
'abc'.match?(/bc\\Z/)
/bc\\Z/.match?('abc')
'abc' =~ /bc\\Z/
/bc\\Z/ =~ 'abc'
'abc'.match(/bc\\Z/)
/bc\\Z/.match('abc')

# good
'abc'.end_with?('bc')
----

==== SafeMultiline: true (default)

[source,ruby]
----
# good
'abc'.match?(/bc$/)
/bc$/.match?('abc')
'abc' =~ /bc$/
/bc$/ =~ 'abc'
'abc'.match(/bc$/)
/bc$/.match('abc')
----

==== SafeMultiline: false

[source,ruby]
----
# bad
'abc'.match?(/bc$/)
/bc$/.match?('abc')
'abc' =~ /bc$/
/bc$/ =~ 'abc'
'abc'.match(/bc$/)
/bc$/.match('abc')
----

=== Configurable attributes

|===
| Name | Default value | Configurable values

| SafeMultiline
| `true`
| Boolean
|===

=== References

* https://github.com/JuanitoFatas/fast-ruby#stringmatch-vs-stringstart_withstringend_with-code-start-code-end

== Performance/FixedSize

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| No
| 0.35
| -
|===

Do not compute the size of statically sized objects.

=== Examples

[source,ruby]
----
# String methods
# bad
'foo'.size
%q[bar].count
%(qux).length

# Symbol methods
# bad
:fred.size
:'baz'.length

# Array methods
# bad
[1, 2, thud].count
%W(1, 2, bar).size

# Hash methods
# bad
{ a: corge, b: grault }.length

# good
foo.size
bar.count
qux.length

# good
:""#{fred}"".size
CONST = :baz.length

# good
[1, 2, *thud].count
garply = [1, 2, 3]
garply.size

# good
{ a: corge, **grault }.length
waldo = { a: corge, b: grault }
waldo.size
----

== Performance/FlatMap

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.30
| -
|===

This cop is used to identify usages of `map { ... }.flatten` and
change them to use `flat_map { ... }` instead.

=== Examples

[source,ruby]
----
# bad
[1, 2, 3, 4].map { |e| [e, e] }.flatten(1)
[1, 2, 3, 4].collect { |e| [e, e] }.flatten(1)

# good
[1, 2, 3, 4].flat_map { |e| [e, e] }
[1, 2, 3, 4].map { |e| [e, e] }.flatten
[1, 2, 3, 4].collect { |e| [e, e] }.flatten
----

=== Configurable attributes

|===
| Name | Default value | Configurable values

| EnabledForFlattenWithoutParams
| `false`
| Boolean
|===

=== References

* https://github.com/JuanitoFatas/fast-ruby#enumerablemaparrayflatten-vs-enumerableflat_map-code

== Performance/InefficientHashSearch

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| No
| Yes (Unsafe)
| 0.56
| -
|===

This cop checks for inefficient searching of keys and values within
hashes.

`Hash#keys.include?` is less efficient than `Hash#key?` because
the former allocates a new array and then performs an O(n) search
through that array, while `Hash#key?` does not allocate any array and
performs a faster O(1) search for the key.

`Hash#values.include?` is less efficient than `Hash#value?`. While they
both perform an O(n) search through all of the values, calling `values`
allocates a new array while using `value?` does not.

=== Safety

This cop is unsafe because it can't tell whether the receiver is a hash object.

=== Examples

[source,ruby]
----
# bad
{ a: 1, b: 2 }.keys.include?(:a)
{ a: 1, b: 2 }.keys.include?(:z)
h = { a: 1, b: 2 }; h.keys.include?(100)

# good
{ a: 1, b: 2 }.key?(:a)
{ a: 1, b: 2 }.has_key?(:z)
h = { a: 1, b: 2 }; h.key?(100)

# bad
{ a: 1, b: 2 }.values.include?(2)
{ a: 1, b: 2 }.values.include?('garbage')
h = { a: 1, b: 2 }; h.values.include?(nil)

# good
{ a: 1, b: 2 }.value?(2)
{ a: 1, b: 2 }.has_value?('garbage')
h = { a: 1, b: 2 }; h.value?(nil)
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#hashkey-instead-of-hashkeysinclude-code

== Performance/IoReadlines

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Disabled
| Yes
| Yes
| 1.7
| -
|===

This cop identifies places where inefficient `readlines` method
can be replaced by `each_line` to avoid fully loading file content into memory.

=== Examples

[source,ruby]
----
# bad
File.readlines('testfile').each { |l| puts l }
IO.readlines('testfile', chomp: true).each { |l| puts l }

conn.readlines(10).map { |l| l.size }
file.readlines.find { |l| l.start_with?('#') }
file.readlines.each { |l| puts l }

# good
File.open('testfile', 'r').each_line { |l| puts l }
IO.open('testfile').each_line(chomp: true) { |l| puts l }

conn.each_line(10).map { |l| l.size }
file.each_line.find { |l| l.start_with?('#') }
file.each_line { |l| puts l }
----

=== References

* https://docs.gitlab.com/ee/development/performance.html#reading-from-files-and-other-data-sources

== Performance/MapCompact

NOTE: Required Ruby version: 2.7

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes (Unsafe)
| 1.11
| -
|===

In Ruby 2.7, `Enumerable#filter_map` has been added.

This cop identifies places where `map { ... }.compact` can be replaced by `filter_map`.

[source,ruby]
----
[true, false, nil].compact              #=> [true, false]
[true, false, nil].filter_map(&:itself) #=> [true]
----

=== Safety

This cop's autocorrection is unsafe because `map { ... }.compact` that is not
compatible with `filter_map`.

=== Examples

[source,ruby]
----
# bad
ary.map(&:foo).compact
ary.collect(&:foo).compact

# good
ary.filter_map(&:foo)
ary.map(&:foo).compact!
ary.compact.map(&:foo)
----

== Performance/MethodObjectAsBlock

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| No
| 1.9
| -
|===

This cop identifies places where methods are converted to blocks, with the
use of `&method`, and passed as arguments to method calls.
It is faster to replace those with explicit blocks, calling those methods inside.

=== Examples

[source,ruby]
----
# bad
array.map(&method(:do_something))
[1, 2, 3].each(&out.method(:puts))

# good
array.map { |x| do_something(x) }
[1, 2, 3].each { |x| out.puts(x) }
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#normal-way-to-apply-method-vs-method-code

== Performance/OpenStruct

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Disabled
| No
| No
| 0.61
| -
|===

This cop checks for `OpenStruct.new` calls.
Instantiation of an `OpenStruct` invalidates
Ruby global method cache as it causes dynamic method
definition during program runtime.
This could have an effect on performance,
especially in case of single-threaded
applications with multiple `OpenStruct` instantiations.

=== Safety

This cop is unsafe because `OpenStruct.new` and `Struct.new`
are not equivalent.

=== Examples

[source,ruby]
----
# bad
class MyClass
  def my_method
    OpenStruct.new(my_key1: 'my_value1', my_key2: 'my_value2')
  end
end

# good
class MyClass
  MyStruct = Struct.new(:my_key1, :my_key2)
  def my_method
    MyStruct.new('my_value1', 'my_value2')
  end
end
----

== Performance/RangeInclude

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| No
| Yes (Unsafe)
| 0.36
| 1.7
|===

This cop identifies uses of `Range#include?` and `Range#member?`, which iterates over each
item in a `Range` to see if a specified item is there. In contrast,
`Range#cover?` simply compares the target item with the beginning and
end points of the `Range`. In a great majority of cases, this is what
is wanted.

=== Safety

This cop is unsafe because `Range#include?` (or `Range#member?`) and `Range#cover?`
are not equivalent behaviour.

=== Examples

[source,ruby]
----
# bad
('a'..'z').include?('b') # => true
('a'..'z').member?('b')  # => true

# good
('a'..'z').cover?('b') # => true

# Example of a case where `Range#cover?` may not provide
# the desired result:

('a'..'z').cover?('yellow') # => true
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#cover-vs-include-code

== Performance/RedundantBlockCall

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.36
| -
|===

This cop identifies the use of a `&block` parameter and `block.call`
where `yield` would do just as well.

=== Examples

[source,ruby]
----
# bad
def method(&block)
  block.call
end
def another(&func)
  func.call 1, 2, 3
end

# good
def method
  yield
end
def another
  yield 1, 2, 3
end
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#proccall-and-block-arguments-vs-yieldcode

== Performance/RedundantEqualityComparisonBlock

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| No
| Yes (Unsafe)
| 1.10
| -
|===

This cop checks for uses `Enumerable#all?`, `Enumerable#any?`, `Enumerable#one?`,
and `Enumerable#none?` are compared with `===` or similar methods in block.

By default, `Object#===` behaves the same as `Object#==`, but this
behavior is appropriately overridden in subclass. For example,
`Range#===` returns `true` when argument is within the range.

=== Safety

This cop is unsafe because `===` and `==` do not always behave the same.

=== Examples

[source,ruby]
----
# bad
items.all? { |item| pattern === item }
items.all? { |item| item == other }
items.all? { |item| item.is_a?(Klass) }
items.all? { |item| item.kind_of?(Klass) }

# good
items.all?(pattern)
----

=== References

* https://github.com/rails/rails/pull/41363

== Performance/RedundantMatch

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.36
| -
|===

This cop identifies the use of `Regexp#match` or `String#match`, which
returns `#<MatchData>`/`nil`. The return value of `=~` is an integral
index/`nil` and is more performant.

=== Examples

[source,ruby]
----
# bad
do_something if str.match(/regex/)
while regex.match('str')
  do_something
end

# good
method(str =~ /regex/)
return value unless regex =~ 'str'
----

== Performance/RedundantMerge

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| No
| Yes (Unsafe)
| 0.36
| 1.11
|===

This cop identifies places where `Hash#merge!` can be replaced by
`Hash#[]=`.
You can set the maximum number of key-value pairs to consider
an offense with `MaxKeyValuePairs`.

=== Safety

This cop is unsafe because RuboCop cannot determine if the
receiver of `merge!` is actually a hash or not.

=== Examples

[source,ruby]
----
# bad
hash.merge!(a: 1)
hash.merge!({'key' => 'value'})

# good
hash[:a] = 1
hash['key'] = 'value'
----

==== MaxKeyValuePairs: 2 (default)

[source,ruby]
----
# bad
hash.merge!(a: 1, b: 2)

# good
hash[:a] = 1
hash[:b] = 2
----

=== Configurable attributes

|===
| Name | Default value | Configurable values

| MaxKeyValuePairs
| `2`
| Integer
|===

=== References

* https://github.com/JuanitoFatas/fast-ruby#hashmerge-vs-hash-code

== Performance/RedundantSortBlock

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 1.7
| -
|===

This cop identifies places where `sort { |a, b| a <=> b }`
can be replaced with `sort`.

=== Examples

[source,ruby]
----
# bad
array.sort { |a, b| a <=> b }

# good
array.sort
----

== Performance/RedundantSplitRegexpArgument

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 1.10
| -
|===

This cop identifies places where `split` argument can be replaced from
a deterministic regexp to a string.

=== Examples

[source,ruby]
----
# bad
'a,b,c'.split(/,/)

# good
'a,b,c'.split(',')
----

== Performance/RedundantStringChars

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 1.7
| -
|===

This cop checks for redundant `String#chars`.

=== Examples

[source,ruby]
----
# bad
str.chars[0..2]
str.chars.slice(0..2)

# good
str[0..2].chars

# bad
str.chars.first
str.chars.first(2)

# good
str[0]
str[0...2].chars

# bad
str.chars.take(2)
str.chars.length
str.chars.size
str.chars.empty?

# good
str[0...2].chars
str.length
str.size
str.empty?

# For example, if the receiver is a blank string, it will be incompatible.
# If a negative value is specified for the receiver, `nil` is returned.
str.chars.last    # Incompatible with `str[-1]`.
str.chars.last(2) # Incompatible with `str[-2..-1].chars`.
str.chars.drop(2) # Incompatible with `str[2..-1].chars`.
----

== Performance/RegexpMatch

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.47
| -
|===

In Ruby 2.4, `String#match?`, `Regexp#match?`, and `Symbol#match?`
have been added. The methods are faster than `match`.
Because the methods avoid creating a `MatchData` object or saving
backref.
So, when `MatchData` is not used, use `match?` instead of `match`.

=== Examples

[source,ruby]
----
# bad
def foo
  if x =~ /re/
    do_something
  end
end

# bad
def foo
  if x !~ /re/
    do_something
  end
end

# bad
def foo
  if x.match(/re/)
    do_something
  end
end

# bad
def foo
  if /re/ === x
    do_something
  end
end

# good
def foo
  if x.match?(/re/)
    do_something
  end
end

# good
def foo
  if !x.match?(/re/)
    do_something
  end
end

# good
def foo
  if x =~ /re/
    do_something(Regexp.last_match)
  end
end

# good
def foo
  if x.match(/re/)
    do_something($~)
  end
end

# good
def foo
  if /re/ === x
    do_something($~)
  end
end
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#regexp-vs-stringmatch-vs-string-vs-stringmatch-code-

== Performance/ReverseEach

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.30
| -
|===

This cop is used to identify usages of `reverse.each` and
change them to use `reverse_each` instead.

If the return value is used, it will not be detected because the result will be different.

[source,ruby]
----
[1, 2, 3].reverse.each {} #=> [3, 2, 1]
[1, 2, 3].reverse_each {} #=> [1, 2, 3]
----

=== Examples

[source,ruby]
----
# bad
items.reverse.each

# good
items.reverse_each
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#enumerablereverseeach-vs-enumerablereverse_each-code

== Performance/ReverseFirst

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 1.7
| -
|===

This cop identifies places where `reverse.first(n)` and `reverse.first`
can be replaced by `last(n).reverse` and `last`.

=== Examples

[source,ruby]
----
# bad
array.reverse.first(5)
array.reverse.first

# good
array.last(5).reverse
array.last
----

== Performance/SelectMap

NOTE: Required Ruby version: 2.7

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Disabled
| Yes
| No
| 1.11
| -
|===

In Ruby 2.7, `Enumerable#filter_map` has been added.

This cop identifies places where `select.map` can be replaced by `filter_map`.

=== Examples

[source,ruby]
----
# bad
ary.select(&:foo).map(&:bar)
ary.filter(&:foo).map(&:bar)

# good
ary.filter_map { |o| o.bar if o.foo }
----

== Performance/Size

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.30
| -
|===

This cop is used to identify usages of `count` on an
`Array` and `Hash` and change them to `size`.

TODO: Add advanced detection of variables that could
have been assigned to an array or a hash.

=== Examples

[source,ruby]
----
# bad
[1, 2, 3].count
(1..3).to_a.count
Array[*1..3].count
Array(1..3).count

# bad
{a: 1, b: 2, c: 3}.count
[[:foo, :bar], [1, 2]].to_h.count
Hash[*('a'..'z')].count
Hash(key: :value).count

# good
[1, 2, 3].size
(1..3).to_a.size
Array[*1..3].size
Array(1..3).size

# good
{a: 1, b: 2, c: 3}.size
[[:foo, :bar], [1, 2]].to_h.size
Hash[*('a'..'z')].size
Hash(key: :value).size

# good
[1, 2, 3].count { |e| e > 2 }
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#arraylength-vs-arraysize-vs-arraycount-code

== Performance/SortReverse

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 1.7
| -
|===

This cop identifies places where `sort { |a, b| b <=> a }`
can be replaced by a faster `sort.reverse`.

=== Examples

[source,ruby]
----
# bad
array.sort { |a, b| b <=> a }

# good
array.sort.reverse
----

== Performance/Squeeze

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 1.7
| -
|===

This cop identifies places where `gsub(/a+/, 'a')` and `gsub!(/a+/, 'a')`
can be replaced by `squeeze('a')` and `squeeze!('a')`.

The `squeeze('a')` method is faster than `gsub(/a+/, 'a')`.

=== Examples

[source,ruby]
----
# bad
str.gsub(/a+/, 'a')
str.gsub!(/a+/, 'a')

# good
str.squeeze('a')
str.squeeze!('a')
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#remove-extra-spaces-or-other-contiguous-characters-code

== Performance/StartWith

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes (Unsafe)
| 0.36
| 1.10
|===

This cop identifies unnecessary use of a regex where `String#start_with?` would suffice.

This cop has `SafeMultiline` configuration option that `true` by default because
`^start` is unsafe as it will behave incompatible with `start_with?`
for receiver is multiline string.

=== Safety

This will change to a new method call which isn't guaranteed to be on the
object. Switching these methods has to be done with knowledge of the types
of the variables which rubocop doesn't have.

=== Examples

[source,ruby]
----
# bad
'abc'.match?(/\\Aab/)
/\\Aab/.match?('abc')
'abc' =~ /\\Aab/
/\\Aab/ =~ 'abc'
'abc'.match(/\\Aab/)
/\\Aab/.match('abc')

# good
'abc'.start_with?('ab')
----

==== SafeMultiline: true (default)

[source,ruby]
----
# good
'abc'.match?(/^ab/)
/^ab/.match?('abc')
'abc' =~ /^ab/
/^ab/ =~ 'abc'
'abc'.match(/^ab/)
/^ab/.match('abc')
----

==== SafeMultiline: false

[source,ruby]
----
# bad
'abc'.match?(/^ab/)
/^ab/.match?('abc')
'abc' =~ /^ab/
/^ab/ =~ 'abc'
'abc'.match(/^ab/)
/^ab/.match('abc')
----

=== Configurable attributes

|===
| Name | Default value | Configurable values

| SafeMultiline
| `true`
| Boolean
|===

=== References

* https://github.com/JuanitoFatas/fast-ruby#stringmatch-vs-stringstart_withstringend_with-code-start-code-end

== Performance/StringIdentifierArgument

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes
| 1.13
| -
|===

This cop identifies places where string identifier argument can be replaced
by symbol identifier argument.
It prevents the redundancy of the internal string-to-symbol conversion.

This cop targets methods that take identifier (e.g. method name) argument
and the following examples are parts of it.

=== Examples

[source,ruby]
----
# bad
send('do_something')
attr_accessor 'do_something'
instance_variable_get('@ivar')

# good
send(:do_something)
attr_accessor :do_something
instance_variable_get(:@ivar)
----

== Performance/StringInclude

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes (Unsafe)
| 1.7
| 1.12
|===

This cop identifies unnecessary use of a regex where
`String#include?` would suffice.

=== Safety

This cop's offenses are not safe to auto-correct if a receiver is nil.

=== Examples

[source,ruby]
----
# bad
'abc'.match?(/ab/)
/ab/.match?('abc')
'abc' =~ /ab/
/ab/ =~ 'abc'
'abc'.match(/ab/)
/ab/.match('abc')

# good
'abc'.include?('ab')
----

== Performance/StringReplacement

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.33
| -
|===

This cop identifies places where `gsub` can be replaced by
`tr` or `delete`.

=== Examples

[source,ruby]
----
# bad
'abc'.gsub('b', 'd')
'abc'.gsub('a', '')
'abc'.gsub(/a/, 'd')
'abc'.gsub!('a', 'd')

# good
'abc'.gsub(/.*/, 'a')
'abc'.gsub(/a+/, 'd')
'abc'.tr('b', 'd')
'a b c'.delete(' ')
----

=== References

* https://github.com/JuanitoFatas/fast-ruby#stringgsub-vs-stringtr-code

== Performance/Sum

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Pending
| Yes
| Yes (Unsafe)
| 1.8
| 1.13
|===

This cop identifies places where custom code finding the sum of elements
in some Enumerable object can be replaced by `Enumerable#sum` method.

=== Safety

Auto-corrections are unproblematic wherever an initial value is provided explicitly:

[source,ruby]
----
[1, 2, 3].reduce(4, :+) # => 10
[1, 2, 3].sum(4) # => 10

[].reduce(4, :+) # => 4
[].sum(4) # => 4
----

This also holds true for non-numeric types which implement a `:+` method:

[source,ruby]
----
['l', 'o'].reduce('Hel', :+) # => ""Hello""
['l', 'o'].sum('Hel') # => ""Hello""
----

When no initial value is provided though, `Enumerable#reduce` will pick the first enumerated value
as initial value and successively add all following values to it, whereas
`Enumerable#sum` will set an initial value of `0` (`Integer`) which can lead to a `TypeError`:

[source,ruby]
----
[].reduce(:+) # => nil
[1, 2, 3].reduce(:+) # => 6
['H', 'e', 'l', 'l', 'o'].reduce(:+) # => ""Hello""

[].sum # => 0
[1, 2, 3].sum # => 6
['H', 'e', 'l', 'l', 'o'].sum # => in `+': String can't be coerced into Integer (TypeError)
----

=== Examples

==== OnlySumOrWithInitialValue: false (default)

[source,ruby]
----
# bad
[1, 2, 3].inject(:+)                        # Auto-corrections for cases without initial value are unsafe
[1, 2, 3].inject(&:+)                       # and will only be performed when using the `-A` option.
[1, 2, 3].reduce { |acc, elem| acc + elem } # They can be prohibited completely using `SafeAutoCorrect: true`.
[1, 2, 3].reduce(10, :+)
[1, 2, 3].map { |elem| elem ** 2 }.sum
[1, 2, 3].collect(&:count).sum(10)

# good
[1, 2, 3].sum
[1, 2, 3].sum(10)
[1, 2, 3].sum { |elem| elem ** 2 }
[1, 2, 3].sum(10, &:count)
----

==== OnlySumOrWithInitialValue: true

[source,ruby]
----
# bad
[1, 2, 3].reduce(10, :+)
[1, 2, 3].map { |elem| elem ** 2 }.sum
[1, 2, 3].collect(&:count).sum(10)

# good
[1, 2, 3].sum(10)
[1, 2, 3].sum { |elem| elem ** 2 }
[1, 2, 3].sum(10, &:count)
----

=== Configurable attributes

|===
| Name | Default value | Configurable values

| OnlySumOrWithInitialValue
| `false`
| Boolean
|===

=== References

* https://blog.bigbinary.com/2016/11/02/ruby-2-4-introduces-enumerable-sum.html

== Performance/TimesMap

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes (Unsafe)
| 0.36
| 1.13
|===

This cop checks for .times.map calls.
In most cases such calls can be replaced
with an explicit array creation.

=== Safety

This cop's autocorrection is unsafe because `Integer#times` does nothing if receiver is 0
or less. However, `Array.new` raises an error if argument is less than 0.

For example:

[source,ruby]
----
-1.times{}    # does nothing
Array.new(-1) # ArgumentError: negative array size
----

=== Examples

[source,ruby]
----
# bad
9.times.map do |i|
  i.to_s
end

# good
Array.new(9) do |i|
  i.to_s
end
----

== Performance/UnfreezeString

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes (Unsafe)
| 0.50
| 1.9
|===

In Ruby 2.3 or later, use unary plus operator to unfreeze a string
literal instead of `String#dup` and `String.new`.
Unary plus operator is faster than `String#dup`.

=== Safety

This cop's autocorrection is unsafe because `String.new` (without operator) is not
exactly the same as `+''`. These differ in encoding. `String.new.encoding` is always
`ASCII-8BIT`. However, `(+'').encoding` is the same as script encoding(e.g. `UTF-8`).
if you expect `ASCII-8BIT` encoding, disable this cop.

=== Examples

[source,ruby]
----
# bad
''.dup
""something"".dup
String.new
String.new('')
String.new('something')

# good
+'something'
+''
----

== Performance/UriDefaultParser

|===
| Enabled by default | Safe | Supports autocorrection | Version Added | Version Changed

| Enabled
| Yes
| Yes
| 0.50
| -
|===

This cop identifies places where `URI::Parser.new`
can be replaced by `URI::DEFAULT_PARSER`.

=== Examples

[source,ruby]
----
# bad
URI::Parser.new

# good
URI::DEFAULT_PARSER
----
",12343,True,3000.232497181857,median
"/*
 * Copyright (c) 2018 Bitshares Foundation, and contributors.
 *
 * The MIT License
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the ""Software""), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED ""AS IS"", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */

#include <vector>
#include <boost/test/unit_test.hpp>


#include <graphene/chain/database.hpp>
#include <graphene/chain/hardfork.hpp>

#include <graphene/chain/balance_object.hpp>
#include <graphene/chain/budget_record_object.hpp>
#include <graphene/chain/committee_member_object.hpp>
#include <graphene/chain/market_object.hpp>
#include <graphene/chain/withdraw_permission_object.hpp>
#include <graphene/chain/witness_object.hpp>
#include <graphene/chain/worker_object.hpp>
#include <graphene/chain/asset_evaluator.hpp>

#include <graphene/utilities/tempdir.hpp>

#include <fc/crypto/digest.hpp>
#include <fc/log/log_message.hpp>

#include ""../common/database_fixture.hpp""

using namespace graphene::chain;
using namespace graphene::chain::test;

BOOST_FIXTURE_TEST_SUITE( bitasset_tests, database_fixture )

/*****
 * @brief helper method to change a backing asset to a new one
 * @param fixture the database_fixture
 * @param signing_key the signer
 * @param asset_id_to_update asset to update
 * @param new_backing_asset_id the new backing asset
 */
void change_backing_asset(database_fixture& fixture, const fc::ecc::private_key& signing_key,
      asset_id_type asset_id_to_update, asset_id_type new_backing_asset_id)
{
   try
   {
      asset_update_bitasset_operation ba_op;
      const asset_object& asset_to_update = asset_id_to_update(fixture.db);
      ba_op.asset_to_update = asset_id_to_update;
      ba_op.issuer = asset_to_update.issuer;
      ba_op.new_options.short_backing_asset = new_backing_asset_id;
      fixture.trx.operations.push_back(ba_op);
      fixture.sign(fixture.trx, signing_key);
      PUSH_TX(fixture.db, fixture.trx, ~0);
      fixture.generate_block();
      fixture.trx.clear();
   }
   catch (fc::exception& ex)
   {
      BOOST_FAIL( ""Exception thrown in chainge_backing_asset. Exception was: "" +
            ex.to_string(fc::log_level(fc::log_level::all)) );
   }
}

/******
 * @brief helper method to turn witness_fed_asset on and off
 * @param fixture the database_fixture
 * @param new_issuer optionally change the issuer
 * @param signing_key signer
 * @param asset_id asset we want to change
 * @param witness_fed true if you want this to be a witness fed asset
 */
void change_asset_options(database_fixture& fixture, const optional<account_id_type>& new_issuer,
      const fc::ecc::private_key& signing_key,
      asset_id_type asset_id, bool witness_fed)
{
   asset_update_operation op;
   const asset_object& obj = asset_id(fixture.db);
   op.asset_to_update = asset_id;
   op.issuer = obj.issuer;
   if (new_issuer)
      op.new_issuer = new_issuer;
   op.new_options = obj.options;
   if (witness_fed)
   {
      op.new_options.flags |= witness_fed_asset;
      op.new_options.flags &= ~committee_fed_asset;
   }
   else
   {
      op.new_options.flags &= ~witness_fed_asset; // we don't care about the committee flag here
   }
   fixture.trx.operations.push_back(op);
   fixture.sign( fixture.trx, signing_key );
   PUSH_TX( fixture.db, fixture.trx, ~0 );
   fixture.generate_block();
   fixture.trx.clear();

}

/*********
 * @brief helper method to create a coin backed by a bitasset
 * @param fixture the database_fixture
 * @param index added to name of the coin
 * @param backing the backing asset
 * @param signing_key the signing key
 */
const graphene::chain::asset_object& create_bitasset_backed(graphene::chain::database_fixture& fixture,
      int index, graphene::chain::asset_id_type backing, const fc::ecc::private_key& signing_key)
{
   // create the coin
   std::string name = ""COIN"" + std::to_string(index + 1) + ""TEST"";
   const graphene::chain::asset_object& obj = fixture.create_bitasset(name);
   asset_id_type asset_id = obj.get_id();
   // adjust the backing asset
   change_backing_asset(fixture, signing_key, asset_id, backing);
   fixture.trx.set_expiration(fixture.db.get_dynamic_global_properties().next_maintenance_time);
   return obj;
}


/*********
 * @brief make sure feeds still work after changing backing asset on a witness-fed asset
 */
BOOST_AUTO_TEST_CASE( reset_backing_asset_on_witness_asset )
{
   ACTORS((nathan));

   /*
       // do a maintenance block
      generate_blocks(db.get_dynamic_global_properties().next_maintenance_time);
      // generate blocks until close to hard fork
      generate_blocks( HARDFORK_CORE_868_890_TIME - fc::hours(1) );
    */

   BOOST_TEST_MESSAGE(""Advance to near hard fork"");
   auto maint_interval = db.get_global_properties().parameters.maintenance_interval;
   generate_blocks( HARDFORK_CORE_868_890_TIME - maint_interval);
   trx.set_expiration(HARDFORK_CORE_868_890_TIME - fc::seconds(1));

   BOOST_TEST_MESSAGE(""Create USDBIT"");
   asset_id_type bit_usd_id = create_bitasset(""USDBIT"").id;
   asset_id_type core_id = bit_usd_id(db).bitasset_data(db).options.short_backing_asset;

   {
      BOOST_TEST_MESSAGE(""Update the USDBIT asset options"");
      change_asset_options(*this, nathan_id, nathan_private_key, bit_usd_id, false );
   }

   BOOST_TEST_MESSAGE(""Create JMJBIT based on USDBIT."");
   asset_id_type bit_jmj_id = create_bitasset(""JMJBIT"").id;
   {
      BOOST_TEST_MESSAGE(""Update the JMJBIT asset options"");
      change_asset_options(*this, nathan_id, nathan_private_key, bit_jmj_id, true );
   }

   {
      BOOST_TEST_MESSAGE(""Update the JMJBIT bitasset options"");
      asset_update_bitasset_operation ba_op;
      const asset_object& obj = bit_jmj_id(db);
      ba_op.asset_to_update = obj.get_id();
      ba_op.issuer = obj.issuer;
      ba_op.new_options.short_backing_asset = bit_usd_id;
      ba_op.new_options.minimum_feeds = 1;
      trx.operations.push_back(ba_op);
      sign(trx, nathan_private_key);
      PUSH_TX(db, trx, ~0);
      generate_block();
      trx.clear();
   }

   BOOST_TEST_MESSAGE(""Grab active witnesses"");
   auto& global_props = db.get_global_properties();
   std::vector<account_id_type> active_witnesses;
   for(const witness_id_type& wit_id : global_props.active_witnesses)
      active_witnesses.push_back(wit_id(db).witness_account);
   BOOST_REQUIRE_EQUAL(active_witnesses.size(), INITIAL_WITNESS_COUNT);

   {
      BOOST_TEST_MESSAGE(""Adding price feed 1"");
      publish_feed(active_witnesses[0], bit_usd_id, 1, bit_jmj_id, 300, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 300.0);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);
   }
   {
      BOOST_TEST_MESSAGE(""Adding price feed 2"");
      publish_feed(active_witnesses[1], bit_usd_id, 1, bit_jmj_id, 100, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 300.0);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);
   }
   {
      BOOST_TEST_MESSAGE(""Adding price feed 3"");
      publish_feed(active_witnesses[2], bit_usd_id, 1, bit_jmj_id, 1, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 100.0);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);
   }
   {
      BOOST_TEST_MESSAGE(""Change underlying asset of bit_jmj from bit_usd to core"");
      change_backing_asset(*this, nathan_private_key, bit_jmj_id, core_id);

      BOOST_TEST_MESSAGE(""Verify feed producers have not been reset"");
      const asset_bitasset_data_object& jmj_obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(jmj_obj.feeds.size(), 3ul);
   }
   {
      BOOST_TEST_MESSAGE(""With underlying bitasset changed from one to another, price feeds should still be publish-able"");
      BOOST_TEST_MESSAGE(""Re-Adding Witness 1 price feed"");
      publish_feed(active_witnesses[0], core_id, 1, bit_jmj_id, 30, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 1);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);

      BOOST_CHECK(bitasset.current_feed.core_exchange_rate.base.asset_id != bitasset.current_feed.core_exchange_rate.quote.asset_id);
   }
   {
      BOOST_TEST_MESSAGE(""Re-Adding Witness 2 price feed"");
      publish_feed(active_witnesses[1], core_id, 1, bit_jmj_id, 100, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 100);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);
   }
   {
      BOOST_TEST_MESSAGE(""Advance to after hard fork"");
      generate_blocks( HARDFORK_CORE_868_890_TIME + fc::seconds(1));
      trx.set_expiration(HARDFORK_CORE_868_890_TIME + fc::hours(2));

      BOOST_TEST_MESSAGE(""After hardfork, 1 feed should have been erased"");
      const asset_bitasset_data_object& jmj_obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(jmj_obj.feeds.size(), 2ul);
   }
   {
      BOOST_TEST_MESSAGE(""After hardfork, change underlying asset of bit_jmj from core to bit_usd"");
      change_backing_asset(*this, nathan_private_key, bit_jmj_id, bit_usd_id);

      BOOST_TEST_MESSAGE(""Verify feed producers have been reset"");
      const asset_bitasset_data_object& jmj_obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(jmj_obj.feeds.size(), 0ul);
   }
   {
      BOOST_TEST_MESSAGE(""With underlying bitasset changed from one to another, price feeds should still be publish-able"");
      BOOST_TEST_MESSAGE(""Re-Adding Witness 1 price feed"");
      publish_feed(active_witnesses[0], bit_usd_id, 1, bit_jmj_id, 30, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 30);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);

      BOOST_CHECK(bitasset.current_feed.core_exchange_rate.base.asset_id != bitasset.current_feed.core_exchange_rate.quote.asset_id);
   }
}

/****
 * @brief make sure feeds work correctly after changing the backing asset on a non-witness-fed asset
 */
BOOST_AUTO_TEST_CASE( reset_backing_asset_on_non_witness_asset )
{
   ACTORS((nathan)(dan)(ben)(vikram));

   BOOST_TEST_MESSAGE(""Advance to near hard fork"");
   auto maint_interval = db.get_global_properties().parameters.maintenance_interval;
   generate_blocks( HARDFORK_CORE_868_890_TIME - maint_interval);
   trx.set_expiration(HARDFORK_CORE_868_890_TIME - fc::seconds(1));


   BOOST_TEST_MESSAGE(""Create USDBIT"");
   asset_id_type bit_usd_id = create_bitasset(""USDBIT"").id;
   asset_id_type core_id = bit_usd_id(db).bitasset_data(db).options.short_backing_asset;

   {
      BOOST_TEST_MESSAGE(""Update the USDBIT asset options"");
      change_asset_options(*this, nathan_id, nathan_private_key, bit_usd_id, false );
   }

   BOOST_TEST_MESSAGE(""Create JMJBIT based on USDBIT."");
   asset_id_type bit_jmj_id = create_bitasset(""JMJBIT"").id;
   {
      BOOST_TEST_MESSAGE(""Update the JMJBIT asset options"");
      change_asset_options(*this, nathan_id, nathan_private_key, bit_jmj_id, false );
   }
   {
      BOOST_TEST_MESSAGE(""Update the JMJBIT bitasset options"");
      asset_update_bitasset_operation ba_op;
      const asset_object& obj = bit_jmj_id(db);
      ba_op.asset_to_update = obj.get_id();
      ba_op.issuer = obj.issuer;
      ba_op.new_options.short_backing_asset = bit_usd_id;
      ba_op.new_options.minimum_feeds = 1;
      trx.operations.push_back(ba_op);
      sign(trx, nathan_private_key);
      PUSH_TX(db, trx, ~0);
      generate_block();
      trx.clear();
   }
   {
      BOOST_TEST_MESSAGE(""Set feed producers for JMJBIT"");
      asset_update_feed_producers_operation op;
      op.asset_to_update = bit_jmj_id;
      op.issuer = nathan_id;
      op.new_feed_producers = {dan_id, ben_id, vikram_id};
      trx.operations.push_back(op);
      sign( trx, nathan_private_key );
      PUSH_TX( db, trx, ~0 );
      generate_block();
      trx.clear();
   }

   {
      BOOST_TEST_MESSAGE(""Verify feed producers are registered for JMJBIT"");
      const asset_bitasset_data_object& obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(obj.feeds.size(), 3ul);
      BOOST_CHECK(obj.current_feed == price_feed());

      BOOST_CHECK( bit_usd_id == obj.options.short_backing_asset );
   }
   {
      BOOST_TEST_MESSAGE(""Adding Vikram's price feed"");
      publish_feed(vikram_id, bit_usd_id, 1, bit_jmj_id, 300, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 300.0);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);
   }
   {
      BOOST_TEST_MESSAGE(""Adding Ben's pricing to JMJBIT"");
      publish_feed(ben_id, bit_usd_id, 1, bit_jmj_id, 100, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 300);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);
   }
   {
      BOOST_TEST_MESSAGE(""Adding Dan's pricing to JMJBIT"");
      publish_feed(dan_id, bit_usd_id, 1, bit_jmj_id, 1, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 100);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);
      generate_block();
      trx.clear();

      BOOST_CHECK(bitasset.current_feed.core_exchange_rate.base.asset_id != bitasset.current_feed.core_exchange_rate.quote.asset_id);
   }
   {
      BOOST_TEST_MESSAGE(""Change underlying asset of bit_jmj from bit_usd to core"");
      change_backing_asset(*this, nathan_private_key, bit_jmj_id, core_id);

      BOOST_TEST_MESSAGE(""Verify feed producers have not been reset"");
      const asset_bitasset_data_object& jmj_obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(jmj_obj.feeds.size(), 3ul);
      for(const auto& feed : jmj_obj.feeds) {
         BOOST_CHECK(!feed.second.second.settlement_price.is_null());
      }
   }
   {
      BOOST_TEST_MESSAGE(""Add a new (and correct) feed price for 1 feed producer"");
      publish_feed(vikram_id, core_id, 1, bit_jmj_id, 300, core_id);
   }
   {
      BOOST_TEST_MESSAGE(""Advance to past hard fork"");
      generate_blocks( HARDFORK_CORE_868_890_TIME + maint_interval);
      trx.set_expiration(HARDFORK_CORE_868_890_TIME + fc::hours(48));

      BOOST_TEST_MESSAGE(""Verify that the incorrect feeds have been corrected"");
      const asset_bitasset_data_object& jmj_obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(jmj_obj.feeds.size(), 3ul);
      int nan_count = 0;
      for(const auto& feed : jmj_obj.feeds)
      {
         if (feed.second.second.settlement_price.is_null())
            nan_count++;
      }
      BOOST_CHECK_EQUAL(nan_count, 2);
      // the settlement price will be NaN until 50% of price feeds are valid
      //BOOST_CHECK_EQUAL(jmj_obj.current_feed.settlement_price.to_real(), 300);
   }
   {
      BOOST_TEST_MESSAGE(""After hardfork, change underlying asset of bit_jmj from core to bit_usd"");
      change_backing_asset(*this, nathan_private_key, bit_jmj_id, bit_usd_id);

      BOOST_TEST_MESSAGE(""Verify feed producers have been reset"");
      const asset_bitasset_data_object& jmj_obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(jmj_obj.feeds.size(), 3ul);
      for(const auto& feed : jmj_obj.feeds)
      {
         BOOST_CHECK(feed.second.second.settlement_price.is_null());
      }
   }
   {
      BOOST_TEST_MESSAGE(""With underlying bitasset changed from one to another, price feeds should still be publish-able"");
      BOOST_TEST_MESSAGE(""Adding Vikram's price feed"");
      publish_feed(vikram_id, bit_usd_id, 1, bit_jmj_id, 30, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 30);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);

      BOOST_TEST_MESSAGE(""Adding Ben's pricing to JMJBIT"");
      publish_feed(ben_id, bit_usd_id, 1, bit_jmj_id, 25, core_id);

      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 30);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);

      BOOST_TEST_MESSAGE(""Adding Dan's pricing to JMJBIT"");
      publish_feed(dan_id, bit_usd_id, 1, bit_jmj_id, 10, core_id);

      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 25);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);
      generate_block();
      trx.clear();

      BOOST_CHECK(bitasset.current_feed.core_exchange_rate.base.asset_id != bitasset.current_feed.core_exchange_rate.quote.asset_id);
   }
}

/*********
 * @brief Update median feeds after feed_lifetime_sec changed
 */
BOOST_AUTO_TEST_CASE( hf_890_test )
{
   uint32_t skip = database::skip_witness_signature
                 | database::skip_transaction_signatures
                 | database::skip_transaction_dupe_check
                 | database::skip_block_size_check
                 | database::skip_tapos_check
                 | database::skip_merkle_check
                 ;
   generate_blocks(HARDFORK_615_TIME, true, skip); // get around Graphene issue #615 feed expiration bug
   generate_blocks(db.get_dynamic_global_properties().next_maintenance_time, true, skip);

   auto hf_time = HARDFORK_CORE_868_890_TIME;
   if(hf1270)
      hf_time = HARDFORK_CORE_1270_TIME;

   for( int i=0; i<2; ++i )
   {
      int blocks = 0;
      auto mi = db.get_global_properties().parameters.maintenance_interval;

      if( i == 1 ) // go beyond hard fork
      {
         blocks += generate_blocks(hf_time - mi, true, skip);
         blocks += generate_blocks(db.get_dynamic_global_properties().next_maintenance_time, true, skip);
      }
      set_expiration( db, trx );

      ACTORS((buyer)(seller)(borrower)(feedproducer));

      int64_t init_balance(1000000);

      transfer(committee_account, buyer_id, asset(init_balance));
      transfer(committee_account, borrower_id, asset(init_balance));

      const auto& bitusd = create_bitasset(""USDBIT"", feedproducer_id);
      asset_id_type usd_id = bitusd.id;

      {
         // change feed lifetime
         const asset_object& asset_to_update = usd_id(db);
         asset_update_bitasset_operation ba_op;
         ba_op.asset_to_update = usd_id;
         ba_op.issuer = asset_to_update.issuer;
         ba_op.new_options = asset_to_update.bitasset_data(db).options;
         ba_op.new_options.feed_lifetime_sec = 600;
         trx.operations.push_back(ba_op);
         PUSH_TX(db, trx, ~0);
         trx.clear();
      }

      // prepare feed data
      price_feed current_feed;
      current_feed.maintenance_collateral_ratio = 1750;
      current_feed.maximum_short_squeeze_ratio = 1100;

      // set price feed
      update_feed_producers( usd_id(db), {feedproducer_id} );
      current_feed.settlement_price = asset(100, usd_id) / asset(5);
      publish_feed( usd_id, feedproducer_id, current_feed );

      // Place some collateralized orders
      // start out with 300% collateral, call price is 15/175 CORE/USD = 60/700
      borrow( borrower_id, asset(100, usd_id), asset(15) );

      transfer( borrower_id, seller_id, asset(100, usd_id) );

      // Adjust price feed to get call order into margin call territory
      current_feed.settlement_price = asset(100, usd_id) / asset(10);
      publish_feed( usd_id, feedproducer_id, current_feed );
      // settlement price = 100 USD / 10 CORE, mssp = 100/11 USD/CORE

      // let the feed expire
      blocks += generate_blocks( db.head_block_time() + 1200, true, skip );
      set_expiration( db, trx );

      // check: median feed should be null
      BOOST_CHECK( usd_id(db).bitasset_data(db).current_feed.settlement_price.is_null() );

      // place a sell order, it won't be matched with the call order
      limit_order_id_type sell_id = create_sell_order(seller_id, asset(10, usd_id), asset(1))->id;

      {
         // change feed lifetime to longer
         const asset_object& asset_to_update = usd_id(db);
         asset_update_bitasset_operation ba_op;
         ba_op.asset_to_update = usd_id;
         ba_op.issuer = asset_to_update.issuer;
         ba_op.new_options = asset_to_update.bitasset_data(db).options;
         ba_op.new_options.feed_lifetime_sec = hf_time.sec_since_epoch()
                                             - db.head_block_time().sec_since_epoch()
                                             + mi
                                             + 1800;
         trx.operations.push_back(ba_op);
         PUSH_TX(db, trx, ~0);
         trx.clear();
      }

      // check
      if( i == 0 ) // before hard fork, median feed is still null, and limit order is still there
      {
         BOOST_CHECK( usd_id(db).bitasset_data(db).current_feed.settlement_price.is_null() );
         BOOST_CHECK( db.find<limit_order_object>( sell_id ) );

         // go beyond hard fork
         blocks += generate_blocks(hf_time - mi, true, skip);
         blocks += generate_blocks(db.get_dynamic_global_properties().next_maintenance_time, true, skip);
      }

      // after hard fork, median feed should become valid, and the limit order should be filled
      {
         BOOST_CHECK( usd_id(db).bitasset_data(db).current_feed.settlement_price == current_feed.settlement_price );
         BOOST_CHECK( !db.find<limit_order_object>( sell_id ) );
      }

      // undo above tx's and reset
      generate_block( skip );
      ++blocks;
      while( blocks > 0 )
      {
         db.pop_block();
         --blocks;
      }
   }
}

class bitasset_evaluator_wrapper : public asset_update_bitasset_evaluator
{
public:
   void set_db(database& db)
   {
      this->trx_state = new transaction_evaluation_state(&db);
   }
};

struct assets_922_931
{
   asset_id_type bit_usd;
   asset_id_type bit_usdbacked;
   asset_id_type bit_usdbacked2;
   asset_id_type bit_child_bitasset;
   asset_id_type bit_parent;
   asset_id_type user_issued;
   asset_id_type six_precision;
   asset_id_type prediction;
};

assets_922_931 create_assets_922_931(database_fixture* fixture)
{
   assets_922_931 asset_objs;
   BOOST_TEST_MESSAGE( ""Create USDBIT"" );
   asset_objs.bit_usd = fixture->create_bitasset( ""USDBIT"", GRAPHENE_COMMITTEE_ACCOUNT ).get_id();

   BOOST_TEST_MESSAGE( ""Create USDBACKED"" );
   asset_objs.bit_usdbacked = fixture->create_bitasset( ""USDBACKED"", GRAPHENE_COMMITTEE_ACCOUNT,
         100, charge_market_fee, 2, asset_objs.bit_usd ).get_id();

   BOOST_TEST_MESSAGE( ""Create USDBACKEDII"" );
   asset_objs.bit_usdbacked2 = fixture->create_bitasset( ""USDBACKEDII"", GRAPHENE_WITNESS_ACCOUNT,
         100, charge_market_fee, 2, asset_objs.bit_usd ).get_id();

   BOOST_TEST_MESSAGE( ""Create PARENT"" );
   asset_objs.bit_parent = fixture->create_bitasset( ""PARENT"", GRAPHENE_WITNESS_ACCOUNT).get_id();

   BOOST_TEST_MESSAGE( ""Create CHILDUSER"" );
   asset_objs.bit_child_bitasset = fixture->create_bitasset( ""CHILDUSER"", GRAPHENE_WITNESS_ACCOUNT,
         100, charge_market_fee, 2, asset_objs.bit_parent ).get_id();

   BOOST_TEST_MESSAGE( ""Create user issued USERISSUED"" );
   asset_objs.user_issued = fixture->create_user_issued_asset( ""USERISSUED"",
         GRAPHENE_WITNESS_ACCOUNT(fixture->db), charge_market_fee ).get_id();

   BOOST_TEST_MESSAGE( ""Create a user-issued asset with a precision of 6"" );
   asset_objs.six_precision = fixture->create_user_issued_asset( ""SIXPRECISION"", GRAPHENE_WITNESS_ACCOUNT(fixture->db),
         charge_market_fee, price(asset(1, asset_id_type(1)), asset(1)), 6 ).get_id();

   BOOST_TEST_MESSAGE( ""Create Prediction market with precision of 6, backed by SIXPRECISION"" );
   asset_objs.prediction = fixture->create_prediction_market( ""PREDICTION"", GRAPHENE_WITNESS_ACCOUNT,
         100, charge_market_fee, 6, asset_objs.six_precision ).get_id();

   return asset_objs;
}
/******
 * @brief Test various bitasset asserts within the asset_evaluator before the HF 922 / 931
 */
BOOST_AUTO_TEST_CASE( bitasset_evaluator_test_before_922_931 )
{
   BOOST_TEST_MESSAGE(""Advance to near hard fork 922 / 931"");
   auto global_params = db.get_global_properties().parameters;
   generate_blocks( HARDFORK_CORE_922_931_TIME - global_params.maintenance_interval );
   trx.set_expiration( HARDFORK_CORE_922_931_TIME - global_params.maintenance_interval + global_params.maximum_time_until_expiration );

   ACTORS( (nathan) (john) );

   assets_922_931 asset_objs = create_assets_922_931( this );
   const asset_id_type bit_usd_id = asset_objs.bit_usd;

   // make a generic operation
   bitasset_evaluator_wrapper evaluator;
   evaluator.set_db(db);
   asset_update_bitasset_operation op;
   op.asset_to_update = bit_usd_id;
   op.issuer = asset_objs.bit_usd(db).issuer;
   op.new_options = asset_objs.bit_usd(db).bitasset_data(db).options;

   // this should pass
   BOOST_TEST_MESSAGE( ""Evaluating a good operation"" );
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );

   // test with a market issued asset
   BOOST_TEST_MESSAGE( ""Sending a non-bitasset."" );
   op.asset_to_update = asset_objs.user_issued;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""on a non-BitAsset."" );
   op.asset_to_update = bit_usd_id;

   // test changing issuer
   BOOST_TEST_MESSAGE( ""Test changing issuer."" );
   account_id_type original_issuer = op.issuer;
   op.issuer = john_id;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""Only asset issuer can update"" );
   op.issuer = original_issuer;

   // bad backing_asset
   BOOST_TEST_MESSAGE( ""Non-existent backing asset."" );
   asset_id_type correct_asset_id = op.new_options.short_backing_asset;
   op.new_options.short_backing_asset = asset_id_type();
   op.new_options.short_backing_asset.instance = 123;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""Unable to find Object"" );
   op.new_options.short_backing_asset = correct_asset_id;

   // now check the things that are wrong, but still pass before HF 922 / 931
   BOOST_TEST_MESSAGE( ""Now check the things that are wrong, but still pass before HF 922 / 931"" );

   // back by self
   BOOST_TEST_MESSAGE( ""Message should contain: op.new_options.short_backing_asset == asset_obj.get_id()"" );
   op.new_options.short_backing_asset = bit_usd_id;
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   op.new_options.short_backing_asset = correct_asset_id;

   // prediction market with different precision
   BOOST_TEST_MESSAGE( ""Message should contain: for a PM, asset_obj.precision != new_backing_asset.precision"" );
   op.asset_to_update = asset_objs.prediction;
   op.issuer = asset_objs.prediction(db).issuer;
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   op.asset_to_update = bit_usd_id;
   op.issuer = asset_objs.bit_usd(db).issuer;

   // checking old backing asset instead of new backing asset
   BOOST_TEST_MESSAGE( ""Message should contain: to be backed by an asset which is not market issued asset nor CORE"" );
   op.new_options.short_backing_asset = asset_objs.six_precision;
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   BOOST_TEST_MESSAGE( ""Message should contain: modified a blockchain-controlled market asset to be backed by an asset ""
         ""which is not backed by CORE"" );
   op.new_options.short_backing_asset = asset_objs.prediction;
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   op.new_options.short_backing_asset = correct_asset_id;

   // CHILDUSER is a non-committee asset backed by PARENT which is backed by CORE
   // Cannot change PARENT's backing asset from CORE to something that is not [CORE | UIA]
   // because that will make CHILD be backed by an asset that is not itself backed by CORE or a UIA.
   BOOST_TEST_MESSAGE( ""Message should contain: but this asset is a backing asset for another MPA, which would cause MPA ""
         ""backed by MPA backed by MPA."" );
   op.asset_to_update = asset_objs.bit_parent;
   op.issuer = asset_objs.bit_parent(db).issuer;
   op.new_options.short_backing_asset = asset_objs.bit_usdbacked;
   // this should generate a warning in the log, but not fail.
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   // changing the backing asset to a UIA should work
   BOOST_TEST_MESSAGE( ""Switching to a backing asset that is a UIA should work. No warning should be produced."" );
   op.new_options.short_backing_asset = asset_objs.user_issued;
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   // A -> B -> C, change B to be backed by A (circular backing)
   BOOST_TEST_MESSAGE( ""Message should contain: A cannot be backed by B which is backed by A."" );
   op.new_options.short_backing_asset = asset_objs.bit_child_bitasset;
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   op.new_options.short_backing_asset = asset_objs.user_issued;
   BOOST_TEST_MESSAGE( ""Message should contain: but this asset is a backing asset for a committee-issued asset."" );
   // CHILDCOMMITTEE is a committee asset backed by PARENT which is backed by CORE
   // Cannot change PARENT's backing asset from CORE to something else because that will make CHILD be backed by
   // an asset that is not itself backed by CORE
   create_bitasset( ""CHILDCOMMITTEE"", GRAPHENE_COMMITTEE_ACCOUNT, 100, charge_market_fee, 2,
         asset_objs.bit_parent );
   // it should again work, generating 2 warnings in the log. 1 for the above, and 1 new one.
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   op.asset_to_update = asset_objs.bit_usd;
   op.issuer = asset_objs.bit_usd(db).issuer;
   op.new_options.short_backing_asset = correct_asset_id;

   // USDBACKED is backed by USDBIT (which is backed by CORE)
   // USDBACKEDII is backed by USDBIT
   // We should not be able to make USDBACKEDII be backed by USDBACKED
   // because that would be a MPA backed by MPA backed by MPA.
   BOOST_TEST_MESSAGE( ""Message should contain: a BitAsset cannot be backed by a BitAsset that ""
         ""itself is backed by a BitAsset."" );
   op.asset_to_update = asset_objs.bit_usdbacked2;
   op.issuer = asset_objs.bit_usdbacked2(db).issuer;
   op.new_options.short_backing_asset = asset_objs.bit_usdbacked;
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   // set everything to a more normal state
   op.asset_to_update = asset_objs.bit_usdbacked;
   op.issuer = asset_objs.bit_usd(db).issuer;
   op.new_options.short_backing_asset = asset_id_type();

   // Feed lifetime must exceed block interval
   BOOST_TEST_MESSAGE( ""Message should contain: op.new_options.feed_lifetime_sec <= chain_parameters.block_interval"" );
   const auto good_feed_lifetime = op.new_options.feed_lifetime_sec;
   op.new_options.feed_lifetime_sec = db.get_global_properties().parameters.block_interval;
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   BOOST_TEST_MESSAGE( ""Message should contain: op.new_options.feed_lifetime_sec <= chain_parameters.block_interval"" );
   op.new_options.feed_lifetime_sec = db.get_global_properties().parameters.block_interval - 1; // default interval > 1
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   op.new_options.feed_lifetime_sec = good_feed_lifetime;

   // Force settlement delay must exceed block interval.
   BOOST_TEST_MESSAGE( ""Message should contain: op.new_options.force_settlement_delay_sec <= chain_parameters.block_interval"" );
   const auto good_force_settlement_delay_sec = op.new_options.force_settlement_delay_sec;
   op.new_options.force_settlement_delay_sec = db.get_global_properties().parameters.block_interval;
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   BOOST_TEST_MESSAGE( ""Message should contain: op.new_options.force_settlement_delay_sec <= chain_parameters.block_interval"" );
   op.new_options.force_settlement_delay_sec = db.get_global_properties().parameters.block_interval - 1; // default interval > 1
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   op.new_options.force_settlement_delay_sec = good_force_settlement_delay_sec;

   // this should pass
   BOOST_TEST_MESSAGE( ""We should be all good again."" );
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
}

/******
 * @brief Test various bitasset asserts within the asset_evaluator before the HF 922 / 931
 */
BOOST_AUTO_TEST_CASE( bitasset_evaluator_test_after_922_931 )
{
   BOOST_TEST_MESSAGE(""Advance to after hard fork 922 / 931"");
   auto global_params = db.get_global_properties().parameters;
   generate_blocks( HARDFORK_CORE_922_931_TIME + global_params.maintenance_interval );
   trx.set_expiration( HARDFORK_CORE_922_931_TIME + global_params.maintenance_interval + global_params.maximum_time_until_expiration );

   ACTORS( (nathan) (john) );

   assets_922_931 asset_objs = create_assets_922_931( this );
   const asset_id_type& bit_usd_id = asset_objs.bit_usd;

   // make a generic operation
   bitasset_evaluator_wrapper evaluator;
   evaluator.set_db( db );
   asset_update_bitasset_operation op;
   op.asset_to_update = bit_usd_id;
   op.issuer = asset_objs.bit_usd(db).issuer;
   op.new_options = asset_objs.bit_usd(db).bitasset_data(db).options;

   // this should pass
   BOOST_TEST_MESSAGE( ""Evaluating a good operation"" );
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );

   // test with a market issued asset
   BOOST_TEST_MESSAGE( ""Sending a non-bitasset."" );
   op.asset_to_update = asset_objs.user_issued;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""Cannot update BitAsset-specific settings on a non-BitAsset"" );
   op.asset_to_update = bit_usd_id;

   // test changing issuer
   BOOST_TEST_MESSAGE( ""Test changing issuer."" );
   account_id_type original_issuer = op.issuer;
   op.issuer = john_id;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""Only asset issuer can update"" );
   op.issuer = original_issuer;

   // bad backing_asset
   BOOST_TEST_MESSAGE( ""Non-existent backing asset."" );
   asset_id_type correct_asset_id = op.new_options.short_backing_asset;
   op.new_options.short_backing_asset = asset_id_type();
   op.new_options.short_backing_asset.instance = 123;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""Unable to find"" );
   op.new_options.short_backing_asset = correct_asset_id;

   // now check the things that are wrong and won't pass after HF 922 / 931
   BOOST_TEST_MESSAGE( ""Now check the things that are wrong and won't pass after HF 922 / 931"" );

   // back by self
   BOOST_TEST_MESSAGE( ""Back by itself"" );
   op.new_options.short_backing_asset = bit_usd_id;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""Cannot update an asset to be backed by itself"" );
   op.new_options.short_backing_asset = correct_asset_id;

   // prediction market with different precision
   BOOST_TEST_MESSAGE( ""Prediction market with different precision"" );
   op.asset_to_update = asset_objs.prediction;
   op.issuer = asset_objs.prediction(db).issuer;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""The precision of the asset and backing asset must"" );
   op.asset_to_update = bit_usd_id;
   op.issuer = asset_objs.bit_usd(db).issuer;

   // checking old backing asset instead of new backing asset
   BOOST_TEST_MESSAGE( ""Correctly checking new backing asset rather than old backing asset"" );
   op.new_options.short_backing_asset = asset_objs.six_precision;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""which is not market issued asset nor CORE."" );
   op.new_options.short_backing_asset = asset_objs.prediction;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""which is not backed by CORE"" );
   op.new_options.short_backing_asset = correct_asset_id;

   // CHILD is a non-committee asset backed by PARENT which is backed by CORE
   // Cannot change PARENT's backing asset from CORE to something that is not [CORE | UIA]
   // because that will make CHILD be backed by an asset that is not itself backed by CORE or a UIA.
   BOOST_TEST_MESSAGE( ""Attempting to change PARENT to be backed by a non-core and non-user-issued asset"" );
   op.asset_to_update = asset_objs.bit_parent;
   op.issuer = asset_objs.bit_parent(db).issuer;
   op.new_options.short_backing_asset = asset_objs.bit_usdbacked;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""A non-blockchain controlled BitAsset would be invalidated"" );
   // changing the backing asset to a UIA should work
   BOOST_TEST_MESSAGE( ""Switching to a backing asset that is a UIA should work."" );
   op.new_options.short_backing_asset = asset_objs.user_issued;
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   // A -> B -> C, change B to be backed by A (circular backing)
   BOOST_TEST_MESSAGE( ""Check for circular backing. This should generate an exception"" );
   op.new_options.short_backing_asset = asset_objs.bit_child_bitasset;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""'A' backed by 'B' backed by 'A'"" );
   op.new_options.short_backing_asset = asset_objs.user_issued;
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );
   BOOST_TEST_MESSAGE( ""Creating CHILDCOMMITTEE"" );
   // CHILDCOMMITTEE is a committee asset backed by PARENT which is backed by CORE
   // Cannot change PARENT's backing asset from CORE to something else because that will make CHILDCOMMITTEE
   // be backed by an asset that is not itself backed by CORE
   create_bitasset( ""CHILDCOMMITTEE"", GRAPHENE_COMMITTEE_ACCOUNT, 100, charge_market_fee, 2,
         asset_objs.bit_parent );
   // it should again not work
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""A blockchain-controlled market asset would be invalidated"" );
   op.asset_to_update = asset_objs.bit_usd;
   op.issuer = asset_objs.bit_usd(db).issuer;
   op.new_options.short_backing_asset = correct_asset_id;

   // USDBACKED is backed by USDBIT (which is backed by CORE)
   // USDBACKEDII is backed by USDBIT
   // We should not be able to make USDBACKEDII be backed by USDBACKED
   // because that would be a MPA backed by MPA backed by MPA.
   BOOST_TEST_MESSAGE( ""MPA -> MPA -> MPA not allowed"" );
   op.asset_to_update = asset_objs.bit_usdbacked2;
   op.issuer = asset_objs.bit_usdbacked2(db).issuer;
   op.new_options.short_backing_asset = asset_objs.bit_usdbacked;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op),
         ""A BitAsset cannot be backed by a BitAsset that itself is backed by a BitAsset"" );
   // set everything to a more normal state
   op.asset_to_update = asset_objs.bit_usdbacked;
   op.issuer = asset_objs.bit_usd(db).issuer;
   op.new_options.short_backing_asset = asset_id_type();

   // Feed lifetime must exceed block interval
   BOOST_TEST_MESSAGE( ""Feed lifetime less than or equal to block interval"" );
   const auto good_feed_lifetime = op.new_options.feed_lifetime_sec;
   op.new_options.feed_lifetime_sec = db.get_global_properties().parameters.block_interval;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""Feed lifetime must exceed block"" );
   op.new_options.feed_lifetime_sec = db.get_global_properties().parameters.block_interval - 1; // default interval > 1
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""Feed lifetime must exceed block"" );
   op.new_options.feed_lifetime_sec = good_feed_lifetime;

   // Force settlement delay must exceed block interval.
   BOOST_TEST_MESSAGE( ""Force settlement delay less than or equal to block interval"" );
   const auto good_force_settlement_delay_sec = op.new_options.force_settlement_delay_sec;
   op.new_options.force_settlement_delay_sec = db.get_global_properties().parameters.block_interval;
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""Force settlement delay must"" );
   op.new_options.force_settlement_delay_sec = db.get_global_properties().parameters.block_interval - 1; // default interval > 1
   REQUIRE_EXCEPTION_WITH_TEXT( evaluator.evaluate(op), ""Force settlement delay must"" );
   op.new_options.force_settlement_delay_sec = good_force_settlement_delay_sec;

   // this should pass
   BOOST_TEST_MESSAGE( ""We should be all good again."" );
   BOOST_CHECK( evaluator.evaluate(op) == void_result() );

}

/*********
 * @brief Call check_call_orders after current_feed changed but not only settlement_price changed.
 */
BOOST_AUTO_TEST_CASE( hf_935_test )
{ try {
   uint32_t skip = database::skip_witness_signature
                 | database::skip_transaction_signatures
                 | database::skip_transaction_dupe_check
                 | database::skip_block_size_check
                 | database::skip_tapos_check
                 | database::skip_merkle_check
                 ;
   generate_blocks( HARDFORK_615_TIME, true, skip ); // get around Graphene issue #615 feed expiration bug
   generate_blocks( db.get_dynamic_global_properties().next_maintenance_time, true, skip );
   generate_block( skip );

   for( int i = 0; i < 8; ++i )
   {
      idump( (i) );
      int blocks = 0;
      auto mi = db.get_global_properties().parameters.maintenance_interval;

      if( i == 2 ) // go beyond hard fork 890
      {
         generate_blocks( HARDFORK_CORE_868_890_TIME - mi, true, skip );
         generate_blocks( db.get_dynamic_global_properties().next_maintenance_time, true, skip );
      }
      else if( i == 4 ) // go beyond hard fork 935
      {
         generate_blocks( HARDFORK_CORE_935_TIME - mi, true, skip );
         generate_blocks( db.get_dynamic_global_properties().next_maintenance_time, true, skip );
      }
      else if( i == 6 ) // go beyond hard fork 1270
      {
         generate_blocks( HARDFORK_CORE_1270_TIME - mi, true, skip );
         generate_blocks( db.get_dynamic_global_properties().next_maintenance_time, true, skip );
      }
      set_expiration( db, trx );

      ACTORS( (seller)(borrower)(feedproducer)(feedproducer2)(feedproducer3) );

      int64_t init_balance( 1000000 );

      transfer( committee_account, borrower_id, asset(init_balance) );

      const auto& bitusd = create_bitasset( ""USDBIT"", feedproducer_id );
      asset_id_type usd_id = bitusd.id;

      {
         // set a short feed lifetime
         const asset_object& asset_to_update = usd_id(db);
         asset_update_bitasset_operation ba_op;
         ba_op.asset_to_update = usd_id;
         ba_op.issuer = asset_to_update.issuer;
         ba_op.new_options = asset_to_update.bitasset_data(db).options;
         ba_op.new_options.feed_lifetime_sec = 300;
         trx.operations.push_back(ba_op);
         PUSH_TX(db, trx, ~0);
         trx.clear();
      }

      // set feed producers
      flat_set<account_id_type> producers;
      producers.insert( feedproducer_id );
      producers.insert( feedproducer2_id );
      producers.insert( feedproducer3_id );
      update_feed_producers( usd_id(db), producers );

      // prepare feed data
      price_feed current_feed;
      if( i % 2 == 0 ) // MCR test
      {
         current_feed.maintenance_collateral_ratio = 3500;
         current_feed.maximum_short_squeeze_ratio = 1100;
         current_feed.settlement_price = asset(100, usd_id) / asset(5);
      }
      else // MSSR test
      {
         current_feed.maintenance_collateral_ratio = 1750;
         current_feed.maximum_short_squeeze_ratio = 1250;
         current_feed.settlement_price = asset(100, usd_id) / asset(10);
         // mssp = 1000/125
      }

      // set 2 price feeds which should call some later
      publish_feed( usd_id, feedproducer_id, current_feed );
      publish_feed( usd_id, feedproducer2_id, current_feed );

      // check median
      BOOST_CHECK( usd_id(db).bitasset_data(db).current_feed.settlement_price == current_feed.settlement_price );
      if( i % 2 == 0 ) // MCR test, MCR should be 350%
         BOOST_CHECK_EQUAL( usd_id(db).bitasset_data(db).current_feed.maintenance_collateral_ratio, 3500 );
      else // MSSR test, MSSR should be 125%
         BOOST_CHECK_EQUAL( usd_id(db).bitasset_data(db).current_feed.maximum_short_squeeze_ratio, 1250 );

      // generate some blocks, let the feeds expire
      blocks += generate_blocks( db.head_block_time() + 360, true, skip );
      set_expiration( db, trx );

      // check median, should be null
      BOOST_CHECK( usd_id(db).bitasset_data(db).current_feed.settlement_price.is_null() );

      // publish a new feed with 175% MCR and 110% MSSR
      current_feed.settlement_price = asset(100, usd_id) / asset(5);
      current_feed.maintenance_collateral_ratio = 1750;
      current_feed.maximum_short_squeeze_ratio = 1100;
      publish_feed( usd_id, feedproducer3_id, current_feed );

      // check median, MCR would be 175%, MSSR would be 110%
      BOOST_CHECK( usd_id(db).bitasset_data(db).current_feed.settlement_price == current_feed.settlement_price );
      BOOST_CHECK_EQUAL( usd_id(db).bitasset_data(db).current_feed.maintenance_collateral_ratio, 1750 );
      BOOST_CHECK_EQUAL( usd_id(db).bitasset_data(db).current_feed.maximum_short_squeeze_ratio, 1100 );

      // Place some collateralized orders
      // start out with 300% collateral, call price is 15/175 CORE/USD = 60/700
      borrow( borrower_id, asset(100, usd_id), asset(15) );

      transfer( borrower_id, seller_id, asset(100, usd_id) );

      if( i % 2 == 1) // MSSR test
      {
         // publish a new feed to put the call order into margin call territory
         current_feed.settlement_price = asset(100, usd_id) / asset(10);
         current_feed.maintenance_collateral_ratio = 1750;
         current_feed.maximum_short_squeeze_ratio = 1100;
         publish_feed( usd_id, feedproducer3_id, current_feed );
         // mssp = 100/11
      }

      // place a sell order, it won't be matched with the call order now.
      // For MCR test, the sell order is at feed price (100/5),
      //   when median MCR changed to 350%, the call order with 300% collateral will be in margin call territory,
      //   then this limit order should be filled
      // For MSSR test, the sell order is above 110% of feed price (100/10) but below 125% of feed price,
      //   when median MSSR changed to 125%, the call order will be matched,
      //   then this limit order should be filled
      limit_order_id_type sell_id = ( i % 2 == 0 ) ?
                                    create_sell_order( seller_id, asset(20, usd_id), asset(1) )->id : // for MCR test
                                    create_sell_order( seller_id, asset(8, usd_id), asset(1) )->id;  // for MSSR test

      {
         // change feed lifetime to longer, let all 3 feeds be valid
         const asset_object& asset_to_update = usd_id(db);
         asset_update_bitasset_operation ba_op;
         ba_op.asset_to_update = usd_id;
         ba_op.issuer = asset_to_update.issuer;
         ba_op.new_options = asset_to_update.bitasset_data(db).options;
         ba_op.new_options.feed_lifetime_sec = HARDFORK_CORE_1270_TIME.sec_since_epoch()
                                             + mi * 3 + 86400 * 2
                                             - db.head_block_time().sec_since_epoch();
         trx.operations.push_back(ba_op);
         PUSH_TX(db, trx, ~0);
         trx.clear();
      }

      bool affected_by_hf_343 = false;

      // check
      if( i / 2 == 0 ) // before hard fork 890
      {
         // median feed won't change (issue 890)
         BOOST_CHECK( usd_id(db).bitasset_data(db).current_feed.settlement_price == current_feed.settlement_price );
         BOOST_CHECK_EQUAL( usd_id(db).bitasset_data(db).current_feed.maintenance_collateral_ratio, 1750 );
         BOOST_CHECK_EQUAL( usd_id(db).bitasset_data(db).current_feed.maximum_short_squeeze_ratio, 1100 );
         // limit order is still there
         BOOST_CHECK( db.find<limit_order_object>( sell_id ) );

         // go beyond hard fork 890
         blocks += generate_blocks( HARDFORK_CORE_868_890_TIME - mi, true, skip );
         bool was_before_hf_343 = ( db.get_dynamic_global_properties().next_maintenance_time <= HARDFORK_CORE_343_TIME );

         blocks += generate_blocks( db.get_dynamic_global_properties().next_maintenance_time, true, skip );
         bool now_after_hf_343 = ( db.get_dynamic_global_properties().next_maintenance_time > HARDFORK_CORE_343_TIME );

         if( was_before_hf_343 && now_after_hf_343 ) // if hf 343 executed at same maintenance interval, actually after hf 890
            affected_by_hf_343 = true;
      }

      // after hard fork 890, if it's before hard fork 935
      if( db.get_dynamic_global_properties().next_maintenance_time <= HARDFORK_CORE_935_TIME )
      {
         // median should have changed
         BOOST_CHECK( usd_id(db).bitasset_data(db).current_feed.settlement_price == current_feed.settlement_price );
         if( i % 2 == 0 ) // MCR test, MCR should be 350%
            BOOST_CHECK_EQUAL( usd_id(db).bitasset_data(db).current_feed.maintenance_collateral_ratio, 3500 );
         else // MSSR test, MSSR should be 125%
            BOOST_CHECK_EQUAL( usd_id(db).bitasset_data(db).current_feed.maximum_short_squeeze_ratio, 1250 );

         if( affected_by_hf_343 ) // if updated bitasset before hf 890, and hf 343 executed after hf 890
            // the limit order should have been filled
            BOOST_CHECK( !db.find<limit_order_object>( sell_id ) );
         else // if not affected by hf 343
            // the limit order should be still there, because `check_call_order` was incorrectly skipped
            BOOST_CHECK( db.find<limit_order_object>( sell_id ) );

         // go beyond hard fork 935
         blocks += generate_blocks(HARDFORK_CORE_935_TIME - mi, true, skip);
         blocks += generate_blocks(db.get_dynamic_global_properties().next_maintenance_time, true, skip);
      }

      // after hard fork 935, the limit order is filled only for the MSSR test
      if( db.get_dynamic_global_properties().next_maintenance_time > HARDFORK_CORE_935_TIME &&
          db.get_dynamic_global_properties().next_maintenance_time <= HARDFORK_CORE_1270_TIME)
      {
         // check median
         BOOST_CHECK( usd_id(db).bitasset_data(db).current_feed.settlement_price == current_feed.settlement_price );
         if( i % 2 == 0) { // MCR test, median MCR should be 350% and order will not be filled except when i = 0
            BOOST_CHECK_EQUAL(usd_id(db).bitasset_data(db).current_feed.maintenance_collateral_ratio, 3500);
            if( affected_by_hf_343 )
               BOOST_CHECK(!db.find<limit_order_object>(sell_id));
            else
               BOOST_CHECK(db.find<limit_order_object>(sell_id)); // MCR bug, order still there
         }
         else { // MSSR test, MSSR should be 125% and order is filled
            BOOST_CHECK_EQUAL(usd_id(db).bitasset_data(db).current_feed.maximum_short_squeeze_ratio, 1250);
            BOOST_CHECK(!db.find<limit_order_object>(sell_id)); // order filled
         }

         // go beyond hard fork 1270
         blocks += generate_blocks(HARDFORK_CORE_1270_TIME - mi, true, skip);
         blocks += generate_blocks(db.get_dynamic_global_properties().next_maintenance_time, true, skip);
      }

      // after hard fork 1270, the limit order should be filled for MCR test
      if( db.get_dynamic_global_properties().next_maintenance_time > HARDFORK_CORE_1270_TIME)
      {
         // check median
         BOOST_CHECK( usd_id(db).bitasset_data(db).current_feed.settlement_price == current_feed.settlement_price );
         if( i % 2 == 0 ) { // MCR test, order filled
            BOOST_CHECK_EQUAL(usd_id(db).bitasset_data(db).current_feed.maintenance_collateral_ratio, 3500);
            BOOST_CHECK(!db.find<limit_order_object>(sell_id));
         }
      }

      // undo above tx's and reset
      generate_block( skip );
      ++blocks;
      while( blocks > 0 )
      {
         db.pop_block();
         --blocks;
      }
   }
} FC_LOG_AND_RETHROW() }

BOOST_AUTO_TEST_CASE( bitasset_secondary_index )
{
   ACTORS( (nathan) );

   graphene::chain::asset_id_type core_id;
   BOOST_TEST_MESSAGE( ""Running test bitasset_secondary_index"" );
   BOOST_TEST_MESSAGE( ""Core asset id: "" + fc::json::to_pretty_string( core_id ) );
   BOOST_TEST_MESSAGE(""Create coins"");
   try
   {
      // make 5 coins (backed by core)
      for(int i = 0; i < 5; i++)
      {
         create_bitasset_backed(*this, i, core_id, nathan_private_key);
      }
      // make the next 5 (10-14) be backed by COIN1
      graphene::chain::asset_id_type coin1_id = get_asset(""COIN1TEST"").get_id();
      for(int i = 5; i < 10; i++)
      {
         create_bitasset_backed(*this, i, coin1_id, nathan_private_key);
      }
      // make the next 5 (15-19) be backed by COIN2
      graphene::chain::asset_id_type coin2_id = get_asset(""COIN2TEST"").get_id();
      for(int i = 10; i < 15; i++)
      {
         create_bitasset_backed(*this, i, coin2_id, nathan_private_key);
      }
      // make the last 5 be backed by core
      for(int i = 15; i < 20; i++)
      {
         create_bitasset_backed(*this, i, core_id, nathan_private_key);
      }

      BOOST_TEST_MESSAGE(""Searching for all coins backed by CORE"");
      const auto& idx = db.get_index_type<graphene::chain::asset_bitasset_data_index>().indices().get<graphene::chain::by_short_backing_asset>();
      auto core_itr = idx.equal_range( core_id );
      BOOST_TEST_MESSAGE(""Searching for all coins backed by COIN1"");
      auto coin1_itr = idx.equal_range( coin1_id );
      BOOST_TEST_MESSAGE(""Searching for all coins backed by COIN2"");
      auto coin2_itr = idx.equal_range( coin2_id );

      int core_count = 0, coin1_count = 0, coin2_count = 0;

      BOOST_TEST_MESSAGE(""Counting coins in each category"");

      for( auto itr = core_itr.first ; itr != core_itr.second; ++itr)
      {
         BOOST_CHECK(itr->options.short_backing_asset == core_id);
         BOOST_TEST_MESSAGE( fc::json::to_pretty_string(itr->asset_id) + "" is backed by CORE"" );
         core_count++;
      }
      for( auto itr = coin1_itr.first ; itr != coin1_itr.second; ++itr )
      {
         BOOST_CHECK(itr->options.short_backing_asset == coin1_id);
         BOOST_TEST_MESSAGE( fc::json::to_pretty_string( itr->asset_id) + "" is backed by COIN1TEST"" );
         coin1_count++;
      }
      for( auto itr = coin2_itr.first; itr != coin2_itr.second; ++itr )
      {
         BOOST_CHECK(itr->options.short_backing_asset == coin2_id);
         BOOST_TEST_MESSAGE( fc::json::to_pretty_string( itr->asset_id) + "" is backed by COIN2TEST"" );
         coin2_count++;
      }

      BOOST_CHECK( core_count >= 10 );
      BOOST_CHECK_EQUAL( coin1_count, 5 );
      BOOST_CHECK_EQUAL( coin2_count, 5 );
   }
   catch (fc::exception& ex)
   {
      BOOST_FAIL(ex.to_string(fc::log_level(fc::log_level::all)));
   }
}


/*****
 * @brief make sure feeds work correctly after changing from non-witness-fed to witness-fed before the 868 fork
 * NOTE: This test case is a different issue than what is currently being worked on, and fails. Hopefully it
 * will help when the fix for that issue is being coded.
 */
/*
BOOST_AUTO_TEST_CASE( reset_backing_asset_switching_to_witness_fed )
{
   ACTORS((nathan)(dan)(ben)(vikram));

   BOOST_TEST_MESSAGE(""Advance to near hard fork"");
   auto maint_interval = db.get_global_properties().parameters.maintenance_interval;
   generate_blocks( HARDFORK_CORE_868_890_TIME - maint_interval);
   trx.set_expiration(HARDFORK_CORE_868_890_TIME - fc::seconds(1));


   BOOST_TEST_MESSAGE(""Create USDBIT"");
   asset_id_type bit_usd_id = create_bitasset(""USDBIT"").id;
   asset_id_type core_id = bit_usd_id(db).bitasset_data(db).options.short_backing_asset;

   {
      BOOST_TEST_MESSAGE(""Update the USDBIT asset options"");
      change_asset_options(*this, nathan_id, nathan_private_key, bit_usd_id, false );
   }

   BOOST_TEST_MESSAGE(""Create JMJBIT based on USDBIT."");
   asset_id_type bit_jmj_id = create_bitasset(""JMJBIT"").id;
   {
      BOOST_TEST_MESSAGE(""Update the JMJBIT asset options"");
      change_asset_options(*this, nathan_id, nathan_private_key, bit_jmj_id, false );
   }
   {
      BOOST_TEST_MESSAGE(""Update the JMJBIT bitasset options"");
      asset_update_bitasset_operation ba_op;
      const asset_object& obj = bit_jmj_id(db);
      ba_op.asset_to_update = obj.get_id();
      ba_op.issuer = obj.issuer;
      ba_op.new_options.short_backing_asset = bit_usd_id;
      ba_op.new_options.minimum_feeds = 1;
      trx.operations.push_back(ba_op);
      sign(trx, nathan_private_key);
      PUSH_TX(db, trx, ~0);
      generate_block();
      trx.clear();
   }
   {
      BOOST_TEST_MESSAGE(""Set feed producers for JMJBIT"");
      asset_update_feed_producers_operation op;
      op.asset_to_update = bit_jmj_id;
      op.issuer = nathan_id;
      op.new_feed_producers = {dan_id, ben_id, vikram_id};
      trx.operations.push_back(op);
      sign( trx, nathan_private_key );
      PUSH_TX( db, trx, ~0 );
      generate_block();
      trx.clear();
   }
   {
      BOOST_TEST_MESSAGE(""Verify feed producers are registered for JMJBIT"");
      const asset_bitasset_data_object& obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(obj.feeds.size(), 3ul);
      BOOST_CHECK(obj.current_feed == price_feed());


      BOOST_CHECK_EQUAL(""1"", std::to_string(obj.options.short_backing_asset.space_id));
      BOOST_CHECK_EQUAL(""3"", std::to_string(obj.options.short_backing_asset.type_id));
      BOOST_CHECK_EQUAL(""1"", std::to_string(obj.options.short_backing_asset.instance.value));

      BOOST_CHECK_EQUAL(""1"", std::to_string(bit_jmj_id.space_id));
      BOOST_CHECK_EQUAL(""3"", std::to_string(bit_jmj_id.type_id));
      BOOST_CHECK_EQUAL(""2"", std::to_string(bit_jmj_id.instance.value));
   }
   {
      BOOST_TEST_MESSAGE(""Adding Vikram's price feed"");
      add_price_feed(*this, vikram_id, bit_usd_id, 1, bit_jmj_id, 300, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 300.0);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);
   }
   {
      BOOST_TEST_MESSAGE(""Change JMJBIT to be witness_fed"");
      optional<account_id_type> noone;
      change_asset_options(*this, noone, nathan_private_key, bit_jmj_id, true );
   }
   {
      BOOST_TEST_MESSAGE(""Change underlying asset of bit_jmj from bit_usd to core"");
      change_backing_asset(*this, nathan_private_key, bit_jmj_id, core_id);

      BOOST_TEST_MESSAGE(""Verify feed producers have not been reset"");
      const asset_bitasset_data_object& jmj_obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(jmj_obj.feeds.size(), 3ul);
      int nan_count = 0;
      for(const auto& feed : jmj_obj.feeds) {
         if(feed.second.second.settlement_price.is_null())
            ++nan_count;
      }
      BOOST_CHECK_EQUAL(nan_count, 2);
   }
   {
      BOOST_TEST_MESSAGE(""Add a new (and correct) feed price from a witness"");
      auto& global_props = db.get_global_properties();
      std::vector<account_id_type> active_witnesses;
      const witness_id_type& first_witness_id = (*global_props.active_witnesses.begin());
      const account_id_type witness_account_id = first_witness_id(db).witness_account;
      add_price_feed(*this, witness_account_id, core_id, 1, bit_jmj_id, 300, core_id);

      // we should have 2 feeds nan, 1 old feed with wrong asset, and 1 witness feed
      const asset_bitasset_data_object& jmj_obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(jmj_obj.feeds.size(), 4ul);
      int nan_count = 0;
      for(const auto& feed : jmj_obj.feeds) {
         if ( feed.second.second.settlement_price.is_null() )
            ++nan_count;
      }
      BOOST_CHECK_EQUAL(nan_count, 2);
   }
   {
      BOOST_TEST_MESSAGE(""Advance to past hard fork"");
      generate_blocks( HARDFORK_CORE_868_890_TIME + maint_interval);
      trx.set_expiration(HARDFORK_CORE_868_890_TIME + fc::hours(48));

      BOOST_TEST_MESSAGE(""Verify that the incorrect feeds have been removed"");
      const asset_bitasset_data_object& jmj_obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(jmj_obj.feeds.size(), 1ul);
      BOOST_CHECK( ! (*jmj_obj.feeds.begin()).second.second.settlement_price.is_null() );
      // the settlement price will be NaN until 50% of price feeds are valid
      //BOOST_CHECK_EQUAL(jmj_obj.current_feed.settlement_price.to_real(), 300);
   }
   {
      BOOST_TEST_MESSAGE(""After hardfork, change underlying asset of bit_jmj from core to bit_usd"");
      change_backing_asset(*this, nathan_private_key, bit_jmj_id, bit_usd_id);

      BOOST_TEST_MESSAGE(""Verify feed producers have been reset"");
      const asset_bitasset_data_object& jmj_obj = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(jmj_obj.feeds.size(), 0ul);
   }
   {
      BOOST_TEST_MESSAGE(""With underlying bitasset changed from one to another, price feeds should still be publish-able"");
      auto& global_props = db.get_global_properties();
      std::vector<account_id_type> active_witnesses;
      for(const auto& witness_id : global_props.active_witnesses)
      {
         active_witnesses.push_back(witness_id(db).witness_account);
      }
      BOOST_TEST_MESSAGE(""Adding Witness 0's price feed"");
      add_price_feed(*this, active_witnesses[0], bit_usd_id, 1, bit_jmj_id, 30, core_id);

      const asset_bitasset_data_object& bitasset = bit_jmj_id(db).bitasset_data(db);
      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 30);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);

      BOOST_TEST_MESSAGE(""Adding Witness 1's pricing to JMJBIT"");
      add_price_feed(*this, active_witnesses[0], bit_usd_id, 1, bit_jmj_id, 25, core_id);

      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 30);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);

      BOOST_TEST_MESSAGE(""Adding Witness 2's pricing to JMJBIT"");
      add_price_feed(*this, active_witnesses[2], bit_usd_id, 1, bit_jmj_id, 10, core_id);

      BOOST_CHECK_EQUAL(bitasset.current_feed.settlement_price.to_real(), 25);
      BOOST_CHECK(bitasset.current_feed.maintenance_collateral_ratio == GRAPHENE_DEFAULT_MAINTENANCE_COLLATERAL_RATIO);
      generate_block();
      trx.clear();

      BOOST_CHECK(bitasset.current_feed.core_exchange_rate.base.asset_id != bitasset.current_feed.core_exchange_rate.quote.asset_id);
   }
}
*/
BOOST_AUTO_TEST_CASE(hf_890_test_hf1270)
{ try {
   hf1270 = true;
   INVOKE(hf_890_test);

} FC_LOG_AND_RETHROW() }

BOOST_AUTO_TEST_SUITE_END()
",16290,True,3400.055501871827,median
"/****************************************************************************
 *
 *   Copyright (c) 2013-2018 PX4 Development Team. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name PX4 nor the names of its contributors may be
 *    used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
 * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
 * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 *
 ****************************************************************************/
/**
 * @file navigator_mission.cpp
 *
 * Helper class to access missions
 *
 * @author Julian Oes <julian@oes.ch>
 * @author Thomas Gubler <thomasgubler@gmail.com>
 * @author Anton Babushkin <anton.babushkin@me.com>
 * @author Ban Siesta <bansiesta@gmail.com>
 * @author Simon Wilks <simon@uaventure.com>
 * @author Andreas Antener <andreas@uaventure.com>
 * @author Sander Smeets <sander@droneslab.com>
 * @author Lorenz Meier <lorenz@px4.io>
 */

#include ""mission.h""
#include ""navigator.h""

#include <string.h>
#include <drivers/drv_hrt.h>
#include <dataman/dataman.h>
#include <systemlib/mavlink_log.h>
#include <systemlib/err.h>
#include <lib/ecl/geo/geo.h>
#include <navigator/navigation.h>
#include <uORB/uORB.h>
#include <uORB/topics/mission.h>
#include <uORB/topics/mission_result.h>

Mission::Mission(Navigator *navigator) :
	MissionBlock(navigator),
	ModuleParams(navigator)
{
}

void
Mission::on_inactive()
{
	/* We need to reset the mission cruising speed, otherwise the
	 * mission velocity which might have been set using mission items
	 * is used for missions such as RTL. */
	_navigator->set_cruising_speed();

	/* Without home a mission can't be valid yet anyway, let's wait. */
	if (!_navigator->home_position_valid()) {
		return;
	}

	if (_inited) {
		if (_mission_sub.updated()) {
			update_mission();

			if (_mission_type == MISSION_TYPE_NONE && _mission.count > 0) {
				_mission_type = MISSION_TYPE_MISSION;
			}
		}

		/* reset the current mission if needed */
		if (need_to_reset_mission(false)) {
			reset_mission(_mission);
			update_mission();
			_navigator->reset_cruising_speed();
		}

	} else {

		/* load missions from storage */
		mission_s mission_state = {};

		dm_lock(DM_KEY_MISSION_STATE);

		/* read current state */
		int read_res = dm_read(DM_KEY_MISSION_STATE, 0, &mission_state, sizeof(mission_s));

		dm_unlock(DM_KEY_MISSION_STATE);

		if (read_res == sizeof(mission_s)) {
			_mission.dataman_id = mission_state.dataman_id;
			_mission.count = mission_state.count;
			_current_mission_index = mission_state.current_seq;

			// find and store landing start marker (if available)
			find_mission_land_start();
		}

		/* On init let's check the mission, maybe there is already one available. */
		check_mission_valid(false);

		_inited = true;
	}

	/* require takeoff after non-loiter or landing */
	if (!_navigator->get_can_loiter_at_sp() || _navigator->get_land_detected()->landed) {
		_need_takeoff = true;
	}

	/* reset so current mission item gets restarted if mission was paused */
	_work_item_type = WORK_ITEM_TYPE_DEFAULT;

	/* reset so MISSION_ITEM_REACHED isn't published */
	_navigator->get_mission_result()->seq_reached = -1;
}

void
Mission::on_inactivation()
{
	// Disable camera trigger
	vehicle_command_s cmd = {};
	cmd.command = vehicle_command_s::VEHICLE_CMD_DO_TRIGGER_CONTROL;
	// Pause trigger
	cmd.param1 = -1.0f;
	cmd.param3 = 1.0f;
	_navigator->publish_vehicle_cmd(&cmd);
}

void
Mission::on_activation()
{
	if (_mission_waypoints_changed) {
		// do not set the closest mission item in the normal mission mode
		if (_mission_execution_mode != mission_result_s::MISSION_EXECUTION_MODE_NORMAL) {
			_current_mission_index = index_closest_mission_item();
		}

		_mission_waypoints_changed = false;
	}

	// we already reset the mission items
	_execution_mode_changed = false;

	set_mission_items();

	// unpause triggering if it was paused
	vehicle_command_s cmd = {};
	cmd.command = vehicle_command_s::VEHICLE_CMD_DO_TRIGGER_CONTROL;
	// unpause trigger
	cmd.param1 = -1.0f;
	cmd.param3 = 0.0f;
	_navigator->publish_vehicle_cmd(&cmd);
}

void
Mission::on_active()
{
	if (_work_item_type == WORK_ITEM_TYPE_PRECISION_LAND) {
		// switch out of precision land once landed
		if (_navigator->get_land_detected()->landed) {
			_navigator->get_precland()->on_inactivation();
			_work_item_type = WORK_ITEM_TYPE_DEFAULT;

		} else {
			_navigator->get_precland()->on_active();
		}
	}

	check_mission_valid(false);

	/* check if anything has changed */
	bool mission_sub_updated = _mission_sub.updated();

	if (mission_sub_updated) {
		_navigator->reset_triplets();
		update_mission();
	}

	/* reset the current mission if needed */
	if (need_to_reset_mission(true)) {
		reset_mission(_mission);
		_navigator->reset_triplets();
		update_mission();
		_navigator->reset_cruising_speed();
		mission_sub_updated = true;
	}

	_mission_changed = false;

	/* reset mission items if needed */
	if (mission_sub_updated || _mission_waypoints_changed || _execution_mode_changed) {
		if (_mission_waypoints_changed) {
			// do not set the closest mission item in the normal mission mode
			if (_mission_execution_mode != mission_result_s::MISSION_EXECUTION_MODE_NORMAL) {
				_current_mission_index = index_closest_mission_item();
			}

			_mission_waypoints_changed = false;
		}

		_execution_mode_changed = false;
		set_mission_items();
	}

	/* lets check if we reached the current mission item */
	if (_mission_type != MISSION_TYPE_NONE && is_mission_item_reached()) {
		/* If we just completed a takeoff which was inserted before the right waypoint,
		   there is no need to report that we reached it because we didn't. */
		if (_work_item_type != WORK_ITEM_TYPE_TAKEOFF) {
			set_mission_item_reached();
		}

		if (_mission_item.autocontinue) {
			/* switch to next waypoint if 'autocontinue' flag set */
			advance_mission();
			set_mission_items();
		}

	} else if (_mission_type != MISSION_TYPE_NONE && _param_mis_altmode.get() == MISSION_ALTMODE_FOH) {

		altitude_sp_foh_update();

	} else {
		/* if waypoint position reached allow loiter on the setpoint */
		if (_waypoint_position_reached && _mission_item.nav_cmd != NAV_CMD_IDLE) {
			_navigator->set_can_loiter_at_sp(true);
		}
	}

	/* check if a cruise speed change has been commanded */
	if (_mission_type != MISSION_TYPE_NONE) {
		cruising_speed_sp_update();
	}

	/* see if we need to update the current yaw heading */
	if (!_param_mis_mnt_yaw_ctl.get()
	    && (_navigator->get_vstatus()->vehicle_type == vehicle_status_s::VEHICLE_TYPE_ROTARY_WING)
	    && (_navigator->get_vroi().mode != vehicle_roi_s::ROI_NONE)
	    && !(_mission_item.nav_cmd == NAV_CMD_TAKEOFF
		 || _mission_item.nav_cmd == NAV_CMD_VTOL_TAKEOFF
		 || _mission_item.nav_cmd == NAV_CMD_DO_VTOL_TRANSITION
		 || _mission_item.nav_cmd == NAV_CMD_LAND
		 || _mission_item.nav_cmd == NAV_CMD_VTOL_LAND
		 || _work_item_type == WORK_ITEM_TYPE_ALIGN)) {
		// Mount control is disabled If the vehicle is in ROI-mode, the vehicle
		// needs to rotate such that ROI is in the field of view.
		// ROI only makes sense for multicopters.
		heading_sp_update();
	}

	// TODO: Add vtol heading update method if required.
	// Question: Why does vtol ever have to update heading?

	/* check if landing needs to be aborted */
	if ((_mission_item.nav_cmd == NAV_CMD_LAND)
	    && (_navigator->abort_landing())) {

		do_abort_landing();
	}
}

bool
Mission::set_current_mission_index(uint16_t index)
{
	if (_navigator->get_mission_result()->valid &&
	    (index != _current_mission_index) && (index < _mission.count)) {

		_current_mission_index = index;

		// a mission index is set manually which has the higher priority than the closest mission item
		// as it is set by the user
		_mission_waypoints_changed = false;

		// update mission items if already in active mission
		if (_navigator->is_planned_mission()) {
			// prevent following ""previous - current"" line
			_navigator->get_position_setpoint_triplet()->previous.valid = false;
			_navigator->get_position_setpoint_triplet()->current.valid = false;
			_navigator->get_position_setpoint_triplet()->next.valid = false;
			set_mission_items();
		}

		return true;
	}

	return false;
}

void
Mission::set_closest_item_as_current()
{
	_current_mission_index = index_closest_mission_item();
}

void
Mission::set_execution_mode(const uint8_t mode)
{
	if (_mission_execution_mode != mode) {
		_execution_mode_changed = true;
		_navigator->get_mission_result()->execution_mode = mode;


		switch (_mission_execution_mode) {
		case mission_result_s::MISSION_EXECUTION_MODE_NORMAL:
		case mission_result_s::MISSION_EXECUTION_MODE_FAST_FORWARD:
			if (mode == mission_result_s::MISSION_EXECUTION_MODE_REVERSE) {
				// command a transition if in vtol mc mode
				if (_navigator->get_vstatus()->vehicle_type == vehicle_status_s::VEHICLE_TYPE_ROTARY_WING &&
				    _navigator->get_vstatus()->is_vtol &&
				    !_navigator->get_land_detected()->landed) {

					set_vtol_transition_item(&_mission_item, vtol_vehicle_status_s::VEHICLE_VTOL_STATE_FW);

					position_setpoint_triplet_s *pos_sp_triplet = _navigator->get_position_setpoint_triplet();
					pos_sp_triplet->previous = pos_sp_triplet->current;
					generate_waypoint_from_heading(&pos_sp_triplet->current, _mission_item.yaw);
					_navigator->set_position_setpoint_triplet_updated();
					issue_command(_mission_item);
				}

				if (_mission_type == MISSION_TYPE_NONE && _mission.count > 0) {
					_mission_type = MISSION_TYPE_MISSION;
				}

				if (_current_mission_index > _mission.count - 1) {
					_current_mission_index = _mission.count - 1;

				} else if (_current_mission_index > 0) {
					--_current_mission_index;
				}

				_work_item_type = WORK_ITEM_TYPE_DEFAULT;
			}

			break;

		case mission_result_s::MISSION_EXECUTION_MODE_REVERSE:
			if ((mode == mission_result_s::MISSION_EXECUTION_MODE_NORMAL) ||
			    (mode == mission_result_s::MISSION_EXECUTION_MODE_FAST_FORWARD)) {
				// handle switch from reverse to forward mission
				if (_current_mission_index < 0) {
					_current_mission_index = 0;

				} else if (_current_mission_index < _mission.count - 1) {
					++_current_mission_index;
				}

				_work_item_type = WORK_ITEM_TYPE_DEFAULT;
			}

			break;

		}

		_mission_execution_mode = mode;
	}
}

bool
Mission::find_mission_land_start()
{
	/* return true if a MAV_CMD_DO_LAND_START, NAV_CMD_VTOL_LAND or NAV_CMD_LAND is found and internally save the index
	 *  return false if not found
	 */

	const dm_item_t dm_current = (dm_item_t)_mission.dataman_id;
	struct mission_item_s missionitem = {};
	struct mission_item_s missionitem_prev = {}; //to store mission item before currently checked on, needed to get pos of wp before NAV_CMD_DO_LAND_START

	for (size_t i = 1; i < _mission.count; i++) {
		const ssize_t len = sizeof(missionitem);
		missionitem_prev = missionitem; // store the last mission item before reading a new one

		if (dm_read(dm_current, i, &missionitem, len) != len) {
			/* not supposed to happen unless the datamanager can't access the SD card, etc. */
			PX4_ERR(""dataman read failure"");
			break;
		}

		// first check for DO_LAND_START marker
		if ((missionitem.nav_cmd == NAV_CMD_DO_LAND_START) && (missionitem_prev.nav_cmd == NAV_CMD_WAYPOINT)) {

			_land_start_available = true;
			_land_start_index = i;
			// the DO_LAND_START marker contains no position sp, so take them from the previous mission item
			_landing_lat = missionitem_prev.lat;
			_landing_lon = missionitem_prev.lon;
			_landing_alt = missionitem_prev.altitude;
			return true;

			// if no DO_LAND_START marker available, also check for VTOL_LAND or normal LAND

		} else if (((missionitem.nav_cmd == NAV_CMD_VTOL_LAND) && _navigator->get_vstatus()->is_vtol) ||
			   (missionitem.nav_cmd == NAV_CMD_LAND)) {

			_land_start_available = true;
			_land_start_index = i;
			_landing_lat = missionitem.lat;
			_landing_lon = missionitem.lon;
			_landing_alt = missionitem.altitude;
			return true;
		}
	}

	_land_start_available = false;
	return false;
}

bool
Mission::land_start()
{
	// if not currently landing, jump to do_land_start
	if (_land_start_available) {
		if (landing()) {
			return true;

		} else {
			set_current_mission_index(get_land_start_index());
			return landing();
		}
	}

	return false;
}

bool
Mission::landing()
{
	// vehicle is currently landing if
	//  mission valid, still flying, and in the landing portion of mission

	const bool mission_valid = _navigator->get_mission_result()->valid;
	const bool on_landing_stage = _land_start_available && (_current_mission_index >= get_land_start_index());

	return mission_valid && on_landing_stage;
}

void
Mission::update_mission()
{

	bool failed = true;

	/* Reset vehicle_roi
	 * Missions that do not explicitly configure ROI would not override
	 * an existing ROI setting from previous missions */
	_navigator->reset_vroi();

	const mission_s old_mission = _mission;

	if (_mission_sub.copy(&_mission)) {
		/* determine current index */
		if (_mission.current_seq >= 0 && _mission.current_seq < (int)_mission.count) {
			_current_mission_index = _mission.current_seq;

		} else {
			/* if less items available, reset to first item */
			if (_current_mission_index >= (int)_mission.count) {
				_current_mission_index = 0;

			} else if (_current_mission_index < 0) {
				/* if not initialized, set it to 0 */
				_current_mission_index = 0;
			}

			/* otherwise, just leave it */
		}

		check_mission_valid(true);

		failed = !_navigator->get_mission_result()->valid;

		if (!failed) {
			/* reset mission failure if we have an updated valid mission */
			_navigator->get_mission_result()->failure = false;

			/* reset sequence info as well */
			_navigator->get_mission_result()->seq_reached = -1;
			_navigator->get_mission_result()->seq_total = _mission.count;

			/* reset work item if new mission has been accepted */
			_work_item_type = WORK_ITEM_TYPE_DEFAULT;
			_mission_changed = true;
		}

		/* check if the mission waypoints changed while the vehicle is in air
		 * TODO add a flag to mission_s which actually tracks if the position of the waypoint changed */
		if (((_mission.count != old_mission.count) ||
		     (_mission.dataman_id != old_mission.dataman_id)) &&
		    !_navigator->get_land_detected()->landed) {
			_mission_waypoints_changed = true;
		}

	} else {
		PX4_ERR(""mission update failed"");
	}

	if (failed) {
		_mission.count = 0;
		_mission.current_seq = 0;
		_current_mission_index = 0;

		PX4_ERR(""mission check failed"");
	}

	// find and store landing start marker (if available)
	find_mission_land_start();

	set_current_mission_item();
}


void
Mission::advance_mission()
{
	/* do not advance mission item if we're processing sub mission work items */
	if (_work_item_type != WORK_ITEM_TYPE_DEFAULT) {
		return;
	}

	switch (_mission_type) {
	case MISSION_TYPE_MISSION:
		switch (_mission_execution_mode) {
		case mission_result_s::MISSION_EXECUTION_MODE_NORMAL:
		case mission_result_s::MISSION_EXECUTION_MODE_FAST_FORWARD: {
				_current_mission_index++;
				break;
			}

		case mission_result_s::MISSION_EXECUTION_MODE_REVERSE: {
				// find next position item in reverse order
				dm_item_t dm_current = (dm_item_t)(_mission.dataman_id);

				for (int32_t i = _current_mission_index - 1; i >= 0; i--) {
					struct mission_item_s missionitem = {};
					const ssize_t len = sizeof(missionitem);

					if (dm_read(dm_current, i, &missionitem, len) != len) {
						/* not supposed to happen unless the datamanager can't access the SD card, etc. */
						PX4_ERR(""dataman read failure"");
						break;
					}

					if (item_contains_position(missionitem)) {
						_current_mission_index = i;
						return;
					}
				}

				// finished flying back the mission
				_current_mission_index = -1;
				break;
			}

		default:
			_current_mission_index++;
		}

		break;

	case MISSION_TYPE_NONE:
	default:
		break;
	}
}

void
Mission::set_mission_items()
{
	/* reset the altitude foh (first order hold) logic, if altitude foh is enabled (param) a new foh element starts now */
	_min_current_sp_distance_xy = FLT_MAX;

	/* the home dist check provides user feedback, so we initialize it to this */
	bool user_feedback_done = false;

	/* mission item that comes after current if available */
	struct mission_item_s mission_item_next_position;
	bool has_next_position_item = false;

	work_item_type new_work_item_type = WORK_ITEM_TYPE_DEFAULT;

	if (prepare_mission_items(&_mission_item, &mission_item_next_position, &has_next_position_item)) {
		/* if mission type changed, notify */
		if (_mission_type != MISSION_TYPE_MISSION) {
			mavlink_log_info(_navigator->get_mavlink_log_pub(),
					 _mission_execution_mode == mission_result_s::MISSION_EXECUTION_MODE_REVERSE ? ""Executing Reverse Mission"" :
					 ""Executing Mission"");
			user_feedback_done = true;
		}

		_mission_type = MISSION_TYPE_MISSION;

	} else {
		/* no mission available or mission finished, switch to loiter */
		if (_mission_type != MISSION_TYPE_NONE) {

			if (_navigator->get_land_detected()->landed) {
				mavlink_log_info(_navigator->get_mavlink_log_pub(),
						 _mission_execution_mode == mission_result_s::MISSION_EXECUTION_MODE_REVERSE ? ""Reverse Mission finished, landed"" :
						 ""Mission finished, landed."");

			} else {
				/* https://en.wikipedia.org/wiki/Loiter_(aeronautics) */
				mavlink_log_info(_navigator->get_mavlink_log_pub(),
						 _mission_execution_mode == mission_result_s::MISSION_EXECUTION_MODE_REVERSE ? ""Reverse Mission finished, loitering"" :
						 ""Mission finished, loitering."");

				/* use last setpoint for loiter */
				_navigator->set_can_loiter_at_sp(true);
			}

			user_feedback_done = true;
		}

		_mission_type = MISSION_TYPE_NONE;

		/* set loiter mission item and ensure that there is a minimum clearance from home */
		set_loiter_item(&_mission_item, _navigator->get_takeoff_min_alt());

		/* update position setpoint triplet  */
		position_setpoint_triplet_s *pos_sp_triplet = _navigator->get_position_setpoint_triplet();
		pos_sp_triplet->previous.valid = false;
		mission_apply_limitation(_mission_item);
		mission_item_to_position_setpoint(_mission_item, &pos_sp_triplet->current);
		pos_sp_triplet->next.valid = false;

		/* reuse setpoint for LOITER only if it's not IDLE */
		_navigator->set_can_loiter_at_sp(pos_sp_triplet->current.type == position_setpoint_s::SETPOINT_TYPE_LOITER);

		// set mission finished
		_navigator->get_mission_result()->finished = true;
		_navigator->set_mission_result_updated();

		if (!user_feedback_done) {
			/* only tell users that we got no mission if there has not been any
			 * better, more specific feedback yet
			 * https://en.wikipedia.org/wiki/Loiter_(aeronautics)
			 */

			if (_navigator->get_land_detected()->landed) {
				/* landed, refusing to take off without a mission */
				mavlink_log_critical(_navigator->get_mavlink_log_pub(), ""No valid mission available, refusing takeoff."");

			} else {
				mavlink_log_critical(_navigator->get_mavlink_log_pub(), ""No valid mission available, loitering."");
			}

			user_feedback_done = true;
		}

		_navigator->set_position_setpoint_triplet_updated();
		return;
	}

	/*********************************** handle mission item *********************************************/

	/* handle mission items depending on the mode */

	const position_setpoint_s current_setpoint_copy = _navigator->get_position_setpoint_triplet()->current;

	if (item_contains_position(_mission_item)) {
		switch (_mission_execution_mode) {
		case mission_result_s::MISSION_EXECUTION_MODE_NORMAL:
		case mission_result_s::MISSION_EXECUTION_MODE_FAST_FORWARD: {
				/* force vtol land */
				if (_navigator->force_vtol() && _mission_item.nav_cmd == NAV_CMD_LAND) {
					_mission_item.nav_cmd = NAV_CMD_VTOL_LAND;
				}

				position_setpoint_triplet_s *pos_sp_triplet = _navigator->get_position_setpoint_triplet();

				/* do takeoff before going to setpoint if needed and not already in takeoff */
				/* in fixed-wing this whole block will be ignored and a takeoff item is always propagated */
				if (do_need_vertical_takeoff() &&
				    _work_item_type == WORK_ITEM_TYPE_DEFAULT &&
				    new_work_item_type == WORK_ITEM_TYPE_DEFAULT) {

					new_work_item_type = WORK_ITEM_TYPE_TAKEOFF;

					/* use current mission item as next position item */
					mission_item_next_position = _mission_item;
					mission_item_next_position.nav_cmd = NAV_CMD_WAYPOINT;
					has_next_position_item = true;

					float takeoff_alt = calculate_takeoff_altitude(&_mission_item);

					mavlink_log_info(_navigator->get_mavlink_log_pub(), ""Takeoff to %.1f meters above home."",
							 (double)(takeoff_alt - _navigator->get_home_position()->alt));

					_mission_item.nav_cmd = NAV_CMD_TAKEOFF;
					_mission_item.lat = _navigator->get_global_position()->lat;
					_mission_item.lon = _navigator->get_global_position()->lon;
					/* hold heading for takeoff items */
					_mission_item.yaw = _navigator->get_global_position()->yaw;
					_mission_item.altitude = takeoff_alt;
					_mission_item.altitude_is_relative = false;
					_mission_item.autocontinue = true;
					_mission_item.time_inside = 0.0f;

				} else if (_mission_item.nav_cmd == NAV_CMD_TAKEOFF
					   && _work_item_type == WORK_ITEM_TYPE_DEFAULT
					   && new_work_item_type == WORK_ITEM_TYPE_DEFAULT
					   && _navigator->get_vstatus()->vehicle_type == vehicle_status_s::VEHICLE_TYPE_ROTARY_WING) {

					/* if there is no need to do a takeoff but we have a takeoff item, treat is as waypoint */
					_mission_item.nav_cmd = NAV_CMD_WAYPOINT;
					/* ignore yaw here, otherwise it might yaw before heading_sp_update takes over */
					_mission_item.yaw = NAN;
					/* since _mission_item.time_inside and and _mission_item.pitch_min build a union, we need to set time_inside to zero
					 * since in NAV_CMD_TAKEOFF mode there is currently no time_inside.
					 * Note also that resetting time_inside to zero will cause pitch_min to be zero as well.
					 */
					_mission_item.time_inside = 0.0f;

				} else if (_mission_item.nav_cmd == NAV_CMD_VTOL_TAKEOFF
					   && _work_item_type == WORK_ITEM_TYPE_DEFAULT
					   && new_work_item_type == WORK_ITEM_TYPE_DEFAULT) {

					if (_navigator->get_vstatus()->vehicle_type == vehicle_status_s::VEHICLE_TYPE_ROTARY_WING) {
						/* haven't transitioned yet, trigger vtol takeoff logic below */
						_work_item_type = WORK_ITEM_TYPE_TAKEOFF;

					} else {
						/* already in fixed-wing, go to waypoint */
						_mission_item.nav_cmd = NAV_CMD_WAYPOINT;
					}

					/* ignore yaw here, otherwise it might yaw before heading_sp_update takes over */
					_mission_item.yaw = NAN;
				}

				/* if we just did a normal takeoff navigate to the actual waypoint now */
				if (_mission_item.nav_cmd == NAV_CMD_TAKEOFF &&
				    _work_item_type == WORK_ITEM_TYPE_TAKEOFF &&
				    new_work_item_type == WORK_ITEM_TYPE_DEFAULT) {

					_mission_item.nav_cmd = NAV_CMD_WAYPOINT;
					/* ignore yaw here, otherwise it might yaw before heading_sp_update takes over */
					_mission_item.yaw = NAN;
					/* since _mission_item.time_inside and and _mission_item.pitch_min build a union, we need to set time_inside to zero
					 * since in NAV_CMD_TAKEOFF mode there is currently no time_inside.
					 */
					_mission_item.time_inside = 0.0f;
				}

				/* if we just did a VTOL takeoff, prepare transition */
				if (_mission_item.nav_cmd == NAV_CMD_VTOL_TAKEOFF &&
				    _work_item_type == WORK_ITEM_TYPE_TAKEOFF &&
				    new_work_item_type == WORK_ITEM_TYPE_DEFAULT &&
				    _navigator->get_vstatus()->vehicle_type == vehicle_status_s::VEHICLE_TYPE_ROTARY_WING &&
				    !_navigator->get_land_detected()->landed) {

					/* disable weathervane before front transition for allowing yaw to align */
					pos_sp_triplet->current.disable_weather_vane = true;

					/* set yaw setpoint to heading of VTOL_TAKEOFF wp against current position */
					_mission_item.yaw = get_bearing_to_next_waypoint(
								    _navigator->get_global_position()->lat, _navigator->get_global_position()->lon,
								    _mission_item.lat, _mission_item.lon);

					_mission_item.force_heading = true;

					new_work_item_type = WORK_ITEM_TYPE_ALIGN;

					/* set position setpoint to current while aligning */
					_mission_item.lat = _navigator->get_global_position()->lat;
					_mission_item.lon = _navigator->get_global_position()->lon;
				}

				/* heading is aligned now, prepare transition */
				if (_mission_item.nav_cmd == NAV_CMD_VTOL_TAKEOFF &&
				    _work_item_type == WORK_ITEM_TYPE_ALIGN &&
				    _navigator->get_vstatus()->vehicle_type == vehicle_status_s::VEHICLE_TYPE_ROTARY_WING &&
				    !_navigator->get_land_detected()->landed) {

					/* re-enable weather vane again after alignment */
					pos_sp_triplet->current.disable_weather_vane = false;

					/* check if the vtol_takeoff waypoint is on top of us */
					if (do_need_move_to_takeoff()) {
						new_work_item_type = WORK_ITEM_TYPE_TRANSITON_AFTER_TAKEOFF;
					}

					set_vtol_transition_item(&_mission_item, vtol_vehicle_status_s::VEHICLE_VTOL_STATE_FW);

					/* set position setpoint to target during the transition */
					// TODO: if has_next_position_item and use_next set next, or if use_heading set generated
					generate_waypoint_from_heading(&pos_sp_triplet->current, _mission_item.yaw);
				}

				/* takeoff completed and transitioned, move to takeoff wp as fixed wing */
				if (_mission_item.nav_cmd == NAV_CMD_VTOL_TAKEOFF
				    && _work_item_type == WORK_ITEM_TYPE_TRANSITON_AFTER_TAKEOFF
				    && new_work_item_type == WORK_ITEM_TYPE_DEFAULT) {

					new_work_item_type = WORK_ITEM_TYPE_DEFAULT;
					_mission_item.nav_cmd = NAV_CMD_WAYPOINT;
					_mission_item.autocontinue = true;
					_mission_item.time_inside = 0.0f;
				}

				/* move to land wp as fixed wing */
				if (_mission_item.nav_cmd == NAV_CMD_VTOL_LAND
				    && (_work_item_type == WORK_ITEM_TYPE_DEFAULT || _work_item_type == WORK_ITEM_TYPE_TRANSITON_AFTER_TAKEOFF)
				    && new_work_item_type == WORK_ITEM_TYPE_DEFAULT
				    && !_navigator->get_land_detected()->landed) {

					new_work_item_type = WORK_ITEM_TYPE_MOVE_TO_LAND;

					/* use current mission item as next position item */
					mission_item_next_position = _mission_item;
					has_next_position_item = true;

					float altitude = _navigator->get_global_position()->alt;

					if (pos_sp_triplet->current.valid && pos_sp_triplet->current.type == position_setpoint_s::SETPOINT_TYPE_POSITION) {
						altitude = pos_sp_triplet->current.alt;
					}

					_mission_item.altitude = altitude;
					_mission_item.altitude_is_relative = false;
					_mission_item.nav_cmd = NAV_CMD_WAYPOINT;
					_mission_item.autocontinue = true;
					_mission_item.time_inside = 0.0f;
					_mission_item.vtol_back_transition = true;
				}

				/* transition to MC */
				if (_mission_item.nav_cmd == NAV_CMD_VTOL_LAND
				    && _work_item_type == WORK_ITEM_TYPE_MOVE_TO_LAND
				    && new_work_item_type == WORK_ITEM_TYPE_DEFAULT
				    && _navigator->get_vstatus()->vehicle_type == vehicle_status_s::VEHICLE_TYPE_FIXED_WING
				    && !_navigator->get_land_detected()->landed) {

					set_vtol_transition_item(&_mission_item, vtol_vehicle_status_s::VEHICLE_VTOL_STATE_MC);

					new_work_item_type = WORK_ITEM_TYPE_MOVE_TO_LAND_AFTER_TRANSITION;
				}

				/* move to landing waypoint before descent if necessary */
				if (do_need_move_to_land() &&
				    (_work_item_type == WORK_ITEM_TYPE_DEFAULT ||
				     _work_item_type == WORK_ITEM_TYPE_MOVE_TO_LAND_AFTER_TRANSITION) &&
				    new_work_item_type == WORK_ITEM_TYPE_DEFAULT) {

					new_work_item_type = WORK_ITEM_TYPE_MOVE_TO_LAND;

					/* use current mission item as next position item */
					mission_item_next_position = _mission_item;
					has_next_position_item = true;

					/*
					 * Ignoring waypoint altitude:
					 * Set altitude to the same as we have now to prevent descending too fast into
					 * the ground. Actual landing will descend anyway until it touches down.
					 * XXX: We might want to change that at some point if it is clear to the user
					 * what the altitude means on this waypoint type.
					 */
					float altitude = _navigator->get_global_position()->alt;

					if (pos_sp_triplet->current.valid
					    && pos_sp_triplet->current.type == position_setpoint_s::SETPOINT_TYPE_POSITION) {
						altitude = pos_sp_triplet->current.alt;
					}

					_mission_item.altitude = altitude;
					_mission_item.altitude_is_relative = false;
					_mission_item.nav_cmd = NAV_CMD_WAYPOINT;
					_mission_item.autocontinue = true;
					_mission_item.time_inside = 0.0f;

				} else if (_mission_item.nav_cmd == NAV_CMD_LAND && _work_item_type == WORK_ITEM_TYPE_DEFAULT) {
					if (_mission_item.land_precision > 0 && _mission_item.land_precision < 3) {
						new_work_item_type = WORK_ITEM_TYPE_PRECISION_LAND;

						if (_mission_item.land_precision == 1) {
							_navigator->get_precland()->set_mode(PrecLandMode::Opportunistic);

						} else { //_mission_item.land_precision == 2
							_navigator->get_precland()->set_mode(PrecLandMode::Required);
						}

						_navigator->get_precland()->on_activation();

					}
				}

				/* we just moved to the landing waypoint, now descend */
				if (_work_item_type == WORK_ITEM_TYPE_MOVE_TO_LAND &&
				    new_work_item_type == WORK_ITEM_TYPE_DEFAULT) {

					if (_mission_item.land_precision > 0 && _mission_item.land_precision < 3) {
						new_work_item_type = WORK_ITEM_TYPE_PRECISION_LAND;

						if (_mission_item.land_precision == 1) {
							_navigator->get_precland()->set_mode(PrecLandMode::Opportunistic);

						} else { //_mission_item.land_precision == 2
							_navigator->get_precland()->set_mode(PrecLandMode::Required);
						}

						_navigator->get_precland()->on_activation();

					}

				}

				/* ignore yaw for landing items */
				/* XXX: if specified heading for landing is desired we could add another step before the descent
				 * that aligns the vehicle first */
				if (_mission_item.nav_cmd == NAV_CMD_LAND || _mission_item.nav_cmd == NAV_CMD_VTOL_LAND) {
					_mission_item.yaw = NAN;
				}


				// for fast forward convert certain types to simple waypoint
				// XXX: add other types which should be ignored in fast forward
				if (_mission_execution_mode == mission_result_s::MISSION_EXECUTION_MODE_FAST_FORWARD &&
				    ((_mission_item.nav_cmd == NAV_CMD_LOITER_UNLIMITED) ||
				     (_mission_item.nav_cmd == NAV_CMD_LOITER_TIME_LIMIT))) {
					_mission_item.nav_cmd = NAV_CMD_WAYPOINT;
					_mission_item.autocontinue = true;
					_mission_item.time_inside = 0.0f;
				}

				break;
			}

		case mission_result_s::MISSION_EXECUTION_MODE_REVERSE: {
				if (item_contains_position(_mission_item)) {
					// convert mission item to a simple waypoint
					_mission_item.nav_cmd = NAV_CMD_WAYPOINT;
					_mission_item.autocontinue = true;
					_mission_item.time_inside = 0.0f;

				} else {
					mavlink_log_critical(_navigator->get_mavlink_log_pub(), ""MissionReverse: Got a non-position mission item, ignoring it"");
				}

				break;
			}
		}

	} else {
		/* handle non-position mission items such as commands */
		switch (_mission_execution_mode) {
		case mission_result_s::MISSION_EXECUTION_MODE_NORMAL:
		case mission_result_s::MISSION_EXECUTION_MODE_FAST_FORWARD: {
				position_setpoint_triplet_s *pos_sp_triplet = _navigator->get_position_setpoint_triplet();

				/* turn towards next waypoint before MC to FW transition */
				if (_mission_item.nav_cmd == NAV_CMD_DO_VTOL_TRANSITION
				    && _work_item_type == WORK_ITEM_TYPE_DEFAULT
				    && new_work_item_type == WORK_ITEM_TYPE_DEFAULT
				    && _navigator->get_vstatus()->vehicle_type == vehicle_status_s::VEHICLE_TYPE_ROTARY_WING
				    && !_navigator->get_land_detected()->landed
				    && has_next_position_item) {

					/* disable weathervane before front transition for allowing yaw to align */
					pos_sp_triplet->current.disable_weather_vane = true;

					new_work_item_type = WORK_ITEM_TYPE_ALIGN;

					set_align_mission_item(&_mission_item, &mission_item_next_position);

					/* set position setpoint to target during the transition */
					mission_apply_limitation(_mission_item);
					mission_item_to_position_setpoint(mission_item_next_position, &pos_sp_triplet->current);
				}

				/* yaw is aligned now */
				if (_work_item_type == WORK_ITEM_TYPE_ALIGN &&
				    new_work_item_type == WORK_ITEM_TYPE_DEFAULT) {

					new_work_item_type = WORK_ITEM_TYPE_DEFAULT;

					/* set position setpoint to target during the transition */
					pos_sp_triplet->previous = pos_sp_triplet->current;
					generate_waypoint_from_heading(&pos_sp_triplet->current, pos_sp_triplet->current.yaw);
				}

				/* don't advance mission after FW to MC command */
				if (_mission_item.nav_cmd == NAV_CMD_DO_VTOL_TRANSITION
				    && _work_item_type == WORK_ITEM_TYPE_DEFAULT
				    && new_work_item_type == WORK_ITEM_TYPE_DEFAULT
				    && _navigator->get_vstatus()->vehicle_type == vehicle_status_s::VEHICLE_TYPE_FIXED_WING
				    && !_navigator->get_land_detected()->landed
				    && pos_sp_triplet->current.valid) {

					new_work_item_type = WORK_ITEM_TYPE_CMD_BEFORE_MOVE;
				}

				/* after FW to MC transition finish moving to the waypoint */
				if (_work_item_type == WORK_ITEM_TYPE_CMD_BEFORE_MOVE &&
				    new_work_item_type == WORK_ITEM_TYPE_DEFAULT
				    && pos_sp_triplet->current.valid) {

					new_work_item_type = WORK_ITEM_TYPE_DEFAULT;

					_mission_item.nav_cmd = NAV_CMD_WAYPOINT;
					copy_position_if_valid(&_mission_item, &pos_sp_triplet->current);
					_mission_item.autocontinue = true;
					_mission_item.time_inside = 0.0f;
				}

				// ignore certain commands in mission fast forward
				if ((_mission_execution_mode == mission_result_s::MISSION_EXECUTION_MODE_FAST_FORWARD) &&
				    (_mission_item.nav_cmd == NAV_CMD_DELAY)) {
					_mission_item.autocontinue = true;
					_mission_item.time_inside = 0.0f;
				}

				break;
			}

		case mission_result_s::MISSION_EXECUTION_MODE_REVERSE: {
				// nothing to do, all commands are ignored
				break;
			}
		}
	}

	/*********************************** set setpoints and check next *********************************************/

	position_setpoint_triplet_s *pos_sp_triplet = _navigator->get_position_setpoint_triplet();

	/* set current position setpoint from mission item (is protected against non-position items) */
	if (new_work_item_type != WORK_ITEM_TYPE_PRECISION_LAND) {
		mission_apply_limitation(_mission_item);
		mission_item_to_position_setpoint(_mission_item, &pos_sp_triplet->current);
	}

	/* only set the previous position item if the current one really changed */
	if ((_work_item_type != WORK_ITEM_TYPE_MOVE_TO_LAND) &&
	    !position_setpoint_equal(&pos_sp_triplet->current, &current_setpoint_copy)) {
		pos_sp_triplet->previous = current_setpoint_copy;
	}

	/* issue command if ready (will do nothing for position mission items) */
	issue_command(_mission_item);

	/* set current work item type */
	_work_item_type = new_work_item_type;

	/* require takeoff after landing or idle */
	if (pos_sp_triplet->current.type == position_setpoint_s::SETPOINT_TYPE_LAND
	    || pos_sp_triplet->current.type == position_setpoint_s::SETPOINT_TYPE_IDLE) {

		_need_takeoff = true;
	}

	_navigator->set_can_loiter_at_sp(false);
	reset_mission_item_reached();

	if (_mission_type == MISSION_TYPE_MISSION) {
		set_current_mission_item();
	}

	if (_mission_item.autocontinue && get_time_inside(_mission_item) < FLT_EPSILON) {
		/* try to process next mission item */
		if (has_next_position_item) {
			/* got next mission item, update setpoint triplet */
			mission_apply_limitation(mission_item_next_position);
			mission_item_to_position_setpoint(mission_item_next_position, &pos_sp_triplet->next);

		} else {
			/* next mission item is not available */
			pos_sp_triplet->next.valid = false;
		}

	} else {
		/* vehicle will be paused on current waypoint, don't set next item */
		pos_sp_triplet->next.valid = false;
	}

	/* Save the distance between the current sp and the previous one */
	if (pos_sp_triplet->current.valid && pos_sp_triplet->previous.valid) {

		_distance_current_previous = get_distance_to_next_waypoint(
						     pos_sp_triplet->current.lat, pos_sp_triplet->current.lon,
						     pos_sp_triplet->previous.lat, pos_sp_triplet->previous.lon);
	}

	_navigator->set_position_setpoint_triplet_updated();
}

bool
Mission::do_need_vertical_takeoff()
{
	if (_navigator->get_vstatus()->vehicle_type == vehicle_status_s::VEHICLE_TYPE_ROTARY_WING) {

		float takeoff_alt = calculate_takeoff_altitude(&_mission_item);

		if (_navigator->get_land_detected()->landed) {
			/* force takeoff if landed (additional protection) */
			_need_takeoff = true;

		} else if (_navigator->get_global_position()->alt > takeoff_alt - _navigator->get_altitude_acceptance_radius()) {
			/* if in-air and already above takeoff height, don't do takeoff */
			_need_takeoff = false;

		} else if (_navigator->get_global_position()->alt <= takeoff_alt - _navigator->get_altitude_acceptance_radius()
			   && (_mission_item.nav_cmd == NAV_CMD_TAKEOFF
			       || _mission_item.nav_cmd == NAV_CMD_VTOL_TAKEOFF)) {
			/* if in-air but below takeoff height and we have a takeoff item */
			_need_takeoff = true;
		}

		/* check if current mission item is one that requires takeoff before */
		if (_need_takeoff && (
			    _mission_item.nav_cmd == NAV_CMD_TAKEOFF ||
			    _mission_item.nav_cmd == NAV_CMD_WAYPOINT ||
			    _mission_item.nav_cmd == NAV_CMD_VTOL_TAKEOFF ||
			    _mission_item.nav_cmd == NAV_CMD_LOITER_TIME_LIMIT ||
			    _mission_item.nav_cmd == NAV_CMD_LOITER_UNLIMITED)) {

			_need_takeoff = false;
			return true;
		}
	}

	return false;
}

bool
Mission::do_need_move_to_land()
{
	if (_navigator->get_vstatus()->vehicle_type == vehicle_status_s::VEHICLE_TYPE_ROTARY_WING
	    && (_mission_item.nav_cmd == NAV_CMD_LAND || _mission_item.nav_cmd == NAV_CMD_VTOL_LAND)) {

		float d_current = get_distance_to_next_waypoint(_mission_item.lat, _mission_item.lon,
				  _navigator->get_global_position()->lat, _navigator->get_global_position()->lon);

		return d_current > _navigator->get_acceptance_radius();
	}

	return false;
}

bool
Mission::do_need_move_to_takeoff()
{
	if (_navigator->get_vstatus()->vehicle_type == vehicle_status_s::VEHICLE_TYPE_ROTARY_WING
	    && _mission_item.nav_cmd == NAV_CMD_VTOL_TAKEOFF) {

		float d_current = get_distance_to_next_waypoint(_mission_item.lat, _mission_item.lon,
				  _navigator->get_global_position()->lat, _navigator->get_global_position()->lon);

		return d_current > _navigator->get_acceptance_radius();
	}

	return false;
}

void
Mission::copy_position_if_valid(struct mission_item_s *mission_item, struct position_setpoint_s *setpoint)
{
	if (setpoint->valid && setpoint->type == position_setpoint_s::SETPOINT_TYPE_POSITION) {
		mission_item->lat = setpoint->lat;
		mission_item->lon = setpoint->lon;
		mission_item->altitude = setpoint->alt;

	} else {
		mission_item->lat = _navigator->get_global_position()->lat;
		mission_item->lon = _navigator->get_global_position()->lon;
		mission_item->altitude = _navigator->get_global_position()->alt;
	}

	mission_item->altitude_is_relative = false;
}

void
Mission::set_align_mission_item(struct mission_item_s *mission_item, struct mission_item_s *mission_item_next)
{
	mission_item->nav_cmd = NAV_CMD_WAYPOINT;
	copy_position_if_valid(mission_item, &(_navigator->get_position_setpoint_triplet()->current));
	mission_item->altitude_is_relative = false;
	mission_item->autocontinue = true;
	mission_item->time_inside = 0.0f;
	mission_item->yaw = get_bearing_to_next_waypoint(
				    _navigator->get_global_position()->lat, _navigator->get_global_position()->lon,
				    mission_item_next->lat, mission_item_next->lon);
	mission_item->force_heading = true;
}

float
Mission::calculate_takeoff_altitude(struct mission_item_s *mission_item)
{
	/* calculate takeoff altitude */
	float takeoff_alt = get_absolute_altitude_for_item(*mission_item);

	/* takeoff to at least MIS_TAKEOFF_ALT above home/ground, even if first waypoint is lower */
	if (_navigator->get_land_detected()->landed) {
		takeoff_alt = fmaxf(takeoff_alt, _navigator->get_global_position()->alt + _navigator->get_takeoff_min_alt());

	} else {
		takeoff_alt = fmaxf(takeoff_alt, _navigator->get_home_position()->alt + _navigator->get_takeoff_min_alt());
	}

	return takeoff_alt;
}

void
Mission::heading_sp_update()
{
	struct position_setpoint_triplet_s *pos_sp_triplet =
		_navigator->get_position_setpoint_triplet();

	// Only update if current triplet is valid
	if (pos_sp_triplet->current.valid) {

		double point_from_latlon[2] = { _navigator->get_global_position()->lat,
						_navigator->get_global_position()->lon
					      };
		double point_to_latlon[2] = { _navigator->get_global_position()->lat,
					      _navigator->get_global_position()->lon
					    };
		float yaw_offset = 0.0f;

		// Depending on ROI-mode, update heading
		switch (_navigator->get_vroi().mode) {
		case vehicle_roi_s::ROI_LOCATION: {
				// ROI is a fixed location. Vehicle needs to point towards that location
				point_to_latlon[0] = _navigator->get_vroi().lat;
				point_to_latlon[1] = _navigator->get_vroi().lon;
				// No yaw offset required
				yaw_offset = 0.0f;
				break;
			}

		case vehicle_roi_s::ROI_WPNEXT: {
				// ROI is current waypoint. Vehcile needs to point towards current waypoint
				point_to_latlon[0] = pos_sp_triplet->current.lat;
				point_to_latlon[1] = pos_sp_triplet->current.lon;
				// Add the gimbal's yaw offset
				yaw_offset = _navigator->get_vroi().yaw_offset;
				break;
			}

		case vehicle_roi_s::ROI_NONE:
		case vehicle_roi_s::ROI_WPINDEX:
		case vehicle_roi_s::ROI_TARGET:
		case vehicle_roi_s::ROI_ENUM_END:
		default: {
			}
		}

		// Get desired heading and update it.
		// However, only update if distance to desired heading is
		// larger than acceptance radius to prevent excessive yawing
		float d_current = get_distance_to_next_waypoint(point_from_latlon[0],
				  point_from_latlon[1], point_to_latlon[0], point_to_latlon[1]);

		if (d_current > _navigator->get_acceptance_radius()) {
			float yaw = matrix::wrap_pi(
					    get_bearing_to_next_waypoint(point_from_latlon[0],
							    point_from_latlon[1], point_to_latlon[0],
							    point_to_latlon[1]) + yaw_offset);

			_mission_item.yaw = yaw;
			pos_sp_triplet->current.yaw = _mission_item.yaw;
			pos_sp_triplet->current.yaw_valid = true;
		}

		// we set yaw directly so we can run this in parallel to the FOH update
		_navigator->set_position_setpoint_triplet_updated();
	}
}

void
Mission::altitude_sp_foh_update()
{
	struct position_setpoint_triplet_s *pos_sp_triplet = _navigator->get_position_setpoint_triplet();

	/* Don't change setpoint if last and current waypoint are not valid
	 * or if the previous altitude isn't from a position or loiter setpoint or
	 * if rotary wing since that is handled in the mc_pos_control
	 */


	if (!pos_sp_triplet->previous.valid || !pos_sp_triplet->current.valid || !PX4_ISFINITE(pos_sp_triplet->previous.alt)
	    || !(pos_sp_triplet->previous.type == position_setpoint_s::SETPOINT_TYPE_POSITION ||
		 pos_sp_triplet->previous.type == position_setpoint_s::SETPOINT_TYPE_LOITER) ||
	    _navigator->get_vstatus()->vehicle_type == vehicle_status_s::VEHICLE_TYPE_ROTARY_WING) {

		return;
	}

	// Calculate acceptance radius, i.e. the radius within which we do not perform a first order hold anymore
	float acc_rad = _navigator->get_acceptance_radius(_mission_item.acceptance_radius);

	if (pos_sp_triplet->current.type == position_setpoint_s::SETPOINT_TYPE_LOITER) {
		acc_rad = _navigator->get_acceptance_radius(fabsf(_mission_item.loiter_radius) * 1.2f);
	}

	/* Do not try to find a solution if the last waypoint is inside the acceptance radius of the current one */
	if (_distance_current_previous - acc_rad < FLT_EPSILON) {
		return;
	}

	/* Don't do FOH for non-missions, landing and takeoff waypoints, the ground may be near
	 * and the FW controller has a custom landing logic
	 *
	 * NAV_CMD_LOITER_TO_ALT doesn't change altitude until reaching desired lat/lon
	 * */
	if (_mission_item.nav_cmd == NAV_CMD_LAND
	    || _mission_item.nav_cmd == NAV_CMD_VTOL_LAND
	    || _mission_item.nav_cmd == NAV_CMD_TAKEOFF
	    || _mission_item.nav_cmd == NAV_CMD_LOITER_TO_ALT
	    || !_navigator->is_planned_mission()) {

		return;
	}

	/* Calculate distance to current waypoint */
	float d_current = get_distance_to_next_waypoint(_mission_item.lat, _mission_item.lon,
			  _navigator->get_global_position()->lat, _navigator->get_global_position()->lon);

	/* Save distance to waypoint if it is the smallest ever achieved, however make sure that
	 * _min_current_sp_distance_xy is never larger than the distance between the current and the previous wp */
	_min_current_sp_distance_xy = math::min(math::min(d_current, _min_current_sp_distance_xy),
						_distance_current_previous);

	/* if the minimal distance is smaller then the acceptance radius, we should be at waypoint alt
	 * navigator will soon switch to the next waypoint item (if there is one) as soon as we reach this altitude */
	if (_min_current_sp_distance_xy < acc_rad) {
		pos_sp_triplet->current.alt = get_absolute_altitude_for_item(_mission_item);

	} else {
		/* update the altitude sp of the 'current' item in the sp triplet, but do not update the altitude sp
		 * of the mission item as it is used to check if the mission item is reached
		 * The setpoint is set linearly and such that the system reaches the current altitude at the acceptance
		 * radius around the current waypoint
		 **/
		float delta_alt = (get_absolute_altitude_for_item(_mission_item) - pos_sp_triplet->previous.alt);
		float grad = -delta_alt / (_distance_current_previous - acc_rad);
		float a = pos_sp_triplet->previous.alt - grad * _distance_current_previous;
		pos_sp_triplet->current.alt = a + grad * _min_current_sp_distance_xy;
	}

	// we set altitude directly so we can run this in parallel to the heading update
	_navigator->set_position_setpoint_triplet_updated();
}

void
Mission::cruising_speed_sp_update()
{
	struct position_setpoint_triplet_s *pos_sp_triplet = _navigator->get_position_setpoint_triplet();

	const float cruising_speed = _navigator->get_cruising_speed();

	/* Don't change setpoint if the current waypoint is not valid */
	if (!pos_sp_triplet->current.valid ||
	    fabsf(pos_sp_triplet->current.cruising_speed - cruising_speed) < FLT_EPSILON) {
		return;
	}

	pos_sp_triplet->current.cruising_speed = cruising_speed;

	_navigator->set_position_setpoint_triplet_updated();
}

void
Mission::do_abort_landing()
{
	// Abort FW landing
	//  first climb out then loiter over intended landing location

	if (_mission_item.nav_cmd != NAV_CMD_LAND) {
		return;
	}

	// loiter at the larger of MIS_LTRMIN_ALT above the landing point
	//  or 2 * FW_CLMBOUT_DIFF above the current altitude
	const float alt_landing = get_absolute_altitude_for_item(_mission_item);
	const float alt_sp = math::max(alt_landing + _navigator->get_loiter_min_alt(),
				       _navigator->get_global_position()->alt + 20.0f);

	// turn current landing waypoint into an indefinite loiter
	_mission_item.nav_cmd = NAV_CMD_LOITER_UNLIMITED;
	_mission_item.altitude_is_relative = false;
	_mission_item.altitude = alt_sp;
	_mission_item.loiter_radius = _navigator->get_loiter_radius();
	_mission_item.acceptance_radius = _navigator->get_acceptance_radius();
	_mission_item.autocontinue = false;
	_mission_item.origin = ORIGIN_ONBOARD;

	mission_apply_limitation(_mission_item);
	mission_item_to_position_setpoint(_mission_item, &_navigator->get_position_setpoint_triplet()->current);
	_navigator->set_position_setpoint_triplet_updated();

	mavlink_and_console_log_info(_navigator->get_mavlink_log_pub(), ""Holding at %d m above landing."",
				     (int)(alt_sp - alt_landing));

	// reset mission index to start of landing
	if (_land_start_available) {
		_current_mission_index = get_land_start_index();

	} else {
		// move mission index back (landing approach point)
		_current_mission_index -= 1;
	}

	// send reposition cmd to get out of mission
	vehicle_command_s vcmd = {};

	vcmd.command = vehicle_command_s::VEHICLE_CMD_DO_REPOSITION;
	vcmd.param1 = -1;
	vcmd.param2 = 1;
	vcmd.param5 = _mission_item.lat;
	vcmd.param6 = _mission_item.lon;
	vcmd.param7 = alt_sp;

	_navigator->publish_vehicle_cmd(&vcmd);
}

bool
Mission::prepare_mission_items(mission_item_s *mission_item,
			       mission_item_s *next_position_mission_item, bool *has_next_position_item)
{
	*has_next_position_item = false;
	bool first_res = false;
	int offset = 1;

	if (_mission_execution_mode == mission_result_s::MISSION_EXECUTION_MODE_REVERSE) {
		offset = -1;
	}

	if (read_mission_item(0, mission_item)) {

		first_res = true;

		/* trying to find next position mission item */
		while (read_mission_item(offset, next_position_mission_item)) {

			if (item_contains_position(*next_position_mission_item)) {
				*has_next_position_item = true;
				break;
			}

			if (_mission_execution_mode == mission_result_s::MISSION_EXECUTION_MODE_REVERSE) {
				offset--;

			} else {
				offset++;

			}
		}
	}

	return first_res;
}

bool
Mission::read_mission_item(int offset, struct mission_item_s *mission_item)
{
	/* select mission */
	const int current_index = _current_mission_index;
	int index_to_read = current_index + offset;

	int *mission_index_ptr = (offset == 0) ? &_current_mission_index : &index_to_read;
	const dm_item_t dm_item = (dm_item_t)_mission.dataman_id;

	/* do not work on empty missions */
	if (_mission.count == 0) {
		return false;
	}

	/* Repeat this several times in case there are several DO JUMPS that we need to follow along, however, after
	 * 10 iterations we have to assume that the DO JUMPS are probably cycling and give up. */
	for (int i = 0; i < 10; i++) {
		if (*mission_index_ptr < 0 || *mission_index_ptr >= (int)_mission.count) {
			/* mission item index out of bounds - if they are equal, we just reached the end */
			if ((*mission_index_ptr != (int)_mission.count) && (*mission_index_ptr != -1)) {
				mavlink_log_critical(_navigator->get_mavlink_log_pub(), ""Mission item index out of bound, index: %d, max: %d."",
						     *mission_index_ptr, _mission.count);
			}

			return false;
		}

		const ssize_t len = sizeof(struct mission_item_s);

		/* read mission item to temp storage first to not overwrite current mission item if data damaged */
		struct mission_item_s mission_item_tmp;

		/* read mission item from datamanager */
		if (dm_read(dm_item, *mission_index_ptr, &mission_item_tmp, len) != len) {
			/* not supposed to happen unless the datamanager can't access the SD card, etc. */
			mavlink_log_critical(_navigator->get_mavlink_log_pub(), ""Waypoint could not be read."");
			return false;
		}

		/* check for DO_JUMP item, and whether it hasn't not already been repeated enough times */
		if (mission_item_tmp.nav_cmd == NAV_CMD_DO_JUMP) {
			const bool execute_jumps = _mission_execution_mode == mission_result_s::MISSION_EXECUTION_MODE_NORMAL;

			/* do DO_JUMP as many times as requested if not in reverse mode */
			if ((mission_item_tmp.do_jump_current_count < mission_item_tmp.do_jump_repeat_count) && execute_jumps) {

				/* only raise the repeat count if this is for the current mission item
				 * but not for the read ahead mission item */
				if (offset == 0) {
					(mission_item_tmp.do_jump_current_count)++;

					/* save repeat count */
					if (dm_write(dm_item, *mission_index_ptr, DM_PERSIST_POWER_ON_RESET, &mission_item_tmp, len) != len) {
						/* not supposed to happen unless the datamanager can't access the dataman */
						mavlink_log_critical(_navigator->get_mavlink_log_pub(), ""DO JUMP waypoint could not be written."");
						return false;
					}

					report_do_jump_mission_changed(*mission_index_ptr, mission_item_tmp.do_jump_repeat_count);
				}

				/* set new mission item index and repeat
				 * we don't have to validate here, if it's invalid, we should realize this later .*/
				*mission_index_ptr = mission_item_tmp.do_jump_mission_index;

			} else {
				if (offset == 0 && execute_jumps) {
					mavlink_log_info(_navigator->get_mavlink_log_pub(), ""DO JUMP repetitions completed."");
				}

				/* no more DO_JUMPS, therefore just try to continue with next mission item */
				if (_mission_execution_mode == mission_result_s::MISSION_EXECUTION_MODE_REVERSE) {
					(*mission_index_ptr)--;

				} else {
					(*mission_index_ptr)++;
				}
			}

		} else {
			/* if it's not a DO_JUMP, then we were successful */
			memcpy(mission_item, &mission_item_tmp, sizeof(struct mission_item_s));
			return true;
		}
	}

	/* we have given up, we don't want to cycle forever */
	mavlink_log_critical(_navigator->get_mavlink_log_pub(), ""DO JUMP is cycling, giving up."");
	return false;
}

void
Mission::save_mission_state()
{
	mission_s mission_state = {};

	/* lock MISSION_STATE item */
	int dm_lock_ret = dm_lock(DM_KEY_MISSION_STATE);

	if (dm_lock_ret != 0) {
		PX4_ERR(""DM_KEY_MISSION_STATE lock failed"");
	}

	/* read current state */
	int read_res = dm_read(DM_KEY_MISSION_STATE, 0, &mission_state, sizeof(mission_s));

	if (read_res == sizeof(mission_s)) {
		/* data read successfully, check dataman ID and items count */
		if (mission_state.dataman_id == _mission.dataman_id && mission_state.count == _mission.count) {
			/* navigator may modify only sequence, write modified state only if it changed */
			if (mission_state.current_seq != _current_mission_index) {
				mission_state.current_seq = _current_mission_index;
				mission_state.timestamp = hrt_absolute_time();

				if (dm_write(DM_KEY_MISSION_STATE, 0, DM_PERSIST_POWER_ON_RESET, &mission_state,
					     sizeof(mission_s)) != sizeof(mission_s)) {

					PX4_ERR(""Can't save mission state"");
				}
			}
		}

	} else {
		/* invalid data, this must not happen and indicates error in mission publisher */
		mission_state.timestamp = hrt_absolute_time();
		mission_state.dataman_id = _mission.dataman_id;
		mission_state.count = _mission.count;
		mission_state.current_seq = _current_mission_index;

		mavlink_log_critical(_navigator->get_mavlink_log_pub(), ""Invalid mission state."");

		/* write modified state only if changed */
		if (dm_write(DM_KEY_MISSION_STATE, 0, DM_PERSIST_POWER_ON_RESET, &mission_state,
			     sizeof(mission_s)) != sizeof(mission_s)) {

			PX4_ERR(""Can't save mission state"");
		}
	}

	/* unlock MISSION_STATE item */
	if (dm_lock_ret == 0) {
		dm_unlock(DM_KEY_MISSION_STATE);
	}
}

void
Mission::report_do_jump_mission_changed(int index, int do_jumps_remaining)
{
	/* inform about the change */
	_navigator->get_mission_result()->item_do_jump_changed = true;
	_navigator->get_mission_result()->item_changed_index = index;
	_navigator->get_mission_result()->item_do_jump_remaining = do_jumps_remaining;

	_navigator->set_mission_result_updated();
}

void
Mission::set_mission_item_reached()
{
	_navigator->get_mission_result()->seq_reached = _current_mission_index;
	_navigator->set_mission_result_updated();

	reset_mission_item_reached();
}

void
Mission::set_current_mission_item()
{
	_navigator->get_mission_result()->finished = false;
	_navigator->get_mission_result()->seq_current = _current_mission_index;

	_navigator->set_mission_result_updated();

	save_mission_state();
}

void
Mission::check_mission_valid(bool force)
{
	if ((!_home_inited && _navigator->home_position_valid()) || force) {

		MissionFeasibilityChecker _missionFeasibilityChecker(_navigator);

		_navigator->get_mission_result()->valid =
			_missionFeasibilityChecker.checkMissionFeasible(_mission,
					_param_mis_dist_1wp.get(),
					_param_mis_dist_wps.get(),
					_navigator->mission_landing_required());

		_navigator->get_mission_result()->seq_total = _mission.count;
		_navigator->increment_mission_instance_count();
		_navigator->set_mission_result_updated();
		_home_inited = _navigator->home_position_valid();

		// find and store landing start marker (if available)
		find_mission_land_start();
	}
}

void
Mission::reset_mission(struct mission_s &mission)
{
	dm_lock(DM_KEY_MISSION_STATE);

	if (dm_read(DM_KEY_MISSION_STATE, 0, &mission, sizeof(mission_s)) == sizeof(mission_s)) {
		if (mission.dataman_id == DM_KEY_WAYPOINTS_OFFBOARD_0 || mission.dataman_id == DM_KEY_WAYPOINTS_OFFBOARD_1) {
			/* set current item to 0 */
			mission.current_seq = 0;

			/* reset jump counters */
			if (mission.count > 0) {
				const dm_item_t dm_current = (dm_item_t)mission.dataman_id;

				for (unsigned index = 0; index < mission.count; index++) {
					struct mission_item_s item;
					const ssize_t len = sizeof(struct mission_item_s);

					if (dm_read(dm_current, index, &item, len) != len) {
						PX4_WARN(""could not read mission item during reset"");
						break;
					}

					if (item.nav_cmd == NAV_CMD_DO_JUMP) {
						item.do_jump_current_count = 0;

						if (dm_write(dm_current, index, DM_PERSIST_POWER_ON_RESET, &item, len) != len) {
							PX4_WARN(""could not save mission item during reset"");
							break;
						}
					}
				}
			}

		} else {
			mavlink_log_critical(_navigator->get_mavlink_log_pub(), ""Could not read mission."");

			/* initialize mission state in dataman */
			mission.timestamp = hrt_absolute_time();
			mission.dataman_id = DM_KEY_WAYPOINTS_OFFBOARD_0;
			mission.count = 0;
			mission.current_seq = 0;
		}

		dm_write(DM_KEY_MISSION_STATE, 0, DM_PERSIST_POWER_ON_RESET, &mission, sizeof(mission_s));
	}

	dm_unlock(DM_KEY_MISSION_STATE);
}

bool
Mission::need_to_reset_mission(bool active)
{
	/* reset mission state when disarmed */
	if (_navigator->get_vstatus()->arming_state != vehicle_status_s::ARMING_STATE_ARMED && _need_mission_reset) {
		_need_mission_reset = false;
		return true;

	} else if (_navigator->get_vstatus()->arming_state == vehicle_status_s::ARMING_STATE_ARMED && active) {
		/* mission is running, need reset after disarm */
		_need_mission_reset = true;
	}

	return false;
}

void
Mission::generate_waypoint_from_heading(struct position_setpoint_s *setpoint, float yaw)
{
	waypoint_from_heading_and_distance(
		_navigator->get_global_position()->lat, _navigator->get_global_position()->lon,
		yaw, 1000000.0f,
		&(setpoint->lat), &(setpoint->lon));
	setpoint->type = position_setpoint_s::SETPOINT_TYPE_POSITION;
	setpoint->yaw = yaw;
}

int32_t
Mission::index_closest_mission_item() const
{
	int32_t min_dist_index(0);
	float min_dist(FLT_MAX), dist_xy(FLT_MAX), dist_z(FLT_MAX);

	dm_item_t dm_current = (dm_item_t)(_mission.dataman_id);

	for (size_t i = 0; i < _mission.count; i++) {
		struct mission_item_s missionitem = {};
		const ssize_t len = sizeof(missionitem);

		if (dm_read(dm_current, i, &missionitem, len) != len) {
			/* not supposed to happen unless the datamanager can't access the SD card, etc. */
			PX4_ERR(""dataman read failure"");
			break;
		}

		if (item_contains_position(missionitem)) {
			// do not consider land waypoints for a fw
			if (!((missionitem.nav_cmd == NAV_CMD_LAND) &&
			      (_navigator->get_vstatus()->vehicle_type == vehicle_status_s::VEHICLE_TYPE_FIXED_WING) &&
			      (!_navigator->get_vstatus()->is_vtol))) {
				float dist = get_distance_to_point_global_wgs84(missionitem.lat, missionitem.lon,
						get_absolute_altitude_for_item(missionitem),
						_navigator->get_global_position()->lat,
						_navigator->get_global_position()->lon,
						_navigator->get_global_position()->alt,
						&dist_xy, &dist_z);

				if (dist < min_dist) {
					min_dist = dist;
					min_dist_index = i;
				}
			}
		}
	}

	// for mission reverse also consider the home position
	if (_mission_execution_mode == mission_result_s::MISSION_EXECUTION_MODE_REVERSE) {
		float dist = get_distance_to_point_global_wgs84(
				     _navigator->get_home_position()->lat,
				     _navigator->get_home_position()->lon,
				     _navigator->get_home_position()->alt,
				     _navigator->get_global_position()->lat,
				     _navigator->get_global_position()->lon,
				     _navigator->get_global_position()->alt,
				     &dist_xy, &dist_z);

		if (dist < min_dist) {
			min_dist = dist;
			min_dist_index = -1;
		}
	}

	return min_dist_index;
}

bool Mission::position_setpoint_equal(const position_setpoint_s *p1, const position_setpoint_s *p2) const
{
	return ((p1->valid == p2->valid) &&
		(p1->type == p2->type) &&
		(fabsf(p1->x - p2->x) < FLT_EPSILON) &&
		(fabsf(p1->y - p2->y) < FLT_EPSILON) &&
		(fabsf(p1->z - p2->z) < FLT_EPSILON) &&
		(p1->position_valid == p2->position_valid) &&
		(fabsf(p1->vx - p2->vx) < FLT_EPSILON) &&
		(fabsf(p1->vy - p2->vy) < FLT_EPSILON) &&
		(fabsf(p1->vz - p2->vz) < FLT_EPSILON) &&
		(p1->velocity_valid == p2->velocity_valid) &&
		(p1->velocity_frame == p2->velocity_frame) &&
		(p1->alt_valid == p2->alt_valid) &&
		(fabs(p1->lat - p2->lat) < DBL_EPSILON) &&
		(fabs(p1->lon - p2->lon) < DBL_EPSILON) &&
		(fabsf(p1->alt - p2->alt) < FLT_EPSILON) &&
		((fabsf(p1->yaw - p2->yaw) < FLT_EPSILON) || (!PX4_ISFINITE(p1->yaw) && !PX4_ISFINITE(p2->yaw))) &&
		(p1->yaw_valid == p2->yaw_valid) &&
		(fabsf(p1->yawspeed - p2->yawspeed) < FLT_EPSILON) &&
		(p1->yawspeed_valid == p2->yawspeed_valid) &&
		(fabsf(p1->loiter_radius - p2->loiter_radius) < FLT_EPSILON) &&
		(p1->loiter_direction == p2->loiter_direction) &&
		(fabsf(p1->pitch_min - p2->pitch_min) < FLT_EPSILON) &&
		(fabsf(p1->a_x - p2->a_x) < FLT_EPSILON) &&
		(fabsf(p1->a_y - p2->a_y) < FLT_EPSILON) &&
		(fabsf(p1->a_z - p2->a_z) < FLT_EPSILON) &&
		(p1->acceleration_valid == p2->acceleration_valid) &&
		(p1->acceleration_is_force == p2->acceleration_is_force) &&
		(fabsf(p1->acceptance_radius - p2->acceptance_radius) < FLT_EPSILON) &&
		(fabsf(p1->cruising_speed - p2->cruising_speed) < FLT_EPSILON) &&
		(fabsf(p1->cruising_throttle - p2->cruising_throttle) < FLT_EPSILON));

}
",16265,True,3379.010910959692,median
"[[jpa.repositories]]
= JPA Repositories

This chapter points out the specialties for repository support for JPA. This builds on the core repository support explained in ""`<<repositories>>`"". Make sure you have a sound understanding of the basic concepts explained there.

[[jpa.introduction]]
== Introduction

This section describes the basics of configuring Spring Data JPA through either:

* ""`<<jpa.namespace>>`"" (XML configuration)
* ""`<<jpa.java-config>>`"" (Java configuration)

[[jpa.namespace]]
=== Spring Namespace

The JPA module of Spring Data contains a custom namespace that allows defining repository beans. It also contains certain features and element attributes that are special to JPA. Generally, the JPA repositories can be set up by   using the `repositories` element, as shown in the following example:

.Setting up JPA repositories by using the namespace
====
[source, xml]
----
<?xml version=""1.0"" encoding=""UTF-8""?>
<beans xmlns=""http://www.springframework.org/schema/beans""
  xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance""
  xmlns:jpa=""http://www.springframework.org/schema/data/jpa""
  xsi:schemaLocation=""http://www.springframework.org/schema/beans
    https://www.springframework.org/schema/beans/spring-beans.xsd
    http://www.springframework.org/schema/data/jpa
    https://www.springframework.org/schema/data/jpa/spring-jpa.xsd"">

  <jpa:repositories base-package=""com.acme.repositories"" />

</beans>
----
====

Using the `repositories` element looks up Spring Data repositories as described in ""`<<repositories.create-instances>>`"". Beyond that, it activates persistence exception translation for all beans annotated with `@Repository`, to let exceptions being thrown by the JPA persistence providers be converted into Spring's `DataAccessException` hierarchy.

[[jpa.namespace.custom-namespace-attributes]]
==== Custom Namespace Attributes
Beyond the default attributes of the `repositories` element, the JPA namespace offers additional attributes to let you gain more detailed control over the setup of the repositories:

.Custom JPA-specific attributes of the `repositories` element
[options = ""autowidth""]
|===============
|`entity-manager-factory-ref`|Explicitly wire the `EntityManagerFactory` to be used with the repositories being detected by the `repositories` element. Usually used if multiple `EntityManagerFactory` beans are used within the application. If not configured, Spring Data automatically looks up the `EntityManagerFactory` bean with the name `entityManagerFactory` in the `ApplicationContext`.
|`transaction-manager-ref`|Explicitly wire the `PlatformTransactionManager` to be used with the repositories being detected by the `repositories` element. Usually only necessary if multiple transaction managers or `EntityManagerFactory` beans have been configured. Default to a single defined `PlatformTransactionManager` inside the current `ApplicationContext`.
|===============

NOTE: Spring Data JPA requires a `PlatformTransactionManager` bean named `transactionManager` to be present if no explicit `transaction-manager-ref` is defined.

[[jpa.java-config]]
=== Annotation-based Configuration
The Spring Data JPA repositories support can be activated not only through an XML namespace but also by using an annotation through JavaConfig, as shown in the following example:

.Spring Data JPA repositories using JavaConfig
====
[source, java]
----
@Configuration
@EnableJpaRepositories
@EnableTransactionManagement
class ApplicationConfig {

  @Bean
  public DataSource dataSource() {

    EmbeddedDatabaseBuilder builder = new EmbeddedDatabaseBuilder();
    return builder.setType(EmbeddedDatabaseType.HSQL).build();
  }

  @Bean
  public LocalContainerEntityManagerFactoryBean entityManagerFactory() {

    HibernateJpaVendorAdapter vendorAdapter = new HibernateJpaVendorAdapter();
    vendorAdapter.setGenerateDdl(true);

    LocalContainerEntityManagerFactoryBean factory = new LocalContainerEntityManagerFactoryBean();
    factory.setJpaVendorAdapter(vendorAdapter);
    factory.setPackagesToScan(""com.acme.domain"");
    factory.setDataSource(dataSource());
    return factory;
  }

  @Bean
  public PlatformTransactionManager transactionManager(EntityManagerFactory entityManagerFactory) {

    JpaTransactionManager txManager = new JpaTransactionManager();
    txManager.setEntityManagerFactory(entityManagerFactory);
    return txManager;
  }
}
----
====
NOTE: You must create `LocalContainerEntityManagerFactoryBean` and not `EntityManagerFactory` directly, since the former also participates in exception translation mechanisms in addition to creating `EntityManagerFactory`.

The preceding configuration class sets up an embedded HSQL database by using the `EmbeddedDatabaseBuilder` API of `spring-jdbc`. Spring Data then sets up an `EntityManagerFactory` and uses Hibernate as the sample persistence provider. The last infrastructure component declared here is the `JpaTransactionManager`. Finally, the example activates Spring Data JPA repositories by using the `@EnableJpaRepositories` annotation, which essentially carries the same attributes as the XML namespace. If no base package is configured, it uses the one in which the configuration class resides.

[[jpa.bootstrap-mode]]
=== Bootstrap Mode

By default, Spring Data JPA repositories are default Spring beans.
They are singleton scoped and eagerly initialized.
During startup, they already interact with the JPA `EntityManager` for verification and metadata analysis purposes.
Spring Framework supports the initialization of the JPA `EntityManagerFactory` in a background thread because that process usually takes up a significant amount of startup time in a Spring application.
To make use of that background initialization effectively, we need to make sure that JPA repositories are initialized as late as possible.

As of Spring Data JPA 2.1 you can now configure a `BootstrapMode` (either via the `@EnableJpaRepositories` annotation or the XML namespace) that takes the following values:

* `DEFAULT` (default) -- Repositories are instantiated eagerly unless explicitly annotated with `@Lazy`.
The lazification only has effect if no client bean needs an instance of the repository as that will require the initialization of the repository bean.
* `LAZY` -- Implicitly declares all repository beans lazy and also causes lazy initialization proxies to be created to be injected into client beans.
That means, that repositories will not get instantiated if the client bean is simply storing the instance in a field and not making use of the repository during initialization.
Repository instances will be initialized and verified upon first interaction with the repository.
* `DEFERRED` -- Fundamentally the same mode of operation as `LAZY`, but triggering repository initialization in response to an `ContextRefreshedEvent` so that repositories are verified before the application has completely started.

[[jpa.bootstrap-mode.recommendations]]
==== Recommendations

If you're not using asynchronous JPA bootstrap stick with the default bootstrap mode.

In case you bootstrap JPA asynchronously, `DEFERRED` is a reasonable default as it will make sure the Spring Data JPA bootstrap only waits for the `EntityManagerFactory` setup if that itself takes longer than initializing all other application components.
Still, it makes sure that repositories are properly initialized and validated before the application signals it's up.

`LAZY` is a decent choice for testing scenarios and local development.
Once you are pretty sure that repositories can properly bootstrap, or in cases where you are testing other parts of the application, running verification for all repositories might unnecessarily increase the startup time.
The same applies to local development in which you only access parts of the application that might need to have a single repository initialized.

[[jpa.entity-persistence]]
== Persisting Entities

This section describes how to persist (save) entities with Spring Data JPA.

[[jpa.entity-persistence.saving-entites]]
=== Saving Entities

Saving an entity can be performed with the `CrudRepository.save(…)` method. It persists or merges the given entity by using the underlying JPA `EntityManager`. If the entity has not yet been persisted, Spring Data JPA saves the entity with a call to the `entityManager.persist(…)` method. Otherwise, it calls the `entityManager.merge(…)` method.

[[jpa.entity-persistence.saving-entites.strategies]]
==== Entity State-detection Strategies
Spring Data JPA offers the following strategies to detect whether an entity is new or not:

1. Version-Property and Id-Property inspection (*default*):
   By default Spring Data JPA inspects first if there is a Version-property of non-primitive type.
   If there is, the entity is considered new if the value of that property is `null`.
   Without such a Version-property Spring Data JPA inspects the identifier property of the given entity.
   If the identifier property is `null`, then the entity is assumed to be new.
   Otherwise, it is assumed to be not new.
2. Implementing `Persistable`: If an entity implements `Persistable`, Spring Data JPA delegates the new detection to the `isNew(…)` method of the entity. See the link:$$https://docs.spring.io/spring-data/data-commons/docs/current/api/index.html?org/springframework/data/domain/Persistable.html$$[JavaDoc] for details.
3. Implementing `EntityInformation`: You can customize the `EntityInformation` abstraction used in the `SimpleJpaRepository` implementation by creating a subclass of `JpaRepositoryFactory` and overriding the `getEntityInformation(…)` method accordingly. You then have to register the custom implementation of `JpaRepositoryFactory` as a Spring bean. Note that this should be rarely necessary. See the link:$$https://docs.spring.io/spring-data/data-jpa/docs/current/api/index.html?org/springframework/data/jpa/repository/support/JpaRepositoryFactory.html$$[JavaDoc] for details.

Option 1 is not an option for entities that use manually assigned identifiers and no version attribute as with those the identifier will always be non-`null`.
A common pattern in that scenario is to use a common base class with a transient flag defaulting to indicate a new instance and using JPA lifecycle callbacks to flip that flag on persistence operations:

.A base class for entities with manually assigned identifiers
====
[source, java]
----
@MappedSuperclass
public abstract class AbstractEntity<ID> implements Persistable<ID> {

  @Transient
  private boolean isNew = true; <1>

  @Override
  public boolean isNew() {
    return isNew; <2>
  }

  @PrePersist <3>
  @PostLoad
  void markNotNew() {
    this.isNew = false;
  }

  // More code…
}
----
<1> Declare a flag to hold the new state. Transient so that it's not persisted to the database.
<2> Return the flag in the implementation of `Persistable.isNew()` so that Spring Data repositories know whether to call `EntityManager.persist()` or `….merge()`.
<3> Declare a method using JPA entity callbacks so that the flag is switched to indicate an existing entity after a repository call to `save(…)` or an instance creation by the persistence provider.
====

[[jpa.query-methods]]
== Query Methods

This section describes the various ways to create a query with Spring Data JPA.

[[jpa.sample-app.finders.strategies]]
=== Query Lookup Strategies

The JPA module supports defining a query manually as a String or having it being derived from the method name.

Derived queries with the predicates `IsStartingWith`, `StartingWith`, `StartsWith`, `IsEndingWith`, `EndingWith`, `EndsWith`,
`IsNotContaining`, `NotContaining`, `NotContains`, `IsContaining`, `Containing`, `Contains` the respective arguments for these queries will get sanitized.
This means if the arguments actually contain characters recognized by `LIKE` as wildcards these will get escaped so they match only as literals.
The escape character used can be configured by setting the `escapeCharacter` of the `@EnableJpaRepositories` annotation.
Compare with <<jpa.query.spel-expressions>>.

[[jpa.query-methods.declared-queries]]
==== Declared Queries
Although getting a query derived from the method name is quite convenient, one might face the situation in which either the method name parser does not support the keyword one wants to use or the method name would get unnecessarily ugly. So you can either use JPA named queries through a naming convention (see <<jpa.query-methods.named-queries>> for more information) or rather annotate your query method with `@Query` (see <<jpa.query-methods.at-query>> for details).

[[jpa.query-methods.query-creation]]
=== Query Creation

Generally, the query creation mechanism for JPA works as described in ""`<<repositories.query-methods>>`"". The following example shows what a JPA query method translates into:

.Query creation from method names
====
----
public interface UserRepository extends Repository<User, Long> {

  List<User> findByEmailAddressAndLastname(String emailAddress, String lastname);
}
----
We create a query using the JPA criteria API from this, but, essentially, this translates into the following query: `select u from User u where u.emailAddress = ?1 and u.lastname = ?2`. Spring Data JPA does a property check and traverses nested properties, as described in ""`<<repositories.query-methods.query-property-expressions>>`"".
====

The following table describes the keywords supported for JPA and what a method containing that keyword translates to:

.Supported keywords inside method names
[options = ""header, autowidth""]
|===============
|Keyword|Sample|JPQL snippet
|`Distinct`|`findDistinctByLastnameAndFirstname`|`select distinct ... where x.lastname = ?1 and x.firstname = ?2`
|`And`|`findByLastnameAndFirstname`|`… where x.lastname = ?1 and x.firstname = ?2`
|`Or`|`findByLastnameOrFirstname`|`… where x.lastname = ?1 or x.firstname = ?2`
|`Is`, `Equals`|`findByFirstname`,`findByFirstnameIs`,`findByFirstnameEquals`|`… where x.firstname = ?1`
|`Between`|`findByStartDateBetween`|`… where x.startDate between ?1 and ?2`
|`LessThan`|`findByAgeLessThan`|`… where x.age < ?1`
|`LessThanEqual`|`findByAgeLessThanEqual`|`… where x.age \\<= ?1`
|`GreaterThan`|`findByAgeGreaterThan`|`… where x.age > ?1`
|`GreaterThanEqual`|`findByAgeGreaterThanEqual`|`… where x.age >= ?1`
|`After`|`findByStartDateAfter`|`… where x.startDate > ?1`
|`Before`|`findByStartDateBefore`|`… where x.startDate < ?1`
|`IsNull`, `Null`|`findByAge(Is)Null`|`… where x.age is null`
|`IsNotNull`, `NotNull`|`findByAge(Is)NotNull`|`… where x.age not null`
|`Like`|`findByFirstnameLike`|`… where x.firstname like ?1`
|`NotLike`|`findByFirstnameNotLike`|`… where x.firstname not like ?1`
|`StartingWith`|`findByFirstnameStartingWith`|`… where x.firstname like ?1` (parameter bound with appended `%`)
|`EndingWith`|`findByFirstnameEndingWith`|`… where x.firstname like ?1` (parameter bound with prepended `%`)
|`Containing`|`findByFirstnameContaining`|`… where x.firstname like ?1` (parameter bound wrapped in `%`)
|`OrderBy`|`findByAgeOrderByLastnameDesc`|`… where x.age = ?1 order by x.lastname desc`
|`Not`|`findByLastnameNot`|`… where x.lastname <> ?1`
|`In`|`findByAgeIn(Collection<Age> ages)`|`… where x.age in ?1`
|`NotIn`|`findByAgeNotIn(Collection<Age> ages)`|`… where x.age not in ?1`
|`True`|`findByActiveTrue()`|`… where x.active = true`
|`False`|`findByActiveFalse()`|`… where x.active = false`
|`IgnoreCase`|`findByFirstnameIgnoreCase`|`… where UPPER(x.firstname) = UPPER(?1)`
|===============

NOTE: `In` and `NotIn` also take any subclass of `Collection` as a parameter as well as arrays or varargs. For other syntactical versions of the same logical operator, check ""`<<repository-query-keywords>>`"".

[[jpa.query-methods.named-queries]]
=== Using JPA Named Queries

NOTE: The examples use the `<named-query />` element and `@NamedQuery` annotation. The queries for these configuration elements have to be defined in the JPA query language. Of course, you can use `<named-native-query />` or `@NamedNativeQuery` too. These elements let you define the query in native SQL by losing the database platform independence.

[[jpa.query-methods.named-queries.xml-named-query-definition]]
==== XML Named Query Definition
To use XML configuration, add the necessary `<named-query />` element to the `orm.xml` JPA configuration file located in the `META-INF` folder of your classpath. Automatic invocation of named queries is enabled by using some defined naming convention. For more details, see below.

.XML named query configuration
====
[source, xml]
----
<named-query name=""User.findByLastname"">
  <query>select u from User u where u.lastname = ?1</query>
</named-query>
----
====

The query has a special name that is used to resolve it at runtime.

[[jpa.query-methods.named-queries.annotation-based-configuration]]
==== Annotation-based Configuration
Annotation-based configuration has the advantage of not needing another configuration file to be edited, lowering maintenance effort. You pay for that benefit by the need to recompile your domain class for every new query declaration.

.Annotation-based named query configuration
====
[source, java]
----
@Entity
@NamedQuery(name = ""User.findByEmailAddress"",
  query = ""select u from User u where u.emailAddress = ?1"")
public class User {

}
----
====

[[jpa.query-methods.named-queries.declaring-interfaces]]
==== Declaring Interfaces
To allow these named queries, specify the `UserRepository` as follows:

.Query method declaration in UserRepository
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  List<User> findByLastname(String lastname);

  User findByEmailAddress(String emailAddress);
}
----
====

Spring Data tries to resolve a call to these methods to a named query, starting with the simple name of the configured domain class, followed by the method name separated by a dot.
So the preceding example would use the named queries defined earlier instead of trying to create a query from the method name.

[[jpa.query-methods.at-query]]
=== Using `@Query`

Using named queries to declare queries for entities is a valid approach and works fine for a small number of queries. As the queries themselves are tied to the Java method that runs them, you can actually bind them directly by using the Spring Data JPA `@Query` annotation rather than annotating them to the domain class. This frees the domain class from persistence specific information and co-locates the query to the repository interface.

Queries annotated to the query method take precedence over queries defined using `@NamedQuery` or named queries declared in `orm.xml`.

The following example shows a query created with the `@Query` annotation:

.Declare query at the query method using `@Query`
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(""select u from User u where u.emailAddress = ?1"")
  User findByEmailAddress(String emailAddress);
}
----
====

[[jpa.query-methods.at-query.advanced-like]]
==== Using Advanced `LIKE` Expressions

The query running mechanism for manually defined queries created with `@Query` allows the definition of advanced `LIKE` expressions inside the query definition, as shown in the following example:

.Advanced `like` expressions in @Query
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(""select u from User u where u.firstname like %?1"")
  List<User> findByFirstnameEndsWith(String firstname);
}
----
====

In the preceding example, the `LIKE` delimiter character (`%`) is recognized, and the query is transformed into a valid JPQL query (removing the `%`). Upon running the query, the parameter passed to the method call gets augmented with the previously recognized `LIKE` pattern.

[[jpa.query-methods.at-query.native]]
==== Native Queries

The `@Query` annotation allows for running native queries by setting the `nativeQuery` flag to true, as shown in the following example:

.Declare a native query at the query method using @Query
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(value = ""SELECT * FROM USERS WHERE EMAIL_ADDRESS = ?1"", nativeQuery = true)
  User findByEmailAddress(String emailAddress);
}
----

====

NOTE: Spring Data JPA does not currently support dynamic sorting for native queries, because it would have to manipulate the actual query declared, which it cannot do reliably for native SQL. You can, however, use native queries for pagination by specifying the count query yourself, as shown in the following example:

.Declare native count queries for pagination at the query method by using `@Query`
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(value = ""SELECT * FROM USERS WHERE LASTNAME = ?1"",
    countQuery = ""SELECT count(*) FROM USERS WHERE LASTNAME = ?1"",
    nativeQuery = true)
  Page<User> findByLastname(String lastname, Pageable pageable);
}
----

====

A similar approach also works with named native queries, by adding the `.count` suffix to a copy of your query. You probably need to register a result set mapping for your count query, though.

[[jpa.query-methods.sorting]]
=== Using Sort

Sorting can be done by either providing a `PageRequest` or by using `Sort` directly. The properties actually used within the `Order` instances of `Sort` need to match your domain model, which means they need to resolve to either a property or an alias used within the query. The JPQL defines this as a state field path expression.

NOTE: Using any non-referenceable path expression leads to an `Exception`.

However, using `Sort` together with <<jpa.query-methods.at-query, `@Query`>> lets you sneak in non-path-checked `Order` instances containing functions within the `ORDER BY` clause. This is possible because the `Order` is appended to the given query string. By default, Spring Data JPA rejects any `Order` instance containing function calls, but you can use `JpaSort.unsafe` to add potentially unsafe ordering.

The following example uses `Sort` and `JpaSort`, including an unsafe option on `JpaSort`:

.Using `Sort` and `JpaSort`
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(""select u from User u where u.lastname like ?1%"")
  List<User> findByAndSort(String lastname, Sort sort);

  @Query(""select u.id, LENGTH(u.firstname) as fn_len from User u where u.lastname like ?1%"")
  List<Object[]> findByAsArrayAndSort(String lastname, Sort sort);
}

repo.findByAndSort(""lannister"", Sort.by(""firstname""));                <1>
repo.findByAndSort(""stark"", Sort.by(""LENGTH(firstname)""));            <2>
repo.findByAndSort(""targaryen"", JpaSort.unsafe(""LENGTH(firstname)"")); <3>
repo.findByAsArrayAndSort(""bolton"", Sort.by(""fn_len""));               <4>
----
<1> Valid `Sort` expression pointing to property in domain model.
<2> Invalid `Sort` containing function call. Throws Exception.
<3> Valid `Sort` containing explicitly _unsafe_ `Order`.
<4> Valid `Sort` expression pointing to aliased function.
====

[[jpa.named-parameters]]
=== Using Named Parameters

By default, Spring Data JPA uses position-based parameter binding, as described in all the preceding examples. This makes query methods a little error-prone when refactoring regarding the parameter position. To solve this issue, you can use `@Param` annotation to give a method parameter a concrete name and bind the name in the query, as shown in the following example:

.Using named parameters
====
[source, java]
----
public interface UserRepository extends JpaRepository<User, Long> {

  @Query(""select u from User u where u.firstname = :firstname or u.lastname = :lastname"")
  User findByLastnameOrFirstname(@Param(""lastname"") String lastname,
                                 @Param(""firstname"") String firstname);
}
----
====

NOTE: The method parameters are switched according to their order in the defined query.

NOTE: As of version 4, Spring fully supports Java 8’s parameter name discovery based on the `-parameters` compiler flag. By using this flag in your build as an alternative to debug information, you can omit the `@Param` annotation for named parameters.

[[jpa.query.spel-expressions]]
=== Using SpEL Expressions

As of Spring Data JPA release 1.4, we support the usage of restricted SpEL template expressions in manually defined queries that are defined with `@Query`. Upon the query being run, these expressions are evaluated against a predefined set of variables. Spring Data JPA supports a variable called `entityName`. Its usage is `select x from #{#entityName} x`. It inserts the `entityName` of the domain type associated with the given repository. The `entityName` is resolved as follows: If the domain type has set the name property on the `@Entity` annotation, it is used. Otherwise, the simple class-name of the domain type is used.

The following example demonstrates one use case for the `+#{#entityName}+` expression in a query string where you want to define a repository interface with a query method and a manually defined query:

.Using SpEL expressions in repository query methods - entityName
====
[source, java]
----
@Entity
public class User {

  @Id
  @GeneratedValue
  Long id;

  String lastname;
}

public interface UserRepository extends JpaRepository<User,Long> {

  @Query(""select u from #{#entityName} u where u.lastname = ?1"")
  List<User> findByLastname(String lastname);
}
----
====

To avoid stating the actual entity name in the query string of a `@Query` annotation, you can use the `+#{#entityName}+` variable.

NOTE: The `entityName` can be customized by using the `@Entity` annotation. Customizations in `orm.xml` are not supported for the SpEL expressions.

Of course, you could have just used `User` in the query declaration directly, but that would require you to change the query as well. The reference to `#entityName` picks up potential future remappings of the `User` class to a different entity name (for example, by using `@Entity(name = ""MyUser"")`.

Another use case for the `#{#entityName}` expression in a query string is if you want to define a generic repository interface with specialized repository interfaces for a concrete domain type. To not repeat the definition of custom query methods on the concrete interfaces, you can use the entity name expression in the query string of the `@Query` annotation in the generic repository interface, as shown in the following example:

.Using SpEL expressions in repository query methods - entityName with inheritance
====
[source, java]
----
@MappedSuperclass
public abstract class AbstractMappedType {
  …
  String attribute
}

@Entity
public class ConcreteType extends AbstractMappedType { … }

@NoRepositoryBean
public interface MappedTypeRepository<T extends AbstractMappedType>
  extends Repository<T, Long> {

  @Query(""select t from #{#entityName} t where t.attribute = ?1"")
  List<T> findAllByAttribute(String attribute);
}

public interface ConcreteRepository
  extends MappedTypeRepository<ConcreteType> { … }
----
====

In the preceding example, the `MappedTypeRepository` interface is the common parent interface for a few domain types extending `AbstractMappedType`. It also defines the generic `findAllByAttribute(…)` method, which can be used on instances of the specialized repository interfaces. If you now invoke `findByAllAttribute(…)` on `ConcreteRepository`, the query becomes `select t from ConcreteType t where t.attribute = ?1`.

SpEL expressions to manipulate arguments may also be used to manipulate method arguments.
In these SpEL expressions the entity name is not available, but the arguments are.
They can be accessed by name or index as demonstrated in the following example.

.Using SpEL expressions in repository query methods - accessing arguments.
====
[source, java]
----
@Query(""select u from User u where u.firstname = ?1 and u.firstname=?#{[0]} and u.emailAddress = ?#{principal.emailAddress}"")
List<User> findByFirstnameAndCurrentUserWithCustomQuery(String firstname);
----
====

For `like`-conditions one often wants to append `%` to the beginning or the end of a String valued parameter.
This can be done by appending or prefixing a bind parameter marker or a SpEL expression with `%`.
Again the following example demonstrates this.

.Using SpEL expressions in repository query methods - wildcard shortcut.
====
[source, java]
----
@Query(""select u from User u where u.lastname like %:#{[0]}% and u.lastname like %:lastname%"")
List<User> findByLastnameWithSpelExpression(@Param(""lastname"") String lastname);
----
====

When using `like`-conditions with values that are coming from a not secure source the values should be sanitized so they can't contain any wildcards and thereby allow attackers to select more data than they should be able to.
For this purpose the `escape(String)` method is made available in the SpEL context.
It prefixes all instances of `_` and `%` in the first argument with the single character from the second argument.
In combination with the `escape` clause of the `like` expression available in JPQL and standard SQL this allows easy cleaning of bind parameters.


.Using SpEL expressions in repository query methods - sanitizing input values.
====
[source, java]
----
@Query(""select u from User u where u.firstname like %?#{escape([0])}% escape ?#{escapeCharacter()}"")
List<User> findContainingEscaped(String namePart);
----
====

Given this method declaration in a repository interface `findContainingEscaped(""Peter_"")` will find `Peter_Parker` but not `Peter Parker`.
The escape character used can be configured by setting the `escapeCharacter` of the `@EnableJpaRepositories` annotation.
Note that the method `escape(String)` available in the SpEL context will only escape the SQL and JPQL standard wildcards `_` and `%`.
If the underlying database or the JPA implementation supports additional wildcards these will not get escaped.

[[jpa.modifying-queries]]
=== Modifying Queries

All the previous sections describe how to declare queries to access a given entity or collection of entities.
You can add custom modifying behavior by using the custom method facilities described in ""`<<repositories.custom-implementations>>`"".
As this approach is feasible for comprehensive custom functionality, you can modify queries that only need parameter binding by annotating the query method with `@Modifying`, as shown in the following example:

.Declaring manipulating queries
====
[source, java]
----
@Modifying
@Query(""update User u set u.firstname = ?1 where u.lastname = ?2"")
int setFixedFirstnameFor(String firstname, String lastname);
----
====

Doing so triggers the query annotated to the method as an updating query instead of a selecting one. As the `EntityManager` might contain outdated entities after the execution of the modifying query, we do not automatically clear it (see the https://docs.oracle.com/javaee/7/api/javax/persistence/EntityManager.html[JavaDoc] of `EntityManager.clear()` for details), since this effectively drops all non-flushed changes still pending in the `EntityManager`.
If you wish the `EntityManager` to be cleared automatically, you can set the `@Modifying` annotation's `clearAutomatically` attribute to `true`.

The `@Modifying` annotation is only relevant in combination with the `@Query` annotation.
Derived query methods or custom methods do not require this annotation.

[[jpa.modifying-queries.derived-delete]]
==== Derived Delete Queries
Spring Data JPA also supports derived delete queries that let you avoid having to declare the JPQL query explicitly, as shown in the following example:

.Using a derived delete query
====
[source, java]
----
interface UserRepository extends Repository<User, Long> {

  void deleteByRoleId(long roleId);

  @Modifying
  @Query(""delete from User u where u.role.id = ?1"")
  void deleteInBulkByRoleId(long roleId);
}
----
====

Although the `deleteByRoleId(…)` method looks like it basically produces the same result as the `deleteInBulkByRoleId(…)`, there is an important difference between the two method declarations in terms of the way they are run.
As the name suggests, the latter method issues a single JPQL query (the one defined in the annotation) against the database.
This means even currently loaded instances of `User` do not see lifecycle callbacks invoked.

To make sure lifecycle queries are actually invoked, an invocation of `deleteByRoleId(…)` runs a query and then deletes the returned instances one by one, so that the persistence provider can actually invoke `@PreRemove` callbacks on those entities.

In fact, a derived delete query is a shortcut for running the query and then calling `CrudRepository.delete(Iterable<User> users)` on the result and keeping behavior in sync with the implementations of other `delete(…)` methods in `CrudRepository`.

[[jpa.query-hints]]
=== Applying Query Hints
To apply JPA query hints to the queries declared in your repository interface, you can use the `@QueryHints` annotation. It takes an array of JPA `@QueryHint` annotations plus a boolean flag to potentially disable the hints applied to the additional count query triggered when applying pagination, as shown in the following example:

.Using QueryHints with a repository method
====
[source, java]
----
public interface UserRepository extends Repository<User, Long> {

  @QueryHints(value = { @QueryHint(name = ""name"", value = ""value"")},
              forCounting = false)
  Page<User> findByLastname(String lastname, Pageable pageable);
}
----
====
The preceding declaration would apply the configured `@QueryHint` for that actually query but omit applying it to the count query triggered to calculate the total number of pages.

[[jpa.entity-graph]]
=== Configuring Fetch- and LoadGraphs

The JPA 2.1 specification introduced support for specifying Fetch- and LoadGraphs that we also support with the `@EntityGraph` annotation, which lets you reference a `@NamedEntityGraph` definition. You can use that annotation on an entity to configure the fetch plan of the resulting query. The type (`Fetch` or `Load`) of the fetching can be configured by using the `type` attribute on the `@EntityGraph` annotation. See the JPA 2.1 Spec 3.7.4 for further reference.

The following example shows how to define a named entity graph on an entity:

.Defining a named entity graph on an entity.
====
[source, java]
----
@Entity
@NamedEntityGraph(name = ""GroupInfo.detail"",
  attributeNodes = @NamedAttributeNode(""members""))
public class GroupInfo {

  // default fetch mode is lazy.
  @ManyToMany
  List<GroupMember> members = new ArrayList<GroupMember>();

  …
}
----
====

The following example shows how to reference a named entity graph on a repository query method:

.Referencing a named entity graph definition on a repository query method.
====
[source, java]
----
@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 inherited from link:$$https://docs.spring.io/spring-data/data-jpa/docs/current/api/org/springframework/data/jpa/repository/support/SimpleJpaRepository.html$$[`SimpleJpaRepository`] are transactional.
For read operations, the transaction configuration `readOnly` flag is set to `true`.
All others are configured with a plain `@Transactional` so that default transaction configuration applies.
Repository methods that are backed by transactional repository fragments inherit the transactional attributes from the actual fragment method.

If you need to tweak transaction configuration for one of the methods declared in a repository, redeclare the method in your repository interface, as follows:

.Custom transaction configuration for CRUD
====
[source, java]
----
public interface UserRepository extends CrudRepository<User, Long> {

  @Override
  @Transactional(timeout = 10)
  public List<User> findAll();

  // Further query method declarations
}
----
Doing so causes the `findAll()` method to run with a timeout of 10 seconds and without the `readOnly` flag.
====

Another way to alter transactional behaviour is to use a facade or service implementation that (typically) covers more than one repository. Its purpose is to define transactional boundaries for non-CRUD operations. The following example shows how to use such a facade for more than one repository:

.Using a facade to define transactions for multiple repository calls
====
[source, java]
----
@Service
public class UserManagementImpl implements UserManagement {

  private final UserRepository userRepository;
  private final RoleRepository roleRepository;

  public UserManagementImpl(UserRepository userRepository,
    RoleRepository roleRepository) {
    this.userRepository = userRepository;
    this.roleRepository = roleRepository;
  }

  @Transactional
  public void addRoleToAllUsers(String roleName) {

    Role role = roleRepository.findByName(roleName);

    for (User user : userRepository.findAll()) {
      user.addRole(role);
      userRepository.save(user);
    }
  }
}
----
This example causes call to `addRoleToAllUsers(…)` to run inside a transaction (participating in an existing one or creating a new one if none are already running). The transaction configuration at the repositories is then neglected, as the outer transaction configuration determines the actual one used. Note that you must activate `<tx:annotation-driven />` or use `@EnableTransactionManagement` explicitly to get annotation-based configuration of facades to work.
This example assumes you use component scanning.

Note that the call to `save` is not strictly necessary from a JPA point of view, but should still be there in order to stay consistent to the repository abstraction offered by Spring Data.
====

[[transactional-query-methods]]
=== Transactional query methods

To let your query methods be transactional, use `@Transactional` at the repository interface you define, as shown in the following example:

.Using @Transactional at query methods
====
[source, java]
----
@Transactional(readOnly = true)
interface UserRepository extends JpaRepository<User, Long> {

  List<User> findByLastname(String lastname);

  @Modifying
  @Transactional
  @Query(""delete from User u where u.active = false"")
  void deleteInactiveUsers();
}
----
Typically, you want the `readOnly` flag to be set to `true`, as most of the query methods only read data. In contrast to that, `deleteInactiveUsers()` makes use of the `@Modifying` annotation and overrides the transaction configuration. Thus, the method runs with the `readOnly` flag set to `false`.
====

[NOTE]
====
You can use transactions for read-only queries and mark them as such by setting the `readOnly` flag. Doing so does not, however, act as a check that you do not trigger a manipulating query (although some databases reject `INSERT` and `UPDATE` statements inside a read-only transaction). The `readOnly` flag is instead propagated as a hint to the underlying JDBC driver for performance optimizations. Furthermore, Spring performs some optimizations on the underlying JPA provider. For example, when used with Hibernate, the flush mode is set to `NEVER` when you configure a transaction as `readOnly`, which causes Hibernate to skip dirty checks (a noticeable improvement on large object trees).
====

[[locking]]
== Locking
To specify the lock mode to be used, you can use the `@Lock` annotation on query methods, as shown in the following example:

.Defining lock metadata on query methods
====
[source, java]
----
interface UserRepository extends Repository<User, Long> {

  // Plain query method
  @Lock(LockModeType.READ)
  List<User> findByLastname(String lastname);
}
----
====

This method declaration causes the query being triggered to be equipped with a `LockModeType` of `READ`. You can also define locking for CRUD methods by redeclaring them in your repository interface and adding the `@Lock` annotation, as shown in the following example:

.Defining lock metadata on CRUD methods
====
[source, java]
----
interface UserRepository extends Repository<User, Long> {

  // Redeclaration of a CRUD method
  @Lock(LockModeType.READ)
  List<User> findAll();
}
----
====

:leveloffset: +1
include::{spring-data-commons-docs}/auditing.adoc[]
:leveloffset: -1

[[jpa.auditing]]
== JPA Auditing

[[jpa.auditing.configuration]]
=== General Auditing Configuration

Spring Data JPA ships with an entity listener that can be used to trigger the capturing of auditing information. First, you must register the `AuditingEntityListener` to be used for all entities in your persistence contexts inside your `orm.xml` file, as shown in the following example:

.Auditing configuration orm.xml
====
[source, xml]
----
<persistence-unit-metadata>
  <persistence-unit-defaults>
    <entity-listeners>
      <entity-listener class=""….data.jpa.domain.support.AuditingEntityListener"" />
    </entity-listeners>
  </persistence-unit-defaults>
</persistence-unit-metadata>
----
====

You can also enable the `AuditingEntityListener` on a per-entity basis by using the `@EntityListeners` annotation, as follows:

====
[source, java]
----
@Entity
@EntityListeners(AuditingEntityListener.class)
public class MyEntity {

}
----
====

NOTE: The auditing feature requires `spring-aspects.jar` to be on the classpath.

With `orm.xml` suitably modified and `spring-aspects.jar` on the classpath, activating auditing functionality is a matter of adding the Spring Data JPA `auditing` namespace element to your configuration, as follows:

.Activating auditing using XML configuration
====
[source, xml]
----
<jpa:auditing auditor-aware-ref=""yourAuditorAwareBean"" />
----
====

As of Spring Data JPA 1.5, you can enable auditing by annotating a configuration class with the `@EnableJpaAuditing` annotation. You must still modify the `orm.xml` file and have `spring-aspects.jar` on the classpath. The following example shows how to use the `@EnableJpaAuditing` annotation:

.Activating auditing with Java configuration
====
[source, java]
----
@Configuration
@EnableJpaAuditing
class Config {

  @Bean
  public AuditorAware<AuditableUser> auditorProvider() {
    return new AuditorAwareImpl();
  }
}
----
====

If you expose a bean of type `AuditorAware` to the `ApplicationContext`, the auditing infrastructure automatically picks it up and uses it to determine the current user to be set on domain types. If you have multiple implementations registered in the `ApplicationContext`, you can select the one to be used by explicitly setting the `auditorAwareRef` attribute of `@EnableJpaAuditing`.

[[jpa.misc]]
= Miscellaneous Considerations

[[jpa.misc.jpa-context]]
== Using `JpaContext` in Custom Implementations

When working with multiple `EntityManager` instances and <<repositories.custom-implementations,custom repository implementations>>, you need to wire the correct `EntityManager` into the repository implementation class. You can do so by explicitly naming the `EntityManager` in the `@PersistenceContext` annotation or, if the `EntityManager` is `@Autowired`, by using `@Qualifier`.

As of Spring Data JPA 1.9, Spring Data JPA includes a class called `JpaContext` that lets you obtain the `EntityManager` by managed domain class, assuming it is managed by only one of the `EntityManager` instances in the application. The following example shows how to use `JpaContext` in a custom repository:

.Using `JpaContext` in a custom repository implementation
====
[source, java]
----
class UserRepositoryImpl implements UserRepositoryCustom {

  private final EntityManager em;

  @Autowired
  public UserRepositoryImpl(JpaContext context) {
    this.em = context.getEntityManagerByManagedType(User.class);
  }

  …
}
----
====

The advantage of this approach is that, if the domain type gets assigned to a different persistence unit, the repository does not have to be touched to alter the reference to the persistence unit.

[[jpa.misc.merging-persistence-units]]
== Merging persistence units

Spring supports having multiple persistence units. Sometimes, however, you might want to modularize your application but still make sure that all these modules run inside a single persistence unit. To enable that behavior, Spring Data JPA offers a `PersistenceUnitManager` implementation that automatically merges persistence units based on their name, as shown in the following example:

.Using MergingPersistenceUnitmanager
====
[source, xml]
----
<bean class=""….LocalContainerEntityManagerFactoryBean"">
  <property name=""persistenceUnitManager"">
    <bean class=""….MergingPersistenceUnitManager"" />
  </property>
</bean>
----
====

[[jpa.misc.entity-scanning]]
=== Classpath Scanning for @Entity Classes and JPA Mapping Files

A plain JPA setup requires all annotation-mapped entity classes to be listed in `orm.xml`. The same applies to XML mapping files. Spring Data JPA provides a `ClasspathScanningPersistenceUnitPostProcessor` that gets a base package configured and optionally takes a mapping filename pattern. It then scans the given package for classes annotated with `@Entity` or `@MappedSuperclass`, loads the configuration files that match the filename pattern, and hands them to the JPA configuration. The post-processor must be configured as follows:

.Using ClasspathScanningPersistenceUnitPostProcessor
====
[source, xml]
----
<bean class=""….LocalContainerEntityManagerFactoryBean"">
  <property name=""persistenceUnitPostProcessors"">
    <list>
      <bean class=""org.springframework.data.jpa.support.ClasspathScanningPersistenceUnitPostProcessor"">
        <constructor-arg value=""com.acme.domain"" />
        <property name=""mappingFileNamePattern"" value=""**/*Mapping.xml"" />
      </bean>
    </list>
  </property>
</bean>
----
====

NOTE: As of Spring 3.1, a package to scan can be configured on the `LocalContainerEntityManagerFactoryBean` directly to enable classpath scanning for entity classes. See the link:$$https://docs.spring.io/spring/docs/current/javadoc-api/org/springframework/orm/jpa/LocalContainerEntityManagerFactoryBean.html#setPackagesToScan(java.lang.String...)$$[JavaDoc] for details.

[[jpd.misc.cdi-integration]]
== CDI Integration

Instances of the repository interfaces are usually created by a container, for which Spring is the most natural choice when working with Spring Data. Spring offers sophisticated support for creating bean instances, as documented in <<repositories.create-instances>>. As of version 1.1.0, Spring Data JPA ships with a custom CDI extension that allows using the repository abstraction in CDI environments. The extension is part of the JAR. To activate it, include the Spring Data JPA JAR on your classpath.

You can now set up the infrastructure by implementing a CDI Producer for the `EntityManagerFactory` and `EntityManager`, as shown in the following example:

[source, java]
----
class EntityManagerFactoryProducer {

  @Produces
  @ApplicationScoped
  public EntityManagerFactory createEntityManagerFactory() {
    return Persistence.createEntityManagerFactory(""my-persistence-unit"");
  }

  public void close(@Disposes EntityManagerFactory entityManagerFactory) {
    entityManagerFactory.close();
  }

  @Produces
  @RequestScoped
  public EntityManager createEntityManager(EntityManagerFactory entityManagerFactory) {
    return entityManagerFactory.createEntityManager();
  }

  public void close(@Disposes EntityManager entityManager) {
    entityManager.close();
  }
}
----

The necessary setup can vary depending on the JavaEE environment. You may need to do nothing more than redeclare a `EntityManager` as a CDI bean, as follows:

[source, java]
----
class CdiConfig {

  @Produces
  @RequestScoped
  @PersistenceContext
  public EntityManager entityManager;
}
----

In the preceding example, the container has to be capable of creating JPA `EntityManagers` itself. All the configuration does is re-export the JPA `EntityManager` as a CDI bean.

The Spring Data JPA CDI extension picks up all available `EntityManager` instances as CDI beans and creates a proxy for a Spring Data repository whenever a bean of a repository type is requested by the container. Thus, obtaining an instance of a Spring Data repository is a matter of declaring an `@Injected` property, as shown in the following example:

[source, java]
----
class RepositoryClient {

  @Inject
  PersonRepository repository;

  public void businessMethod() {
    List<Person> people = repository.findAll();
  }
}
----
",12088,False,2006.762570027164,median
"CLASS ltcl_syntax_cases DEFINITION DEFERRED.
CLASS zcl_timem_syntax_highlighter DEFINITION LOCAL FRIENDS ltcl_syntax_cases.

*----------------------------------------------------------------------*
*       CLASS ltcl_syntax_cases definition
*----------------------------------------------------------------------*
CLASS ltcl_syntax_cases DEFINITION FINAL FOR TESTING RISK LEVEL HARMLESS
    DURATION SHORT.

  PRIVATE SECTION.

    DATA:
      mt_after_parse  TYPE zcl_timem_syntax_highlighter=>ty_match_tt,
      mt_after_order  TYPE zcl_timem_syntax_highlighter=>ty_match_tt,
      mt_after_extend TYPE zcl_timem_syntax_highlighter=>ty_match_tt,
      ms_match        TYPE zcl_timem_syntax_highlighter=>ty_match.

    METHODS:
      do_test IMPORTING iv_line     TYPE string
                        iv_filename TYPE string,
      test_abap_01 FOR TESTING,
      test_abap_02 FOR TESTING,
      test_abap_03 FOR TESTING,
      test_abap_04 FOR TESTING,
      test_abap_05 FOR TESTING,
      test_abap_06 FOR TESTING,
      test_abap_07 FOR TESTING,
      test_abap_08 FOR TESTING,
      test_xml_01  FOR TESTING,
      test_xml_02  FOR TESTING,
      test_xml_03  FOR TESTING,
      test_xml_04  FOR TESTING,
      test_xml_05  FOR TESTING,
      test_xml_06  FOR TESTING,
      test_xml_07  FOR TESTING,
      test_xml_08  FOR TESTING.

ENDCLASS.
*----------------------------------------------------------------------*
*       CLASS ltcl_syntax_cases IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS ltcl_syntax_cases IMPLEMENTATION.

  DEFINE _generate_parse.
    ms_match-token    = &1.
    ms_match-offset   = &2.
    ms_match-length   = &3.
    APPEND ms_match TO mt_after_parse.
  END-OF-DEFINITION.

  DEFINE _generate_order.
    ms_match-token    = &1.
    ms_match-offset   = &2.
    ms_match-length   = &3.
    ms_match-text_tag = &4.
    APPEND ms_match TO mt_after_order.
  END-OF-DEFINITION.

  DEFINE _generate_extend.
    ms_match-token    = &1.
    ms_match-offset   = &2.
    ms_match-length   = &3.
    ms_match-text_tag = &4.
    APPEND ms_match TO mt_after_extend.
  END-OF-DEFINITION.

  METHOD do_test.

    DATA lt_matches_act TYPE zcl_timem_syntax_highlighter=>ty_match_tt.
    DATA lo_syntax      TYPE REF TO zcl_timem_syntax_highlighter.


    lo_syntax = zcl_timem_syntax_highlighter=>create( iv_filename ).
    lt_matches_act = lo_syntax->parse_line( iv_line ).

    SORT lt_matches_act BY offset ASCENDING.

    cl_abap_unit_assert=>assert_equals( exp = mt_after_parse
                                        act = lt_matches_act
                                        msg = | Error during parsing: { iv_line }| ).

    lo_syntax->order_matches( EXPORTING iv_line    = iv_line
                       CHANGING  ct_matches = lt_matches_act ).

    cl_abap_unit_assert=>assert_equals( exp = mt_after_order
                                        act = lt_matches_act
                                        msg = | Error during ordering: { iv_line }| ).

    lo_syntax->extend_matches(
      EXPORTING
        iv_line    = iv_line
      CHANGING
        ct_matches = lt_matches_act ).

    cl_abap_unit_assert=>assert_equals( exp = mt_after_extend
                                        act = lt_matches_act
                                        msg = | Error during extending: { iv_line }| ).

  ENDMETHOD.

******************************************************
* Test parsing and ordering of comments              *
******************************************************
  METHOD test_abap_01.

    DATA lv_line TYPE string.

    lv_line = '* commented out line with key word data'.    ""#EC NOTEXT

    "" Generate table with expected values after parsing
    _generate_parse 'C' 0  1.
    _generate_parse 'K' 12 3.
    _generate_parse 'K' 16 4.
    _generate_parse 'K' 21 4.
    _generate_parse 'K' 26 3.
    _generate_parse 'K' 30 4.
    _generate_parse 'K' 35 4.

    "" Generate table with expected values after ordering
    _generate_order 'C' 0  39 ''.

    "" Generate table with expected values after ordering
    _generate_extend 'C' 0  39 ''.

    do_test( iv_line = lv_line
             iv_filename = '*.abap' ).

  ENDMETHOD.

******************************************************
* Test parsing and ordering of remainder of string   *
******************************************************
  METHOD test_abap_02.

    DATA lv_line TYPE string.

    lv_line = 'data: lv_var_name type string.'.             ""#EC NOTEXT

    "" Generate table with expected values after parsing
    _generate_parse 'K' 0  4.
    _generate_parse 'K' 18 4.

    "" Generate table with expected values after ordering
    _generate_order 'K' 0  4  ''.
    _generate_order 'K' 18 4  ''.

    "" Generate table with expected values after extending
    _generate_extend 'K' 0  4  ''.
    _generate_extend '.' 4  14 ''.
    _generate_extend 'K' 18 4  ''.
    _generate_extend '.' 22 8  ''.

    do_test( iv_line = lv_line
             iv_filename = '*.abap' ).

  ENDMETHOD.

******************************************************
* Test parsing and ordering of key words & texts     *
******************************************************
  METHOD test_abap_03.

    DATA lv_line TYPE string.


    lv_line = 'call function ''FM_NAME''. "" Commented'.     ""#EC NOTEXT

    "" Generate table with expected values after parsing
    _generate_parse 'K' 0  4.
    _generate_parse 'K' 5  8.
    _generate_parse 'T' 14 1.
    _generate_parse 'T' 22 1.
    _generate_parse 'C' 25 1.

    "" Generate table with expected values after ordering
    _generate_order 'K' 0  4  ''.
    _generate_order 'K' 5  8  ''.
    _generate_order 'T' 14 9  ''''.
    _generate_order 'C' 25 11 ''.

    "" Generate table with expected values after extending
    _generate_extend 'K' 0  4  ''.
    _generate_extend '.' 4  1  ''.
    _generate_extend 'K' 5  8  ''.
    _generate_extend '.' 13 1  ''.
    _generate_extend 'T' 14 9  ''''.
    _generate_extend '.' 23 2  ''.
    _generate_extend 'C' 25 11 ''.

    do_test( iv_line = lv_line
             iv_filename = '*.abap' ).

  ENDMETHOD.

******************************************************
* Test parsing and ordering of key words in texts    *
******************************************************
  METHOD test_abap_04.

    DATA lv_line TYPE string.

    lv_line = 'constants: lc_var type string value ''simpletext data simpletext''.'. ""#EC NOTEXT

    "" Generate table with expected values after parsing
    _generate_parse 'K' 0  9.
    _generate_parse 'K' 18 4.
    _generate_parse 'K' 30 5.
    _generate_parse 'T' 36 1.
    _generate_parse 'K' 48 4.
    _generate_parse 'T' 63 1.

    "" Generate table with expected values after ordering
    _generate_order 'K' 0  9  ''.
    _generate_order 'K' 18 4  ''.
    _generate_order 'K' 30 5  ''.
    _generate_order 'T' 36 28 ''''.

    "" Generate table with expected values after ordering
    _generate_extend 'K' 0  9  ''.
    _generate_extend '.' 9  9  ''.
    _generate_extend 'K' 18 4  ''.
    _generate_extend '.' 22 8  ''.
    _generate_extend 'K' 30 5  ''.
    _generate_extend '.' 35 1  ''.
    _generate_extend 'T' 36 28 ''''.
    _generate_extend '.' 64 1  ''.

    do_test( iv_line = lv_line
             iv_filename = '*.abap' ).

  ENDMETHOD.

******************************************************
* Test parsing and ordering texts in curly brackets  *
******************************************************
  METHOD test_abap_05.

    DATA lv_line TYPE string.

    lv_line = 'a = |{ b }={ c }|.'.                         ""#EC NOTEXT

    "" Generate table with expected values after parsing
    _generate_parse 'T' 4  1.
    _generate_parse 'T' 5  1.
    _generate_parse 'T' 9  1.
    _generate_parse 'T' 11 1.
    _generate_parse 'K' 13 1.
    _generate_parse 'T' 15 1.
    _generate_parse 'T' 16 1.

    "" Generate table with expected values after ordering
    _generate_order 'T' 4  1  '|'.
    _generate_order 'T' 10 1  '}'.
    _generate_order 'K' 13 1  ''.
    _generate_order 'T' 16 1  '}'.

    "" Generate table with expected values after extending
    _generate_extend '.' 0  4  ''.
    _generate_extend 'T' 4  1  '|'.
    _generate_extend '.' 5  5  ''.
    _generate_extend 'T' 10 1  '}'.
    _generate_extend '.' 11 2  ''.
    _generate_extend 'K' 13 1  ''.
    _generate_extend '.' 14 2  ''.
    _generate_extend 'T' 16 1  '}'.
    _generate_extend '.' 17 1  ''.

    do_test( iv_line = lv_line
             iv_filename = '*.abap' ).

  ENDMETHOD.

******************************************************
* Test parsing and ordering of texts                 *
******************************************************
  METHOD test_abap_06.

    DATA lv_line TYPE string.

    lv_line = 'lv_line = lc_constant && |XYZ { ''ab'' && |ac{ ''UU'' }| }|'. ""#EC NOTEXT

    "" Generate table with expected values after parsing
    _generate_parse 'K' 22 2.
    _generate_parse 'T' 25 1.
    _generate_parse 'T' 30 1.
    _generate_parse 'T' 32 1.
    _generate_parse 'T' 35 1.
    _generate_parse 'K' 37 2.
    _generate_parse 'T' 40 1.
    _generate_parse 'T' 43 1.
    _generate_parse 'T' 45 1.
    _generate_parse 'T' 48 1.
    _generate_parse 'T' 50 1.
    _generate_parse 'T' 51 1.
    _generate_parse 'T' 53 1.
    _generate_parse 'T' 54 1.

    "" Generate table with expected values after ordering
    _generate_order 'K' 22 2  ''.
    _generate_order 'T' 25 5  '|'.
    _generate_order 'T' 32 4  ''''.
    _generate_order 'K' 37 2  ''.
    _generate_order 'T' 40 3  '|'.
    _generate_order 'T' 45 4  ''''.
    _generate_order 'T' 51 1  '}'.
    _generate_order 'T' 54 1  '}'.

    "" Generate table with expected values after extending
    _generate_extend '.' 00 22 ''.
    _generate_extend 'K' 22 2  ''.
    _generate_extend '.' 24 1  ''.
    _generate_extend 'T' 25 5  '|'.
    _generate_extend '.' 30 2  ''.
    _generate_extend 'T' 32 4  ''''.
    _generate_extend '.' 36 1  ''.
    _generate_extend 'K' 37 2  ''.
    _generate_extend '.' 39 1  ''.
    _generate_extend 'T' 40 3  '|'.
    _generate_extend '.' 43 2  ''.
    _generate_extend 'T' 45 4  ''''.
    _generate_extend '.' 49 2  ''.
    _generate_extend 'T' 51 1  '}'.
    _generate_extend '.' 52 2  ''.
    _generate_extend 'T' 54 1  '}'.

    do_test( iv_line = lv_line
             iv_filename = '*.abap' ).

  ENDMETHOD.

********************************************************
* Check that '*' in select statement is not a match    *
********************************************************
  METHOD test_abap_07.

    DATA lv_line TYPE string.

    lv_line = 'SELECT * FROM foo'.                          ""#EC NOTEXT

    "" Generate table with expected values after parsing
    _generate_parse 'K' 0  6.
    _generate_parse 'K' 9  4.

    "" Generate table with expected values after ordering
    _generate_order 'K' 0  6 ''.
    _generate_order 'K' 9  4 ''.

    "" Generate table with expected values after extending
    _generate_extend 'K' 0  6 ''.
    _generate_extend '.' 6  3 ''.
    _generate_extend 'K' 9  4 ''.
    _generate_extend '.' 13 4 ''.

    do_test( iv_line = lv_line
             iv_filename = '*.abap' ).

  ENDMETHOD.

********************************************************
* Test parsing and ordering of key words in structures *
********************************************************
  METHOD test_abap_08.

    DATA lv_line TYPE string.

    lv_line = 'lv_length = <match>-length.'.                ""#EC NOTEXT

    "" Generate table with expected values after parsing
    _generate_parse 'K' 13 5.
    _generate_parse 'K' 20 6.

    "" Generate table with expected values after extending
    _generate_extend '.' 0  27 ''.

    do_test( iv_line = lv_line
             iv_filename = '*.abap' ).

  ENDMETHOD.

********************************************************
* Test parsing and ordering of tags in xml             *
********************************************************
  METHOD test_xml_01.

    DATA lv_line TYPE string.

    lv_line = '<tag>Text</tag>'.                            ""#EC NOTEXT

    "" Generate table with expected values after parsing
    _generate_parse 'X' 0  1.
    _generate_parse 'X' 4  1.
    _generate_parse 'X' 9  1.
    _generate_parse 'X' 14 1.

    "" Generate table with expected values after ordering
    _generate_order 'X' 0  5 '<'.
    _generate_order 'X' 9  6 '<'.

    "" Generate table with expected values after extending
    _generate_extend 'X' 0  5 '<'.
    _generate_extend '.' 5  4 ''.
    _generate_extend 'X' 9  6 '<'.

    do_test( iv_line = lv_line
             iv_filename = '*.xml' ).

  ENDMETHOD.

  METHOD test_xml_02.

    DATA lv_line TYPE string.

    lv_line = '<tag/>'.                                     ""#EC NOTEXT

    "" Generate table with expected values after parsing
    _generate_parse 'X' 0  1.
    _generate_parse 'X' 5  1.

    "" Generate table with expected values after ordering
    _generate_order 'X' 0  6 '<'.

    "" Generate table with expected values after extending
    _generate_extend 'X' 0  6 '<'.

    do_test( iv_line = lv_line
             iv_filename = '*.xml' ).

  ENDMETHOD.

  METHOD test_xml_03.

    DATA lv_line TYPE string.

    lv_line = '<tag attribute=""value""/>'.                   ""#EC NOTEXT

    "" Generate table with expected values after parsing
    _generate_parse 'X' 0  1.
    _generate_parse 'A' 4  10.
    _generate_parse 'V' 15 7.
    _generate_parse 'X' 23 1.

    "" Generate table with expected values after ordering
    _generate_order 'X' 0  4 '<'.
    _generate_order 'A' 4  10 ''.
    _generate_order 'V' 15 7 ''.
    _generate_order 'X' 22 2 '>'.

    "" Generate table with expected values after extending
    _generate_extend 'X' 0  4 '<'.
    _generate_extend 'A' 4  10 ''.
    _generate_extend '.' 14 1 ''.
    _generate_extend 'V' 15 7 ''.
    _generate_extend 'X' 22 2 '>'.

    do_test( iv_line = lv_line
             iv_filename = '*.xml' ).

  ENDMETHOD.

  METHOD test_xml_04.

    DATA lv_line TYPE string.

    lv_line = '<?xml version=""1.0""?>'.                      ""#EC NOTEXT

    "" Generate table with expected values after parsing
    _generate_parse 'X' 0  1.
    _generate_parse 'A' 5  8.
    _generate_parse 'V' 14 5.
    _generate_parse 'X' 20 1.

    "" Generate table with expected values after ordering
    _generate_order 'X' 0  5 '<'.
    _generate_order 'A' 5  8 ''.
    _generate_order 'V' 14 5 ''.
    _generate_order 'X' 19 2 '>'.

    "" Generate table with expected values after extending
    _generate_extend 'X' 0  5 '<'.
    _generate_extend 'A' 5  8 ''.
    _generate_extend '.' 13 1 ''.
    _generate_extend 'V' 14 5 ''.
    _generate_extend 'X' 19 2 '>'.

    do_test( iv_line = lv_line
             iv_filename = '*.xml' ).

  ENDMETHOD.

  METHOD test_xml_05.

    DATA lv_line TYPE string.

    lv_line = '<ns:tag ns:a1=""v1"" ns:a2=''v2''>""text""</ns:tag>'. ""#EC NOTEXT

    "" Generate table with expected values after parsing
    _generate_parse 'X' 0  1.
    _generate_parse 'A' 7  6.
    _generate_parse 'V' 14 4.
    _generate_parse 'A' 18 6.
    _generate_parse 'V' 25 4.
    _generate_parse 'X' 29 1.
    _generate_parse 'V' 30 6.
    _generate_parse 'X' 36 1.
    _generate_parse 'X' 44 1.

    "" Generate table with expected values after ordering
    _generate_order 'X' 0  7 '<'.
    _generate_order 'A' 7  6 ''.
    _generate_order 'V' 14 4 ''.
    _generate_order 'A' 18 6 ''.
    _generate_order 'V' 25 4 ''.
    _generate_order 'X' 29 1 '>'.
    _generate_order 'X' 36 9 '<'.

    "" Generate table with expected values after extending
    _generate_extend 'X' 0  7 '<'.
    _generate_extend 'A' 7  6 ''.
    _generate_extend '.' 13 1 ''.
    _generate_extend 'V' 14 4 ''.
    _generate_extend 'A' 18 6 ''.
    _generate_extend '.' 24 1 ''.
    _generate_extend 'V' 25 4 ''.
    _generate_extend 'X' 29 1 '>'.
    _generate_extend '.' 30 6 ''.
    _generate_extend 'X' 36 9 '<'.

    do_test( iv_line = lv_line
             iv_filename = '*.xml' ).

  ENDMETHOD.

  METHOD test_xml_06.
    DATA lv_line TYPE string.

    ""unclosed tag
    lv_line = '<ns:tag ns:a1=""v1""'.                         ""#EC NOTEXT

    "" Generate table with expected values after parsing
    _generate_parse 'X' 0  1.
    _generate_parse 'A' 7  6.
    _generate_parse 'V' 14 4.

    "" Generate table with expected values after ordering
    _generate_order 'X' 0  7 '<'.
    _generate_order 'A' 7  6 ''.
    _generate_order 'V' 14 4 ''.

    "" Generate table with expected values after extending
    _generate_extend 'X' 0  7 '<'.
    _generate_extend 'A' 7  6 ''.
    _generate_extend '.' 13 1 ''.
    _generate_extend 'V' 14 4 ''.

    do_test( iv_line = lv_line
             iv_filename = '*.xml' ).
  ENDMETHOD.

  METHOD test_xml_07.
    ""invalid XML characters in a string
    DATA lv_line TYPE string.

    ""xml special characters in attribute
    lv_line = '<tag attribute="" '' > ""/>'.                  ""#EC NOTEXT

    "" Generate table with expected values after parsing
    _generate_parse 'X' 0  1.
    _generate_parse 'A' 4  10.
    _generate_parse 'V' 15 7.
    _generate_parse 'X' 23 1.

    "" Generate table with expected values after ordering
    _generate_order 'X' 0  4 '<'.
    _generate_order 'A' 4  10 ''.
    _generate_order 'V' 15 7 ''.
    _generate_order 'X' 22 2 '>'.

    "" Generate table with expected values after extending
    _generate_extend 'X' 0  4 '<'.
    _generate_extend 'A' 4  10 ''.
    _generate_extend '.' 14 1 ''.
    _generate_extend 'V' 15 7 ''.
    _generate_extend 'X' 22 2 '>'.

    do_test( iv_line = lv_line
             iv_filename = '*.xml' ).


  ENDMETHOD.


  METHOD test_xml_08.
    ""invalid XML characters in a string
    DATA lv_line TYPE string.

    ""attribute at beginning of line
    lv_line = 'attribute=''>"" '''.                          ""#EC NOTEXT

    "" Generate table with expected values after parsing
    _generate_parse 'A' 0  9.
    _generate_parse 'V' 10 5.

    "" Generate table with expected values after ordering
    _generate_order 'A' 0  9 ''.
    _generate_order 'V' 10 5 ''.

    "" Generate table with expected values after extending
    _generate_extend 'A' 0  9 ''.
    _generate_extend '.' 9 1 ''.
    _generate_extend 'V' 10 5 ''.

    do_test( iv_line = lv_line
             iv_filename = '*.xml' ).

  ENDMETHOD.

ENDCLASS.

CLASS ltcl_syntax_basic_logic DEFINITION DEFERRED.
CLASS zcl_timem_syntax_highlighter DEFINITION LOCAL FRIENDS ltcl_syntax_basic_logic.

*----------------------------------------------------------------------*
*       CLASS ltcl_syntax_basic_logic DEFINITION
*----------------------------------------------------------------------*
*
*----------------------------------------------------------------------*
CLASS ltcl_syntax_basic_logic DEFINITION FINAL FOR TESTING RISK LEVEL HARMLESS
    DURATION SHORT.

  PRIVATE SECTION.

    DATA mo_syntax_highlighter TYPE REF TO zcl_timem_syntax_highlighter.

    METHODS:
      setup,
      process_line  FOR TESTING,
      format_line   FOR TESTING,
      apply_style   FOR TESTING.

ENDCLASS.

*----------------------------------------------------------------------*
*       CLASS ltcl_syntax_highlighter IMPLEMENTATION
*----------------------------------------------------------------------*
CLASS ltcl_syntax_basic_logic IMPLEMENTATION.

  METHOD setup.
    mo_syntax_highlighter = zcl_timem_syntax_highlighter=>create( '*.abap' ).
  ENDMETHOD.

  METHOD format_line.

    DATA lv_line     TYPE string.
    DATA lv_line_act TYPE string.
    DATA lv_line_exp TYPE string.

    lv_line = 'call function ''FM_NAME''. "" Commented'.     ""#EC NOTEXT

    lv_line_exp =
      '<span class=""keyword"">call</span>' &&                ""#EC NOTEXT
      ' <span class=""keyword"">function</span>' &&           ""#EC NOTEXT
      ' <span class=""text"">&#39;FM_NAME&#39;</span>.' &&    ""#EC NOTEXT
      ' <span class=""comment"">&quot; Commented</span>'.     ""#EC NOTEXT

    lv_line_act = mo_syntax_highlighter->process_line( lv_line ).

    cl_abap_unit_assert=>assert_equals( exp = lv_line_exp
                                        act = lv_line_act
                                        msg = | Error during formating: { lv_line }| ).

  ENDMETHOD.

  METHOD apply_style.

    DATA lv_line_act TYPE string.

    "" Call the method and compare results
    lv_line_act = mo_syntax_highlighter->apply_style( iv_line  = 'CALL FUNCTION' ""#EC NOTEXT
                                   iv_class = zcl_timem_syntax_abap=>c_css-keyword ).

    cl_abap_unit_assert=>assert_equals(
      act = lv_line_act
      exp = '<span class=""keyword"">CALL FUNCTION</span>'    ""#EC NOTEXT
      msg = 'Failure during applying of style.' ).          ""#EC NOTEXT

  ENDMETHOD.

  METHOD process_line.

    DATA lv_line_act TYPE string.

    "" Call the method with empty parameter and compare results
    lv_line_act = mo_syntax_highlighter->process_line( '' ).

    cl_abap_unit_assert=>assert_equals(
      act = lv_line_act
      exp = ''
      msg = 'Failure in method process_line.' ).            ""#EC NOTEXT

    "" Call the method with non-empty line and compare results
    lv_line_act = mo_syntax_highlighter->process_line( '* CALL FUNCTION' ). ""#EC NOTEXT

    cl_abap_unit_assert=>assert_equals(
      act = lv_line_act
      exp = '<span class=""comment"">* CALL FUNCTION</span>'  ""#EC NOTEXT
      msg = 'Failure in method process_line.' ).            ""#EC NOTEXT

  ENDMETHOD.

ENDCLASS.
",6013,False,1440.6639469817976,median
"CLASS zcl_gtt_mia_tp_reader_dli DEFINITION
  PUBLIC
  CREATE PUBLIC .

  PUBLIC SECTION.

    INTERFACES zif_gtt_mia_tp_reader .

    METHODS constructor
      IMPORTING
        !io_ef_parameters TYPE REF TO zif_gtt_mia_ef_parameters .
  PROTECTED SECTION.
  PRIVATE SECTION.

    TYPES tv_posnr_txt TYPE char6 .
    TYPES tv_po_item TYPE char20 .
    TYPES:
      BEGIN OF ts_dl_item,
        "" Header section
        vbeln     TYPE lips-vbeln,
        posnr     TYPE tv_posnr_txt,      ""used char type to avoid leading zeros deletion
        arktx     TYPE lips-arktx,
        matnr     TYPE lips-matnr,
        charg     TYPE lips-charg,         ""MIA
        lgobe     TYPE t001l-lgobe,        ""MIA
        lfimg     TYPE lips-lfimg,
        vrkme     TYPE lips-vrkme,
        "" Departure section
        lifnr     TYPE likp-lifnr,
        lifnr_lt  TYPE /saptrx/loc_id_type,
        dep_addr  TYPE /saptrx/paramval200,
        dep_email TYPE /saptrx/paramval200,
        dep_tel   TYPE /saptrx/paramval200,
        "" Destination section
        werks     TYPE lips-werks,
        werks_lt  TYPE /saptrx/loc_id_type,
        dest_addr TYPE /saptrx/paramval200,
        lgnum     TYPE lips-lgnum,
        lgtor     TYPE lips-lgtor,
        lgnum_txt TYPE /saptrx/paramval200,
        "" Others
        bldat     TYPE likp-bldat,
        lfdat     TYPE likp-lfdat,
        brgew     TYPE lips-brgew,
        ntgew     TYPE lips-ntgew,
        gewei     TYPE likp-gewei,
        volum     TYPE lips-volum,
        voleh     TYPE lips-voleh,
        bolnr     TYPE likp-bolnr,
        profl     TYPE lips-profl,
        incov     TYPE likp-incov,
        inco1     TYPE likp-inco1,
        inco2_l   TYPE likp-inco2_l,
        po_item   TYPE tv_po_item,
      END OF ts_dl_item .

    CONSTANTS:
      BEGIN OF cs_mapping,
        "" Header section
        vbeln     TYPE /saptrx/paramname VALUE 'YN_DL_DELEVERY',
        posnr     TYPE /saptrx/paramname VALUE 'YN_DL_DELEVERY_ITEM',
        arktx     TYPE /saptrx/paramname VALUE 'YN_DL_ITEM_DESCR',
        matnr     TYPE /saptrx/paramname VALUE 'YN_DL_MATERIAL_ID',
        charg     TYPE /saptrx/paramname VALUE 'YN_DL_MATERIAL_BATCH',       ""MIA
        lgobe     TYPE /saptrx/paramname VALUE 'YN_DL_STORAGE_LOCATION_TXT', ""MIA
        lfimg     TYPE /saptrx/paramname VALUE 'YN_DL_ORDER_QUANT',
        vrkme     TYPE /saptrx/paramname VALUE 'YN_DL_ORDER_UNITS',
        "" Departure section
        lifnr     TYPE /saptrx/paramname VALUE 'YN_DL_VENDOR_ID',
        lifnr_lt  TYPE /saptrx/paramname VALUE 'YN_DL_VENDOR_LOC_TYPE',
        dep_addr  TYPE /saptrx/paramname VALUE 'YN_DL_DEPART_ADDRESS',
        dep_email TYPE /saptrx/paramname VALUE 'YN_DL_DEPART_EMAIL',
        dep_tel   TYPE /saptrx/paramname VALUE 'YN_DL_DEPART_TEL',
        "" Destination section
        werks     TYPE /saptrx/paramname VALUE 'YN_DL_PLANT',
        werks_lt  TYPE /saptrx/paramname VALUE 'YN_DL_PLANT_LOC_TYPE',
        dest_addr TYPE /saptrx/paramname VALUE 'YN_DL_DESTIN_ADDRESS',
        lgnum     TYPE /saptrx/paramname VALUE 'YN_DL_WAREHOUSE',
        lgnum_txt TYPE /saptrx/paramname VALUE 'YN_DL_WAREHOUSE_DESC',
        lgtor     TYPE /saptrx/paramname VALUE 'YN_DL_DOOR',
        "" Others
        bldat     TYPE /saptrx/paramname VALUE 'YN_DL_DOCUMENT_DATE',
        lfdat     TYPE /saptrx/paramname VALUE 'YN_DL_PLANNED_DLV_DATE',
        brgew     TYPE /saptrx/paramname VALUE 'YN_DL_GROSS_WEIGHT',
        ntgew     TYPE /saptrx/paramname VALUE 'YN_DL_NET_WEIGHT',
        gewei     TYPE /saptrx/paramname VALUE 'YN_DL_WEIGHT_UNITS',
        volum     TYPE /saptrx/paramname VALUE 'YN_DL_VOLUME',
        voleh     TYPE /saptrx/paramname VALUE 'YN_DL_VOLUME_UNITS',
        bolnr     TYPE /saptrx/paramname VALUE 'YN_DL_BILL_OF_LADING',
        profl     TYPE /saptrx/paramname VALUE 'YN_DL_DANGEROUS_GOODS',
        incov     TYPE /saptrx/paramname VALUE 'YN_DL_INCOTERMS_VERSION',
        inco1     TYPE /saptrx/paramname VALUE 'YN_DL_INCOTERMS',
        inco2_l   TYPE /saptrx/paramname VALUE 'YN_DL_INCOTERMS_LOCATION',
        po_item   TYPE /saptrx/paramname VALUE 'YN_DL_ASSOC_POITEM_NO',
      END OF cs_mapping .
    CONSTANTS cv_posnr_empty TYPE posnr_vl VALUE '000000' ##NO_TEXT.
    DATA mo_ef_parameters TYPE REF TO zif_gtt_mia_ef_parameters .

    METHODS fill_item_from_likp_struct
      IMPORTING
        !ir_likp    TYPE REF TO data
      CHANGING
        !cs_dl_item TYPE ts_dl_item
      RAISING
        cx_udm_message .
    METHODS fill_item_from_lips_struct
      IMPORTING
        !ir_lips    TYPE REF TO data
      CHANGING
        !cs_dl_item TYPE ts_dl_item
      RAISING
        cx_udm_message .
    METHODS fill_item_from_vbpa_table
      IMPORTING
        !ir_vbpa    TYPE REF TO data
        !iv_vbeln   TYPE vbeln_vl
        !iv_posnr   TYPE posnr_vl
      CHANGING
        !cs_dl_item TYPE ts_dl_item
      RAISING
        cx_udm_message .
    METHODS fill_item_location_types
      CHANGING
        !cs_dl_item TYPE ts_dl_item.
    METHODS format_item_location_ids
      CHANGING
        !cs_dl_item TYPE ts_dl_item.
    METHODS get_likp_struct_old
      IMPORTING
        !is_app_object TYPE trxas_appobj_ctab_wa
        !iv_vbeln      TYPE vbeln_vl
      RETURNING
        VALUE(rr_likp) TYPE REF TO data
      RAISING
        cx_udm_message .
    METHODS get_lips_struct_old
      IMPORTING
        !is_app_object TYPE trxas_appobj_ctab_wa
        !iv_vbeln      TYPE vbeln_vl
        !iv_posnr      TYPE posnr_vl
      RETURNING
        VALUE(rr_lips) TYPE REF TO data
      RAISING
        cx_udm_message .
    METHODS get_purchasing_order_item
      IMPORTING
        !ir_lips          TYPE REF TO data
      RETURNING
        VALUE(rv_po_item) TYPE tv_po_item
      RAISING
        cx_udm_message .
    METHODS get_vbpa_table_old
      IMPORTING
        !is_app_object TYPE trxas_appobj_ctab_wa
        !iv_vbeln      TYPE vbeln_vl
        !iv_posnr      TYPE posnr_vl
      RETURNING
        VALUE(rr_vbpa) TYPE REF TO data
      RAISING
        cx_udm_message .
    METHODS is_object_changed
      IMPORTING
        !is_app_object   TYPE trxas_appobj_ctab_wa
      RETURNING
        VALUE(rv_result) TYPE abap_bool
      RAISING
        cx_udm_message .
ENDCLASS.



CLASS zcl_gtt_mia_tp_reader_dli IMPLEMENTATION.


  METHOD constructor.

    mo_ef_parameters    = io_ef_parameters.

  ENDMETHOD.


  METHOD fill_item_from_likp_struct.

    FIELD-SYMBOLS: <ls_likp>  TYPE likpvb.

    ASSIGN ir_likp->* TO <ls_likp>.

    IF <ls_likp> IS ASSIGNED.
      MOVE-CORRESPONDING <ls_likp> TO cs_dl_item.
    ELSE.
      MESSAGE e002(zgtt_mia) WITH 'LIKP' INTO DATA(lv_dummy).
      zcl_gtt_mia_tools=>throw_exception( ).
    ENDIF.

  ENDMETHOD.


  METHOD fill_item_from_lips_struct.

    FIELD-SYMBOLS: <ls_lips> TYPE lipsvb.

    DATA(lv_lgtor_old) = cs_dl_item-lgtor.

    ASSIGN ir_lips->* TO <ls_lips>.

    IF <ls_lips> IS ASSIGNED.
      MOVE-CORRESPONDING <ls_lips> TO cs_dl_item.

      cs_dl_item-profl  = boolc( cs_dl_item-profl IS NOT INITIAL ).

      cs_dl_item-lgtor  = COND #( WHEN cs_dl_item-lgtor IS NOT INITIAL
                                    THEN cs_dl_item-lgtor
                                    ELSE lv_lgtor_old ).
      TRY.
          zcl_gtt_mia_dl_tools=>get_addres_info(
            EXPORTING
              iv_addr_numb = zcl_gtt_mia_dl_tools=>get_plant_address_number(
                               iv_werks = <ls_lips>-werks )
            IMPORTING
              ev_address   = cs_dl_item-dest_addr ).

        CATCH cx_udm_message.
      ENDTRY.

      IF cs_dl_item-lgnum IS NOT INITIAL AND
         cs_dl_item-lgtor IS NOT INITIAL.
        TRY.
            cs_dl_item-lgnum_txt  = zcl_gtt_mia_dl_tools=>get_door_description(
                                      EXPORTING
                                        iv_lgnum = cs_dl_item-lgnum
                                        iv_lgtor = cs_dl_item-lgtor ).
          CATCH cx_udm_message.
        ENDTRY.
      ENDIF.

      IF <ls_lips>-werks IS NOT INITIAL AND
         <ls_lips>-lgort IS NOT INITIAL.
        TRY.
            cs_dl_item-lgobe    = zcl_gtt_mia_dl_tools=>get_storage_location_txt(
                              iv_werks = <ls_lips>-werks
                              iv_lgort = <ls_lips>-lgort ).
          CATCH cx_udm_message.
        ENDTRY.
      ENDIF.


      cs_dl_item-po_item    = get_purchasing_order_item(
                                ir_lips   = ir_lips ).
    ELSE.
      MESSAGE e002(zgtt_mia) WITH 'LIKP' INTO DATA(lv_dummy).
      zcl_gtt_mia_tools=>throw_exception( ).
    ENDIF.

  ENDMETHOD.


  METHOD fill_item_from_vbpa_table.

    TYPES: tt_vbpa TYPE STANDARD TABLE OF vbpavb.

    FIELD-SYMBOLS: <lt_vbpa>      TYPE tt_vbpa,
                   <ls_vbpa>      TYPE vbpavb,
                   <lv_addr_type> TYPE any.

    ASSIGN ir_vbpa->* TO <lt_vbpa>.

    IF <lt_vbpa> IS ASSIGNED.
      READ TABLE <lt_vbpa> ASSIGNING <ls_vbpa>
        WITH KEY vbeln = iv_vbeln
                 posnr = iv_posnr
                 parvw = zif_gtt_mia_app_constants=>cs_parvw-supplier.

      IF sy-subrc = 0.
        ASSIGN COMPONENT 'ADDR_TYPE' OF STRUCTURE <ls_vbpa> TO <lv_addr_type>.
        TRY.
            zcl_gtt_mia_dl_tools=>get_addres_info(
              EXPORTING
                iv_addr_type = COND #( WHEN <lv_addr_type> IS ASSIGNED AND
                                            <lv_addr_type> IS NOT INITIAL
                                         THEN <lv_addr_type>
                                         ELSE zif_gtt_mia_app_constants=>cs_adrtype-organization )
                iv_addr_numb = <ls_vbpa>-adrnr
              IMPORTING
                ev_address   = cs_dl_item-dep_addr
                ev_email     = cs_dl_item-dep_email
                ev_telephone = cs_dl_item-dep_tel ).
          CATCH cx_udm_message.
        ENDTRY.
      ENDIF.
    ELSE.
      MESSAGE e002(zgtt_mia) WITH 'VBPA' INTO DATA(lv_dummy).
      zcl_gtt_mia_tools=>throw_exception( ).
    ENDIF.

  ENDMETHOD.

  METHOD fill_item_location_types.

    cs_dl_item-lifnr_lt   = zif_gtt_mia_ef_constants=>cs_loc_types-supplier.
    cs_dl_item-werks_lt   = zif_gtt_mia_ef_constants=>cs_loc_types-plant.

  ENDMETHOD.

  METHOD format_item_location_ids.
    cs_dl_item-lifnr  = zcl_gtt_mia_tools=>get_pretty_location_id(
                          iv_locid   = cs_dl_item-lifnr
                          iv_loctype = cs_dl_item-lifnr_lt ).

    cs_dl_item-werks  = zcl_gtt_mia_tools=>get_pretty_location_id(
                          iv_locid   = cs_dl_item-werks
                          iv_loctype = cs_dl_item-werks_lt ).
  ENDMETHOD.

  METHOD get_likp_struct_old.

    "" when header is unchanged, table 'DELIVERY_HEADER_OLD' is not populated
    "" so mastertab record is used as data source for header data
    TYPES: tt_likp TYPE STANDARD TABLE OF likpvb.

    FIELD-SYMBOLS: <lt_likp> TYPE tt_likp,
                   <ls_likp> TYPE likpvb.

    DATA(lr_likp)   = mo_ef_parameters->get_appl_table(
                        iv_tabledef = zif_gtt_mia_app_constants=>cs_tabledef-dl_header_old ).

    ASSIGN lr_likp->* TO <lt_likp>.

    IF <lt_likp> IS ASSIGNED.
      READ TABLE <lt_likp> ASSIGNING <ls_likp>
        WITH KEY vbeln = iv_vbeln.

      rr_likp   = COND #( WHEN sy-subrc = 0
                            THEN REF #( <ls_likp> )
                            ELSE is_app_object-mastertabref ).
    ELSE.
      MESSAGE e002(zgtt_mia) WITH 'LIKP' INTO DATA(lv_dummy).
      zcl_gtt_mia_tools=>throw_exception( ).
    ENDIF.

  ENDMETHOD.


  METHOD get_lips_struct_old.

    "" when item is unchanged, it is absent in table 'DELIVERY_ITEM_OLD'
    "" so maintab record is used as data source for item data
    TYPES: tt_lips TYPE STANDARD TABLE OF lipsvb.

    FIELD-SYMBOLS: <lt_lips> TYPE tt_lips,
                   <ls_lips> TYPE lipsvb.

    DATA(lr_lips)   = mo_ef_parameters->get_appl_table(
                        iv_tabledef = zif_gtt_mia_app_constants=>cs_tabledef-dl_item_old ).

    ASSIGN lr_lips->* TO <lt_lips>.

    IF <lt_lips> IS ASSIGNED.
      READ TABLE <lt_lips> ASSIGNING <ls_lips>
        WITH KEY vbeln = iv_vbeln
                 posnr = iv_posnr.

      rr_lips   = COND #( WHEN sy-subrc = 0
                            THEN REF #( <ls_lips> )
                            ELSE is_app_object-maintabref ).
    ELSE.
      MESSAGE e002(zgtt_mia) WITH 'LIPS' INTO DATA(lv_dummy).
      zcl_gtt_mia_tools=>throw_exception( ).
    ENDIF.

  ENDMETHOD.


  METHOD get_purchasing_order_item.

    DATA(lv_ebeln)  = CONV ebeln( zcl_gtt_mia_tools=>get_field_of_structure(
                                    ir_struct_data = ir_lips
                                    iv_field_name  = 'VGBEL' ) ).

    DATA(lv_ebelp)  = CONV ebelp( zcl_gtt_mia_tools=>get_field_of_structure(
                                    ir_struct_data = ir_lips
                                    iv_field_name  = 'VGPOS' ) ).

    rv_po_item  = |{ lv_ebeln }{ lv_ebelp }|.

  ENDMETHOD.


  METHOD get_vbpa_table_old.

    "" when partner data is unchanged, it is absent in table 'PARTNERS_OLD'
    "" so 'PARTNERS_NEW' is used as data source for partner data
    TYPES: tt_vbpa TYPE STANDARD TABLE OF vbpavb.

    FIELD-SYMBOLS: <lt_vbpa> TYPE tt_vbpa,
                   <ls_vbpa> TYPE vbpavb.

    DATA(lr_vbpa)   = mo_ef_parameters->get_appl_table(
                        iv_tabledef = zif_gtt_mia_app_constants=>cs_tabledef-dl_partners_old ).

    ASSIGN lr_vbpa->* TO <lt_vbpa>.

    IF <lt_vbpa> IS ASSIGNED.
      READ TABLE <lt_vbpa> ASSIGNING <ls_vbpa>
        WITH KEY vbeln = iv_vbeln
                 posnr = iv_posnr
                 parvw = zif_gtt_mia_app_constants=>cs_parvw-supplier.

      rr_vbpa = COND #( WHEN sy-subrc = 0
                          THEN lr_vbpa
                          ELSE mo_ef_parameters->get_appl_table(
                                 iv_tabledef = zif_gtt_mia_app_constants=>cs_tabledef-dl_partners_new ) ).
    ELSE.
      MESSAGE e002(zgtt_mia) WITH 'VBPA' INTO DATA(lv_dummy).
      zcl_gtt_mia_tools=>throw_exception( ).
    ENDIF.

  ENDMETHOD.


  METHOD is_object_changed.

    rv_result   = zcl_gtt_mia_tools=>is_object_changed(
                    is_app_object    = is_app_object
                    io_ef_parameters = mo_ef_parameters
                    it_check_tables  = VALUE #( ( zif_gtt_mia_app_constants=>cs_tabledef-dl_partners_new )
                                                ( zif_gtt_mia_app_constants=>cs_tabledef-dl_partners_old ) )
                    iv_key_field     = 'VBELN'
                    iv_upd_field     = 'UPDKZ'
                    iv_chk_mastertab = abap_true ).

  ENDMETHOD.


  METHOD zif_gtt_mia_tp_reader~check_relevance.

    rv_result   = zif_gtt_mia_ef_constants=>cs_condition-false.

    IF zcl_gtt_mia_dl_tools=>is_appropriate_dl_type( ir_struct = is_app_object-mastertabref ) = abap_true AND
       zcl_gtt_mia_dl_tools=>is_appropriate_dl_item( ir_struct = is_app_object-maintabref ) = abap_true AND
       is_object_changed( is_app_object = is_app_object ) = abap_true.

      CASE is_app_object-update_indicator.
        WHEN zif_gtt_mia_ef_constants=>cs_change_mode-insert.
          rv_result   = zif_gtt_mia_ef_constants=>cs_condition-true.
        WHEN zif_gtt_mia_ef_constants=>cs_change_mode-update OR
             zif_gtt_mia_ef_constants=>cs_change_mode-undefined.
          rv_result   = zcl_gtt_mia_tools=>are_structures_different(
                          ir_data1  = zif_gtt_mia_tp_reader~get_data(
                                        is_app_object = is_app_object )
                          ir_data2  = zif_gtt_mia_tp_reader~get_data_old(
                                        is_app_object = is_app_object ) ).
      ENDCASE.
    ENDIF.

  ENDMETHOD.


  METHOD zif_gtt_mia_tp_reader~get_data.

    FIELD-SYMBOLS: <ls_item> TYPE ts_dl_item.

    rr_data   = NEW ts_dl_item( ).

    ASSIGN rr_data->* TO <ls_item>.

    fill_item_from_likp_struct(
      EXPORTING
        ir_likp    = is_app_object-mastertabref
      CHANGING
        cs_dl_item = <ls_item> ).

    fill_item_from_lips_struct(
      EXPORTING
        ir_lips    = is_app_object-maintabref
      CHANGING
        cs_dl_item = <ls_item> ).

    fill_item_from_vbpa_table(
      EXPORTING
        ir_vbpa    = mo_ef_parameters->get_appl_table(
                          iv_tabledef = zif_gtt_mia_app_constants=>cs_tabledef-dl_partners_new )
        iv_vbeln   = <ls_item>-vbeln
        iv_posnr   = cv_posnr_empty
      CHANGING
        cs_dl_item = <ls_item> ).

    fill_item_location_types(
      CHANGING
        cs_dl_item = <ls_item> ).

    format_item_location_ids(
      CHANGING
        cs_dl_item = <ls_item> ).

  ENDMETHOD.


  METHOD zif_gtt_mia_tp_reader~get_data_old.


    FIELD-SYMBOLS: <ls_item> TYPE ts_dl_item.

    DATA(lv_vbeln)  = CONV vbeln_vl( zcl_gtt_mia_tools=>get_field_of_structure(
                                       ir_struct_data = is_app_object-maintabref
                                       iv_field_name  = 'VBELN' ) ).
    DATA(lv_posnr)  = CONV posnr_vl( zcl_gtt_mia_tools=>get_field_of_structure(
                                       ir_struct_data = is_app_object-maintabref
                                       iv_field_name  = 'POSNR' ) ).

    rr_data   = NEW ts_dl_item( ).

    ASSIGN rr_data->* TO <ls_item>.

    fill_item_from_likp_struct(
      EXPORTING
        ir_likp    = get_likp_struct_old(
                       is_app_object = is_app_object
                       iv_vbeln      = lv_vbeln )
      CHANGING
        cs_dl_item = <ls_item> ).

    fill_item_from_lips_struct(
      EXPORTING
        ir_lips    = get_lips_struct_old(
                       is_app_object = is_app_object
                       iv_vbeln      = lv_vbeln
                       iv_posnr      = lv_posnr )
      CHANGING
        cs_dl_item = <ls_item> ).


    fill_item_from_vbpa_table(
      EXPORTING
        ir_vbpa    = get_vbpa_table_old(
                       is_app_object = is_app_object
                       iv_vbeln      = lv_vbeln
                       iv_posnr      = cv_posnr_empty )
        iv_vbeln   = lv_vbeln
        iv_posnr   = cv_posnr_empty
      CHANGING
        cs_dl_item = <ls_item> ).

    fill_item_location_types(
      CHANGING
        cs_dl_item = <ls_item> ).

    format_item_location_ids(
      CHANGING
        cs_dl_item = <ls_item> ).

  ENDMETHOD.


  METHOD zif_gtt_mia_tp_reader~get_field_parameter.

    CLEAR: rv_result.

  ENDMETHOD.


  METHOD zif_gtt_mia_tp_reader~get_mapping_structure.

    rr_data   = REF #( cs_mapping ).

  ENDMETHOD.


  METHOD zif_gtt_mia_tp_reader~get_track_id_data.

    ""In ERP’s extractors, need to include 2 tracking IDs.
    ""The first one is for itself, one is for its header –
    ""please ensure same tracking ID type to be used in the
    ""Inbound Delivery Header process

    DATA: lv_fname TYPE char5.

    FIELD-SYMBOLS: <ls_lips>  TYPE lipsvb.

    "" Actual Business Time zone
    DATA(lv_tzone)  = zcl_gtt_mia_tools=>get_system_time_zone( ).

    ASSIGN is_app_object-maintabref->* TO <ls_lips>.

    IF <ls_lips> IS ASSIGNED.
      et_track_id_data  = VALUE #( (
          appsys      = mo_ef_parameters->get_appsys( )
          appobjtype  = is_app_object-appobjtype
          appobjid    = is_app_object-appobjid
          trxcod      = zif_gtt_mia_app_constants=>cs_trxcod-dl_position
          trxid       = |{ <ls_lips>-vbeln }{ <ls_lips>-posnr }|
          timzon      = lv_tzone
          msrid       = space
        ) ).

      IF <ls_lips>-updkz = zif_gtt_mia_ef_constants=>cs_change_mode-insert.
        et_track_id_data = VALUE #( BASE et_track_id_data (
            appsys      = mo_ef_parameters->get_appsys( )
            appobjtype  = is_app_object-appobjtype
            appobjid    = is_app_object-appobjid
            trxcod      = zif_gtt_mia_app_constants=>cs_trxcod-dl_number
            trxid       = |{ <ls_lips>-vbeln }|
            timzon      = lv_tzone
            msrid       = space
          ) ).
      ENDIF.
    ELSE.
      MESSAGE e002(zgtt_mia) WITH 'LIPS' INTO DATA(lv_dummy).
      zcl_gtt_mia_tools=>throw_exception( ).
    ENDIF.

  ENDMETHOD.
ENDCLASS.
",5592,False,1047.6469546785574,median
"[[smpp-component]]
= SMPP Component
//THIS FILE IS COPIED: EDIT THE SOURCE FILE:
:page-source: components/camel-smpp/src/main/docs/smpp-component.adoc
:docTitle: SMPP
:artifactId: camel-smpp
:description: Send and receive SMS messages using a SMSC (Short Message Service Center).
:since: 2.2
:supportLevel: Stable
:component-header: Both producer and consumer are supported
include::{cq-version}@camel-quarkus:ROOT:partial$reference/components/smpp.adoc[opts=optional]

*Since Camel {since}*

*{component-header}*

This component provides access to an SMSC (Short Message Service Center)
over the http://smsforum.net/SMPP_v3_4_Issue1_2.zip[SMPP] protocol to
send and receive SMS. The http://jsmpp.org[JSMPP] library is used for
the protocol implementation.

The Camel component currently operates as an
http://en.wikipedia.org/wiki/ESME[ESME] (External Short Messaging
Entity) and not as an SMSC itself.

You are also able to execute ReplaceSm,
QuerySm, SubmitMulti, CancelSm and DataSm.

Maven users will need to add the following dependency to their `pom.xml`
for this component:

[source,xml]
------------------------------------------------------------
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-smpp</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>
------------------------------------------------------------

== SMS limitations

SMS is neither reliable or secure.  Users who require reliable and
secure delivery may want to consider using the XMPP or SIP components
instead, combined with a smartphone app supporting the chosen protocol.

* Reliability: although the SMPP standard offers a range of feedback
mechanisms to indicate errors, non-delivery and confirmation of delivery
it is not uncommon for mobile networks to hide or simulate these
responses.  For example, some networks automatically send a delivery
confirmation for every message even if the destination number is invalid
or not switched on.  Some networks silently drop messages if they think
they are spam.  Spam detection rules in the network may be very crude,
sometimes more than 100 messages per day from a single sender may be
considered spam.
* Security: there is basic encryption for the last hop from the radio
tower down to the recipient handset.  SMS messages are not encrypted or
authenticated in any other part of the network.  Some operators allow
staff in retail outlets or call centres to browse through the SMS
message histories of their customers.  Message sender identity can be
easily forged.  Regulators and even the mobile telephone industry itself
has cautioned against the use of SMS in two-factor authentication
schemes and other purposes where security is important.

While the Camel component makes it as easy as possible to send messages
to the SMS network, it can not offer an easy solution to these problems.

== Data coding, alphabet and international character sets

Data coding and alphabet can be specified on a per-message basis. 
Default values can be specified for the endpoint.  It is important to
understand the relationship between these options and the way the
component acts when more than one value is set.

Data coding is an 8 bit field in the SMPP wire format.

Alphabet corresponds to bits 0-3 of the data coding field.  For some
types of message, where a message class is used (by setting bit 5 of the
data coding field), the lower two bits of the data coding field are not
interpreted as alphabet and only bits 2 and 3 impact the alphabet.

Furthermore, current version of the JSMPP library only seems to support
bits 2 and 3, assuming that bits 0 and 1 are used for message class. 
This is why the Alphabet class in JSMPP doesn't support the value 3
(binary 0011) which indicates ISO-8859-1.

Although JSMPP provides a representation of the message class parameter,
the Camel component doesn't currently provide a way to set it other than
manually setting the corresponding bits in the data coding field.

When setting the data coding field in the outgoing message, the Camel
component considers the following values and uses the first one it can
find:

* the data coding specified in a header
* the alphabet specified in a header
* the data coding specified in the endpoint configuration (URI
parameter)

In addition to trying to send the data coding value to the SMSC, the
Camel component also tries to analyze the message body, converts it to a
Java String (Unicode) and converts that to a byte array in the
corresponding alphabet. When deciding which alphabet to use in the byte
array, the Camel SMPP component does not consider the data coding value
(header or configuration), it only considers the specified alphabet
(from either the header or endpoint parameter).

If some characters in the String can not be represented in the chosen
alphabet, they may be replaced by the question mark ( ? ) symbol.  Users
of the API may want to consider checking if their message body can be
converted to ISO-8859-1 before passing it to the component and if not,
setting the alphabet header to request UCS-2 encoding.  If the alphabet
and data coding options are not specified at all then the component may
try to detect the required encoding and set the data coding for you.

The list of alphabet codes are specified in the SMPP specification v3.4,
section 5.2.19.  One notable limitation of the SMPP specification is
that there is no alphabet code for explicitly requesting use of the GSM
3.38 (7 bit) character set.  Choosing the value 0 for the alphabet
selects the SMSC _default_ alphabet, this usually means GSM 3.38 but it
is not guaranteed.  The SMPP gateway Nexmo
https://help.nexmo.com/hc/en-us/articles/204015813-How-to-change-the-character-encoding-in-SMPP-[actually
allows the default to be mapped to any other character set with a
control panel option]. It is suggested that users check with their SMSC
operator to confirm exactly which character set is being used as the
default.

== Message splitting and throttling

After transforming a message body from a String to a byte array, the
Camel component is also responsible for splitting the message into parts
(within the 140 byte SMS size limit) before passing it to JSMPP.  This
is completed automatically.

If the GSM 3.38 alphabet is used, the component will pack up to 160
characters into the 140 byte message body.  If an 8 bit character set is
used (e.g. ISO-8859-1 for western Europe) then 140 characters will be
allowed within the 140 byte message body.  If 16 bit UCS-2 encoding is
used then just 70 characters fit into each 140 byte message.

Some SMSC providers implement throttling rules.  Each part of a message
that has been split may be counted separately by the provider's
throttling mechanism.  The Camel Throttler component can be useful for
throttling messages in the SMPP route before handing them to the SMSC.

== URI format

[source,java]
--------------------------------------------
smpp://[username@]hostname[:port][?options]
smpps://[username@]hostname[:port][?options]
--------------------------------------------

If no *username* is provided, then Camel will provide the default value
`smppclient`. +
 If no *port* number is provided, then Camel will provide the default
value `2775`. +
If the protocol name is ""smpps"", camel-smpp with try to
use SSLSocket to init a connection to the server.

You can append query options to the URI in the following format,
`?option=value&option=value&...`

== URI Options




// component options: START
The SMPP component supports 41 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *initialReconnectDelay* (common) | Defines the initial delay in milliseconds after the consumer/producer tries to reconnect to the SMSC, after the connection was lost. | 5000 | long
| *maxReconnect* (common) | Defines the maximum number of attempts to reconnect to the SMSC, if SMSC returns a negative bind response | 2147483647 | int
| *reconnectDelay* (common) | Defines the interval in milliseconds between the reconnect attempts, if the connection to the SMSC was lost and the previous was not succeed. | 5000 | long
| *splittingPolicy* (common) | You can specify a policy for handling long messages: ALLOW - the default, long messages are split to 140 bytes per message TRUNCATE - long messages are split and only the first fragment will be sent to the SMSC. Some carriers drop subsequent fragments so this reduces load on the SMPP connection sending parts of a message that will never be delivered. REJECT - if a message would need to be split, it is rejected with an SMPP NegativeResponseException and the reason code signifying the message is too long. There are 3 enums and the value can be one of: ALLOW, REJECT, TRUNCATE | ALLOW | SmppSplittingPolicy
| *systemType* (common) | This parameter is used to categorize the type of ESME (External Short Message Entity) that is binding to the SMSC (max. 13 characters). |  | String
| *addressRange* (consumer) | You can specify the address range for the SmppConsumer as defined in section 5.2.7 of the SMPP 3.4 specification. The SmppConsumer will receive messages only from SMSC's which target an address (MSISDN or IP address) within this range. |  | String
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *destAddr* (producer) | Defines the destination SME address. For mobile terminated messages, this is the directory number of the recipient MS. Only for SubmitSm, SubmitMulti, CancelSm and DataSm. | 1717 | String
| *destAddrNpi* (producer) | Defines the type of number (TON) to be used in the SME destination address parameters. Only for SubmitSm, SubmitMulti, CancelSm and DataSm. The following NPI values are defined: 0: Unknown 1: ISDN (E163/E164) 2: Data (X.121) 3: Telex (F.69) 6: Land Mobile (E.212) 8: National 9: Private 10: ERMES 13: Internet (IP) 18: WAP Client Id (to be defined by WAP Forum). There are 10 enums and the value can be one of: 0, 1, 2, 3, 6, 8, 9, 10, 13, 18 |  | byte
| *destAddrTon* (producer) | Defines the type of number (TON) to be used in the SME destination address parameters. Only for SubmitSm, SubmitMulti, CancelSm and DataSm. The following TON values are defined: 0: Unknown 1: International 2: National 3: Network Specific 4: Subscriber Number 5: Alphanumeric 6: Abbreviated. There are 7 enums and the value can be one of: 0, 1, 2, 3, 4, 5, 6 |  | byte
| *lazySessionCreation* (producer) | Sessions can be lazily created to avoid exceptions, if the SMSC is not available when the Camel producer is started. Camel will check the in message headers 'CamelSmppSystemId' and 'CamelSmppPassword' of the first exchange. If they are present, Camel will use these data to connect to the SMSC. | false | boolean
| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. | false | boolean
| *numberingPlanIndicator* (producer) | Defines the numeric plan indicator (NPI) to be used in the SME. The following NPI values are defined: 0: Unknown 1: ISDN (E163/E164) 2: Data (X.121) 3: Telex (F.69) 6: Land Mobile (E.212) 8: National 9: Private 10: ERMES 13: Internet (IP) 18: WAP Client Id (to be defined by WAP Forum). There are 10 enums and the value can be one of: 0, 1, 2, 3, 6, 8, 9, 10, 13, 18 |  | byte
| *priorityFlag* (producer) | Allows the originating SME to assign a priority level to the short message. Only for SubmitSm and SubmitMulti. Four Priority Levels are supported: 0: Level 0 (lowest) priority 1: Level 1 priority 2: Level 2 priority 3: Level 3 (highest) priority. There are 4 enums and the value can be one of: 0, 1, 2, 3 |  | byte
| *protocolId* (producer) | The protocol id |  | byte
| *registeredDelivery* (producer) | Is used to request an SMSC delivery receipt and/or SME originated acknowledgements. The following values are defined: 0: No SMSC delivery receipt requested. 1: SMSC delivery receipt requested where final delivery outcome is success or failure. 2: SMSC delivery receipt requested where the final delivery outcome is delivery failure. There are 3 enums and the value can be one of: 0, 1, 2 |  | byte
| *replaceIfPresentFlag* (producer) | Used to request the SMSC to replace a previously submitted message, that is still pending delivery. The SMSC will replace an existing message provided that the source address, destination address and service type match the same fields in the new message. The following replace if present flag values are defined: 0: Don't replace 1: Replace. There are 2 enums and the value can be one of: 0, 1 |  | byte
| *serviceType* (producer) | The service type parameter can be used to indicate the SMS Application service associated with the message. The following generic service_types are defined: CMT: Cellular Messaging CPT: Cellular Paging VMN: Voice Mail Notification VMA: Voice Mail Alerting WAP: Wireless Application Protocol USSD: Unstructured Supplementary Services Data. There are 6 enums and the value can be one of: CMT, CPT, VMN, VMA, WAP, USSD |  | String
| *sourceAddr* (producer) | Defines the address of SME (Short Message Entity) which originated this message. | 1616 | String
| *sourceAddrNpi* (producer) | Defines the numeric plan indicator (NPI) to be used in the SME originator address parameters. The following NPI values are defined: 0: Unknown 1: ISDN (E163/E164) 2: Data (X.121) 3: Telex (F.69) 6: Land Mobile (E.212) 8: National 9: Private 10: ERMES 13: Internet (IP) 18: WAP Client Id (to be defined by WAP Forum). There are 10 enums and the value can be one of: 0, 1, 2, 3, 6, 8, 9, 10, 13, 18 |  | byte
| *sourceAddrTon* (producer) | Defines the type of number (TON) to be used in the SME originator address parameters. The following TON values are defined: 0: Unknown 1: International 2: National 3: Network Specific 4: Subscriber Number 5: Alphanumeric 6: Abbreviated. There are 7 enums and the value can be one of: 0, 1, 2, 3, 4, 5, 6 |  | byte
| *typeOfNumber* (producer) | Defines the type of number (TON) to be used in the SME. The following TON values are defined: 0: Unknown 1: International 2: National 3: Network Specific 4: Subscriber Number 5: Alphanumeric 6: Abbreviated. There are 7 enums and the value can be one of: 0, 1, 2, 3, 4, 5, 6 |  | byte
| *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
| *configuration* (advanced) | To use the shared SmppConfiguration as configuration. |  | SmppConfiguration
| *enquireLinkTimer* (advanced) | Defines the interval in milliseconds between the confidence checks. The confidence check is used to test the communication path between an ESME and an SMSC. | 60000 | Integer
| *pduProcessorDegree* (advanced) | Sets the number of threads which can read PDU and process them in parallel. | 3 | Integer
| *pduProcessorQueueCapacity* (advanced) | Sets the capacity of the working queue for PDU processing. | 100 | Integer
| *sessionStateListener* (advanced) | You can refer to a org.jsmpp.session.SessionStateListener in the Registry to receive callbacks when the session state changed. |  | SessionStateListener
| *singleDLR* (advanced) | When true, the SMSC delivery receipt would be requested only for the last segment of a multi-segment (long) message. For short messages, with only 1 segment the behaviour is unchanged. | false | boolean
| *transactionTimer* (advanced) | Defines the maximum period of inactivity allowed after a transaction, after which an SMPP entity may assume that the session is no longer active. This timer may be active on either communicating SMPP entity (i.e. SMSC or ESME). | 10000 | Integer
| *alphabet* (codec) | Defines encoding of data according the SMPP 3.4 specification, section 5.2.19. 0: SMSC Default Alphabet 4: 8 bit Alphabet 8: UCS2 Alphabet. There are 3 enums and the value can be one of: 0, 4, 8 |  | byte
| *dataCoding* (codec) | Defines the data coding according the SMPP 3.4 specification, section 5.2.19. Example data encodings are: 0: SMSC Default Alphabet 3: Latin 1 (ISO-8859-1) 4: Octet unspecified (8-bit binary) 8: UCS2 (ISO/IEC-10646) 13: Extended Kanji JIS(X 0212-1990) |  | byte
| *encoding* (codec) | Defines the encoding scheme of the short message user data. Only for SubmitSm, ReplaceSm and SubmitMulti. | ISO-8859-1 | String
| *httpProxyHost* (proxy) | If you need to tunnel SMPP through a HTTP proxy, set this attribute to the hostname or ip address of your HTTP proxy. |  | String
| *httpProxyPassword* (proxy) | If your HTTP proxy requires basic authentication, set this attribute to the password required for your HTTP proxy. |  | String
| *httpProxyPort* (proxy) | If you need to tunnel SMPP through a HTTP proxy, set this attribute to the port of your HTTP proxy. | 3128 | Integer
| *httpProxyUsername* (proxy) | If your HTTP proxy requires basic authentication, set this attribute to the username required for your HTTP proxy. |  | String
| *proxyHeaders* (proxy) | These headers will be passed to the proxy server while establishing the connection. |  | Map
| *password* (security) | The password for connecting to SMSC server. |  | String
| *systemId* (security) | The system id (username) for connecting to SMSC server. | smppclient | String
| *usingSSL* (security) | Whether using SSL with the smpps protocol | false | boolean
|===
// component options: END






// endpoint options: START
The SMPP endpoint is configured using URI syntax:

----
smpp:host:port
----

with the following path and query parameters:

=== Path Parameters (2 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *host* | Hostname for the SMSC server to use. | localhost | String
| *port* | Port number for the SMSC server to use. | 2775 | Integer
|===


=== Query Parameters (41 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *initialReconnectDelay* (common) | Defines the initial delay in milliseconds after the consumer/producer tries to reconnect to the SMSC, after the connection was lost. | 5000 | long
| *maxReconnect* (common) | Defines the maximum number of attempts to reconnect to the SMSC, if SMSC returns a negative bind response | 2147483647 | int
| *reconnectDelay* (common) | Defines the interval in milliseconds between the reconnect attempts, if the connection to the SMSC was lost and the previous was not succeed. | 5000 | long
| *splittingPolicy* (common) | You can specify a policy for handling long messages: ALLOW - the default, long messages are split to 140 bytes per message TRUNCATE - long messages are split and only the first fragment will be sent to the SMSC. Some carriers drop subsequent fragments so this reduces load on the SMPP connection sending parts of a message that will never be delivered. REJECT - if a message would need to be split, it is rejected with an SMPP NegativeResponseException and the reason code signifying the message is too long. There are 3 enums and the value can be one of: ALLOW, REJECT, TRUNCATE | ALLOW | SmppSplittingPolicy
| *systemType* (common) | This parameter is used to categorize the type of ESME (External Short Message Entity) that is binding to the SMSC (max. 13 characters). |  | String
| *addressRange* (consumer) | You can specify the address range for the SmppConsumer as defined in section 5.2.7 of the SMPP 3.4 specification. The SmppConsumer will receive messages only from SMSC's which target an address (MSISDN or IP address) within this range. |  | String
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the consumer will deal with exceptions, that will be logged at WARN or ERROR level and ignored. |  | ExceptionHandler
| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. There are 3 enums and the value can be one of: InOnly, InOut, InOptionalOut |  | ExchangePattern
| *destAddr* (producer) | Defines the destination SME address. For mobile terminated messages, this is the directory number of the recipient MS. Only for SubmitSm, SubmitMulti, CancelSm and DataSm. | 1717 | String
| *destAddrNpi* (producer) | Defines the type of number (TON) to be used in the SME destination address parameters. Only for SubmitSm, SubmitMulti, CancelSm and DataSm. The following NPI values are defined: 0: Unknown 1: ISDN (E163/E164) 2: Data (X.121) 3: Telex (F.69) 6: Land Mobile (E.212) 8: National 9: Private 10: ERMES 13: Internet (IP) 18: WAP Client Id (to be defined by WAP Forum). There are 10 enums and the value can be one of: 0, 1, 2, 3, 6, 8, 9, 10, 13, 18 |  | byte
| *destAddrTon* (producer) | Defines the type of number (TON) to be used in the SME destination address parameters. Only for SubmitSm, SubmitMulti, CancelSm and DataSm. The following TON values are defined: 0: Unknown 1: International 2: National 3: Network Specific 4: Subscriber Number 5: Alphanumeric 6: Abbreviated. There are 7 enums and the value can be one of: 0, 1, 2, 3, 4, 5, 6 |  | byte
| *lazySessionCreation* (producer) | Sessions can be lazily created to avoid exceptions, if the SMSC is not available when the Camel producer is started. Camel will check the in message headers 'CamelSmppSystemId' and 'CamelSmppPassword' of the first exchange. If they are present, Camel will use these data to connect to the SMSC. | false | boolean
| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. | false | boolean
| *numberingPlanIndicator* (producer) | Defines the numeric plan indicator (NPI) to be used in the SME. The following NPI values are defined: 0: Unknown 1: ISDN (E163/E164) 2: Data (X.121) 3: Telex (F.69) 6: Land Mobile (E.212) 8: National 9: Private 10: ERMES 13: Internet (IP) 18: WAP Client Id (to be defined by WAP Forum). There are 10 enums and the value can be one of: 0, 1, 2, 3, 6, 8, 9, 10, 13, 18 |  | byte
| *priorityFlag* (producer) | Allows the originating SME to assign a priority level to the short message. Only for SubmitSm and SubmitMulti. Four Priority Levels are supported: 0: Level 0 (lowest) priority 1: Level 1 priority 2: Level 2 priority 3: Level 3 (highest) priority. There are 4 enums and the value can be one of: 0, 1, 2, 3 |  | byte
| *protocolId* (producer) | The protocol id |  | byte
| *registeredDelivery* (producer) | Is used to request an SMSC delivery receipt and/or SME originated acknowledgements. The following values are defined: 0: No SMSC delivery receipt requested. 1: SMSC delivery receipt requested where final delivery outcome is success or failure. 2: SMSC delivery receipt requested where the final delivery outcome is delivery failure. There are 3 enums and the value can be one of: 0, 1, 2 |  | byte
| *replaceIfPresentFlag* (producer) | Used to request the SMSC to replace a previously submitted message, that is still pending delivery. The SMSC will replace an existing message provided that the source address, destination address and service type match the same fields in the new message. The following replace if present flag values are defined: 0: Don't replace 1: Replace. There are 2 enums and the value can be one of: 0, 1 |  | byte
| *serviceType* (producer) | The service type parameter can be used to indicate the SMS Application service associated with the message. The following generic service_types are defined: CMT: Cellular Messaging CPT: Cellular Paging VMN: Voice Mail Notification VMA: Voice Mail Alerting WAP: Wireless Application Protocol USSD: Unstructured Supplementary Services Data. There are 6 enums and the value can be one of: CMT, CPT, VMN, VMA, WAP, USSD |  | String
| *sourceAddr* (producer) | Defines the address of SME (Short Message Entity) which originated this message. | 1616 | String
| *sourceAddrNpi* (producer) | Defines the numeric plan indicator (NPI) to be used in the SME originator address parameters. The following NPI values are defined: 0: Unknown 1: ISDN (E163/E164) 2: Data (X.121) 3: Telex (F.69) 6: Land Mobile (E.212) 8: National 9: Private 10: ERMES 13: Internet (IP) 18: WAP Client Id (to be defined by WAP Forum). There are 10 enums and the value can be one of: 0, 1, 2, 3, 6, 8, 9, 10, 13, 18 |  | byte
| *sourceAddrTon* (producer) | Defines the type of number (TON) to be used in the SME originator address parameters. The following TON values are defined: 0: Unknown 1: International 2: National 3: Network Specific 4: Subscriber Number 5: Alphanumeric 6: Abbreviated. There are 7 enums and the value can be one of: 0, 1, 2, 3, 4, 5, 6 |  | byte
| *typeOfNumber* (producer) | Defines the type of number (TON) to be used in the SME. The following TON values are defined: 0: Unknown 1: International 2: National 3: Network Specific 4: Subscriber Number 5: Alphanumeric 6: Abbreviated. There are 7 enums and the value can be one of: 0, 1, 2, 3, 4, 5, 6 |  | byte
| *enquireLinkTimer* (advanced) | Defines the interval in milliseconds between the confidence checks. The confidence check is used to test the communication path between an ESME and an SMSC. | 60000 | Integer
| *pduProcessorDegree* (advanced) | Sets the number of threads which can read PDU and process them in parallel. | 3 | Integer
| *pduProcessorQueueCapacity* (advanced) | Sets the capacity of the working queue for PDU processing. | 100 | Integer
| *sessionStateListener* (advanced) | You can refer to a org.jsmpp.session.SessionStateListener in the Registry to receive callbacks when the session state changed. |  | SessionStateListener
| *singleDLR* (advanced) | When true, the SMSC delivery receipt would be requested only for the last segment of a multi-segment (long) message. For short messages, with only 1 segment the behaviour is unchanged. | false | boolean
| *transactionTimer* (advanced) | Defines the maximum period of inactivity allowed after a transaction, after which an SMPP entity may assume that the session is no longer active. This timer may be active on either communicating SMPP entity (i.e. SMSC or ESME). | 10000 | Integer
| *alphabet* (codec) | Defines encoding of data according the SMPP 3.4 specification, section 5.2.19. 0: SMSC Default Alphabet 4: 8 bit Alphabet 8: UCS2 Alphabet. There are 3 enums and the value can be one of: 0, 4, 8 |  | byte
| *dataCoding* (codec) | Defines the data coding according the SMPP 3.4 specification, section 5.2.19. Example data encodings are: 0: SMSC Default Alphabet 3: Latin 1 (ISO-8859-1) 4: Octet unspecified (8-bit binary) 8: UCS2 (ISO/IEC-10646) 13: Extended Kanji JIS(X 0212-1990) |  | byte
| *encoding* (codec) | Defines the encoding scheme of the short message user data. Only for SubmitSm, ReplaceSm and SubmitMulti. | ISO-8859-1 | String
| *httpProxyHost* (proxy) | If you need to tunnel SMPP through a HTTP proxy, set this attribute to the hostname or ip address of your HTTP proxy. |  | String
| *httpProxyPassword* (proxy) | If your HTTP proxy requires basic authentication, set this attribute to the password required for your HTTP proxy. |  | String
| *httpProxyPort* (proxy) | If you need to tunnel SMPP through a HTTP proxy, set this attribute to the port of your HTTP proxy. | 3128 | Integer
| *httpProxyUsername* (proxy) | If your HTTP proxy requires basic authentication, set this attribute to the username required for your HTTP proxy. |  | String
| *proxyHeaders* (proxy) | These headers will be passed to the proxy server while establishing the connection. |  | Map
| *password* (security) | The password for connecting to SMSC server. |  | String
| *systemId* (security) | The system id (username) for connecting to SMSC server. | smppclient | String
| *usingSSL* (security) | Whether using SSL with the smpps protocol | false | boolean
|===
// endpoint options: END




You can have as many of these options as you like.

[source,java]
------------------------------------------------------------------------------------------------------------------
smpp://smppclient@localhost:2775?password=password&enquireLinkTimer=3000&transactionTimer=5000&systemType=consumer
------------------------------------------------------------------------------------------------------------------

== Producer Message Headers

The following message headers can be used to affect the behavior of the
SMPP producer

[width=""100%"",cols=""10%,10%,80%"",options=""header"",]
|=======================================================================
|Header |Type |Description

|`CamelSmppDestAddr` |`List`/`String` |*only for SubmitSm, SubmitMulti, CancelSm and DataSm* Defines the
destination SME address(es). For mobile terminated messages, this is the
directory number of the recipient MS. It must be a `List<String>` for
SubmitMulti and a `String` otherwise.

|`CamelSmppDestAddrTon` |`Byte` |*only for SubmitSm, SubmitMulti, CancelSm and DataSm* Defines the type
of number (TON) to be used in the SME destination address parameters.
Use the `sourceAddrTon` URI option values defined above.

|`CamelSmppDestAddrNpi` |`Byte` |*only for SubmitSm, SubmitMulti, CancelSm and DataSm* Defines the
numeric plan indicator (NPI) to be used in the SME destination address
parameters. Use the URI option `sourceAddrNpi` values defined above.

|`CamelSmppSourceAddr` |`String` |Defines the address of SME (Short Message Entity) which originated this
message.

|`CamelSmppSourceAddrTon` |`Byte` |Defines the type of number (TON) to be used in the SME originator
address parameters. Use the `sourceAddrTon` URI option values defined
above.

|`CamelSmppSourceAddrNpi` |`Byte` |Defines the numeric plan indicator (NPI) to be used in the SME
originator address parameters. Use the URI option `sourceAddrNpi` values
defined above.

|`CamelSmppServiceType` |`String` |The service type parameter can be used to indicate the SMS Application
service associated with the message. Use the URI option `serviceType`
settings above.

|`CamelSmppRegisteredDelivery` |`Byte` |*only for SubmitSm, ReplaceSm, SubmitMulti and DataSm* Is used to
request an SMSC delivery receipt and/or SME originated acknowledgements.
Use the URI option `registeredDelivery` settings above.

|`CamelSmppSingleDLR` | `Boolean` | *only for SubmitSm, SubmitMulti* Is used to
request the SMSC delivery receipt only on the last segment of multi-segment (long) messages.
Use the URI option `singleDLR` settings above.

|`CamelSmppPriorityFlag` |`Byte` |*only for SubmitSm and SubmitMulti* Allows the originating SME to assign
a priority level to the short message. Use the URI option `priorityFlag`
settings above.

|`CamelSmppScheduleDeliveryTime` |`Date` |*only for SubmitSm, SubmitMulti and ReplaceSm* This parameter specifies
the scheduled time at which the message delivery should be first
attempted. It defines either the absolute date and time or relative time
from the current SMSC time at which delivery of this message will be
attempted by the SMSC. It can be specified in either absolute time
format or relative time format. The encoding of a time format is
specified in chapter 7.1.1. in the smpp specification v3.4.

|`CamelSmppValidityPeriod` |`String`/`Date` |*only for SubmitSm, SubmitMulti and ReplaceSm* The validity period
parameter indicates the SMSC expiration time, after which the message
should be discarded if not delivered to the destination. If it's
provided as `Date`, it's interpreted as absolute time or relative time
format if you provide it as `String` as specified in chapter 7.1.1 in
the smpp specification v3.4.

|`CamelSmppReplaceIfPresentFlag` |`Byte` |*only for SubmitSm and SubmitMulti* The replace if present flag
parameter is used to request the SMSC to replace a previously submitted
message, that is still pending delivery. The SMSC will replace an
existing message provided that the source address, destination address
and service type match the same fields in the new message. The following
values are defined: `0`, Don't replace and `1`, Replace

|`CamelSmppAlphabet` / `CamelSmppDataCoding` |`Byte` |*For SubmitSm, SubmitMulti and ReplaceSm*  The data
coding according to the SMPP 3.4 specification, section 5.2.19. Use the
URI option `alphabet` settings above.

|`CamelSmppOptionalParameter` |`Map<Short, Object>` |*only for SubmitSm, SubmitMulti and
DataSm* The optional parameter which are send to the SMSC. The value is
converted in the following way: `String` -> `org.jsmpp.bean.OptionalParameter.COctetString`, 
`byte[]` -> `org.jsmpp.bean.OptionalParameter.OctetString`, 
`Byte` -> `org.jsmpp.bean.OptionalParameter.Byte`,
`Integer` -> `org.jsmpp.bean.OptionalParameter.Int`,
`Short` -> `org.jsmpp.bean.OptionalParameter.Short`, 
`null` -> `org.jsmpp.bean.OptionalParameter.Null`

|CamelSmppEncoding |String |*only for SubmitSm,
SubmitMulti and DataSm*.  Specifies the encoding (character set name) of
the bytes in the message body.  If the message body is a string then
this is not relevant because Java Strings are always Unicode.  If the
body is a byte array then this header can be used to indicate that it is
ISO-8859-1 or some other value.  Default value is specified by the
endpoint configuration parameter _encoding_

|CamelSmppSplittingPolicy |String |*only for SubmitSm,
SubmitMulti and DataSm*.  Specifies the policy for message splitting for
this exchange.  Possible values are described in the endpoint
configuration parameter _splittingPolicy_
|=======================================================================

The following message headers are used by the SMPP producer to set the
response from the SMSC in the message header

[width=""100%"",cols=""10%,10%,80%"",options=""header"",]
|=======================================================================
|Header |Type |Description

|`CamelSmppId` |`List<String>`/`String` |The id to identify the submitted short message(s) for later use.
In case of a ReplaceSm, QuerySm, CancelSm and DataSm this
header vaule is a `String`. In case of a SubmitSm or SubmitMultiSm this
header vaule is a `List<String>`.

|`CamelSmppSentMessageCount` |`Integer` |*only for SubmitSm and SubmitMultiSm* The total
number of messages which has been sent.

|`CamelSmppError` |`Map<String, List<Map<String, Object>>>` |*only for SubmitMultiSm* The errors which
occurred by sending the short message(s) the form `Map<String, List<Map<String, Object>>>` (messageID : (destAddr :
address, error : errorCode)).

|`CamelSmppOptionalParameter` |`Map<Short, Object>` |*only for DataSm* The optional
parameter which are returned from the SMSC by sending the message. The
key is the `Short` code for the optional parameter. The value is
converted in the following way: 
`org.jsmpp.bean.OptionalParameter.COctetString` -> `String`,
`org.jsmpp.bean.OptionalParameter.OctetString` -> `byte[]`,
`org.jsmpp.bean.OptionalParameter.Byte` -> `Byte`,
`org.jsmpp.bean.OptionalParameter.Int` -> `Integer`,
`org.jsmpp.bean.OptionalParameter.Short` -> `Short`, 
`org.jsmpp.bean.OptionalParameter.Null` -> `null`
|=======================================================================

== Consumer Message Headers

The following message headers are used by the SMPP consumer to set the
request data from the SMSC in the message header

[width=""100%"",cols=""10%,10%,80%"",options=""header"",]
|=======================================================================
|Header |Type |Description

|`CamelSmppSequenceNumber` |`Integer` |*only for AlertNotification, DeliverSm and DataSm* A sequence number
allows a response PDU to be correlated with a request PDU. The
associated SMPP response PDU must preserve this field.

|`CamelSmppCommandId` |`Integer` |*only for AlertNotification, DeliverSm and DataSm* The command id field
identifies the particular SMPP PDU. For the complete list of defined
values see chapter 5.1.2.1 in the smpp specification v3.4.

|`CamelSmppSourceAddr` |`String` |*only for AlertNotification, DeliverSm and DataSm* Defines the address
of SME (Short Message Entity) which originated this message.

|`CamelSmppSourceAddrNpi` |`Byte` |*only for AlertNotification and DataSm* Defines the numeric plan
indicator (NPI) to be used in the SME originator address parameters. Use
the URI option `sourceAddrNpi` values defined above.

|`CamelSmppSourceAddrTon` |`Byte` |*only for AlertNotification and DataSm* Defines the type of number (TON)
to be used in the SME originator address parameters. Use the
`sourceAddrTon` URI option values defined above.

|`CamelSmppEsmeAddr` |`String` |*only for AlertNotification* Defines the destination ESME address. For
mobile terminated messages, this is the directory number of the
recipient MS.

|`CamelSmppEsmeAddrNpi` |`Byte` |*only for AlertNotification* Defines the numeric plan indicator (NPI) to
be used in the ESME originator address parameters. Use the URI option
`sourceAddrNpi` values defined above.

|`CamelSmppEsmeAddrTon` |`Byte` |*only for AlertNotification* Defines the type of number (TON) to be used
in the ESME originator address parameters. Use the `sourceAddrTon` URI
option values defined above.

|`CamelSmppId` |`String` |*only for smsc DeliveryReceipt and DataSm* The message ID allocated to
the message by the SMSC when originally submitted.

|`CamelSmppDelivered` |`Integer` |*only for smsc DeliveryReceipt* Number of short messages delivered. This
is only relevant where the original message was submitted to a
distribution list.The value is padded with leading zeros if necessary.

|`CamelSmppDoneDate` |`Date` |*only for smsc DeliveryReceipt* The time and date at which the short
message reached it's final state. The format is as follows: YYMMDDhhmm.

|`CamelSmppStatus` |`DeliveryReceiptState` |*only for smsc DeliveryReceipt:* The final status of the message. The
following values are defined: `DELIVRD`: Message is delivered to destination,
`EXPIRED`: Message validity period has expired,
`DELETED`: Message has been deleted, 
`UNDELIV`: Message is undeliverable, 
`ACCEPTD`: Message is in accepted state (i.e. has been manually read on
behalf of the subscriber by customer service),
`UNKNOWN`: Message is in invalid state,
`REJECTD`: Message is in a rejected state

|`CamelSmppCommandStatus` |`Integer` |*only for DataSm* The Command status of the message.

|`CamelSmppError` |`String` |*only for smsc DeliveryReceipt* Where appropriate this may hold a
Network specific error code or an SMSC error code for the attempted
delivery of the message. These errors are Network or SMSC specific and
are not included here.

|`CamelSmppSubmitDate` |`Date` |*only for smsc DeliveryReceipt* The time and date at which the short
message was submitted. In the case of a message which has been replaced,
this is the date that the original message was replaced. The format is
as follows: YYMMDDhhmm.

|`CamelSmppSubmitted` |`Integer` |*only for smsc DeliveryReceipt* Number of short messages originally
submitted. This is only relevant when the original message was submitted
to a distribution list.The value is padded with leading zeros if
necessary.

|`CamelSmppDestAddr` |`String` |*only for DeliverSm and DataSm:* Defines the destination SME address.
For mobile terminated messages, this is the directory number of the
recipient MS.

|`CamelSmppScheduleDeliveryTime` |`String` |*only for DeliverSm:* This parameter specifies the scheduled time at
which the message delivery should be first attempted. It defines either
the absolute date and time or relative time from the current SMSC time
at which delivery of this message will be attempted by the SMSC. It can
be specified in either absolute time format or relative time format. The
encoding of a time format is specified in Section 7.1.1. in the smpp
specification v3.4.

|`CamelSmppValidityPeriod` |`String` |*only for DeliverSm* The validity period parameter indicates the SMSC
expiration time, after which the message should be discarded if not
delivered to the destination. It can be defined in absolute time format
or relative time format. The encoding of absolute and relative time
format is specified in Section 7.1.1 in the smpp specification v3.4.

|`CamelSmppServiceType` |`String` |*only for DeliverSm and DataSm* The service type parameter indicates the
SMS Application service associated with the message.

|`CamelSmppRegisteredDelivery` |`Byte` |*only for DataSm* Is used to request an delivery receipt and/or SME
originated acknowledgements. Same values as in Producer header list
above.

|`CamelSmppDestAddrNpi` |`Byte` |*only for DataSm* Defines the numeric plan indicator (NPI) in the
destination address parameters. Use the URI option `sourceAddrNpi`
values defined above.

|`CamelSmppDestAddrTon` |`Byte` |*only for DataSm* Defines the type of number (TON) in the destination
address parameters. Use the `sourceAddrTon` URI option values defined
above.

|`CamelSmppMessageType` |`String` |Identifies the type of an incoming message:
`AlertNotification`: an SMSC alert notification,
`DataSm`: an SMSC data short message,
`DeliveryReceipt`: an SMSC delivery receipt,
`DeliverSm`: an SMSC deliver short message

|`CamelSmppOptionalParameter` |`Map<Short, Object>` |*only for DeliverSm* The optional
parameters send back by the SMSC. The key is the `Short` code for the
optional parameter. The value is converted in the following way: 
`org.jsmpp.bean.OptionalParameter.COctetString` -> `String`,
`org.jsmpp.bean.OptionalParameter.OctetString` -> `byte[]`,
`org.jsmpp.bean.OptionalParameter.Byte` -> `Byte`,
`org.jsmpp.bean.OptionalParameter.Int` -> `Integer`,
`org.jsmpp.bean.OptionalParameter.Short` -> `Short`,
`org.jsmpp.bean.OptionalParameter.Null` -> `null`
|=======================================================================

[TIP]
====
*JSMPP library*

See the documentation of the http://jsmpp.org[JSMPP Library] for more
details about the underlying library.
====

== Exception handling

This component supports the general Camel exception handling
capabilities

When an error occurs sending a message with SubmitSm (the default
action), the org.apache.camel.component.smpp.SmppException is thrown
with a nested exception, org.jsmpp.extra.NegativeResponseException. 
Call NegativeResponseException.getCommandStatus() to obtain the exact
SMPP negative response code, the values are explained in the SMPP
specification 3.4, section 5.1.3. +
When the SMPP consumer receives a `DeliverSm` or
`DataSm` short message and the processing of these messages fails, you
can also throw a `ProcessRequestException` instead of handle the
failure. In this case, this exception is forwarded to the underlying
http://jsmpp.org[JSMPP library] which will return the included error
code to the SMSC. This feature is useful to e.g. instruct the SMSC to
resend the short message at a later time. This could be done with the
following lines of code:

[source,java]
--------------------------------------------------------------------------------------------------------------------------
from(""smpp://smppclient@localhost:2775?password=password&enquireLinkTimer=3000&transactionTimer=5000&systemType=consumer"")
  .doTry()
    .to(""bean:dao?method=updateSmsState"")
  .doCatch(Exception.class)
    .throwException(new ProcessRequestException(""update of sms state failed"", 100))
  .end();
--------------------------------------------------------------------------------------------------------------------------

Please refer to the http://smsforum.net/SMPP_v3_4_Issue1_2.zip[SMPP
specification] for the complete list of error codes and their meanings.

== Samples

A route which sends an SMS using the Java DSL:

[source,java]
------------------------------------------------------------------------------------------
from(""direct:start"")
  .to(""smpp://smppclient@localhost:2775?
      password=password&enquireLinkTimer=3000&transactionTimer=5000&systemType=producer"");
------------------------------------------------------------------------------------------

A route which sends an SMS using the Spring XML DSL:

[source,xml]
-----------------------------------------------------------------------------------------------------------
<route>
  <from uri=""direct:start""/>
  <to uri=""smpp://smppclient@localhost:2775?
           password=password&amp;enquireLinkTimer=3000&amp;transactionTimer=5000&amp;systemType=producer""/>
</route>
-----------------------------------------------------------------------------------------------------------

A route which receives an SMS using the Java DSL:

[source,java]
--------------------------------------------------------------------------------------------------------------------------
from(""smpp://smppclient@localhost:2775?password=password&enquireLinkTimer=3000&transactionTimer=5000&systemType=consumer"")
  .to(""bean:foo"");
--------------------------------------------------------------------------------------------------------------------------

A route which receives an SMS using the Spring XML DSL:

[source,xml]
----------------------------------------------------------------------------------------------------------------
  <route>
     <from uri=""smpp://smppclient@localhost:2775?
                password=password&amp;enquireLinkTimer=3000&amp;transactionTimer=5000&amp;systemType=consumer""/>
     <to uri=""bean:foo""/>
  </route>
----------------------------------------------------------------------------------------------------------------

[TIP]
====
*SMSC simulator*

If you need an SMSC simulator for your test, you can use the simulator
provided by
http://opensmpp.logica.com/CommonPart/Download/download2.html#simulator[Logica].
====

== Debug logging

This component has log level *DEBUG*, which can be helpful in debugging
problems. If you use log4j, you can add the following line to your
configuration:

[source,java]
--------------------------------------------------
log4j.logger.org.apache.camel.component.smpp=DEBUG
--------------------------------------------------


include::{page-component-version}@camel-spring-boot::page$smpp-starter.adoc[]
",12188,False,2400.906473775003,median
"[[netty-component]]
= Netty Component
: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[]

*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
| *basicPropertyBinding* (advanced) | *Deprecated* Whether the component 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
| *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
| *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 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[]
",12429,False,2356.1310004779184,median
"// 
//     Licensed to the Apache Software Foundation (ASF) under one
//     or more contributor license agreements.  See the NOTICE file
//     distributed with this work for additional information
//     regarding copyright ownership.  The ASF licenses this file
//     to you under the Apache License, Version 2.0 (the
//     ""License""); you may not use this file except in compliance
//     with the License.  You may obtain a copy of the License at
// 
//       http://www.apache.org/licenses/LICENSE-2.0
// 
//     Unless required by applicable law or agreed to in writing,
//     software distributed under the License is distributed on an
//     ""AS IS"" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
//     KIND, either express or implied.  See the License for the
//     specific language governing permissions and limitations
//     under the License.
//

= Использование поддержки Subversion в IDE NetBeans
:jbake-type: tutorial
:jbake-tags: tutorials 
:jbake-status: published
:icons: font
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:description: Использование поддержки Subversion в IDE NetBeans - Apache NetBeans
:keywords: Apache NetBeans, Tutorials, Использование поддержки Subversion в IDE NetBeans

IDE NetBeans обеспечивает соответствующий уровень интеграции с клиентами Subversion версий 1.6.x и более поздними версиями. Поддержка Subversion в IDE предназначена для упрощения процесса разработки у групп, работающих с общим репозиторием, и позволяет выполнять задачи контроля версий прямо с системы проекта из среды IDE.

В этом документе демонстрируется выполнение основных задач контроля версий в среде IDE путем рассмотрения стандартной последовательности действий при использовании программного обеспечения контроля версий.

Заметим, что поддержка Subversion в NetBeans _не_ работает при использовании из Cygwin.

link:http://subversion.tigris.org/[+Subversion +] — это популярная система контроля версий с открытым кодом, которая стала заменой CVS из следующего поколения программ. Она обладает улучшенными возможностями, например:

* предоставляется полный журнал версий для переименованных, перемещенных или удаленных файлов.
* операции фиксирования неделимы (атомарны), это означает, что набор изменений проекта либо полностью попадает в репозиторий, либо, в случае ошибки подключения, не попадает совсем.
* поддерживается контроль версий метаданных.


image::images/netbeans-stamp-80-74-73.png[title=""Содержимое этой страницы применимо к IDE NetBeans 6.9 или более поздней версии""]


*Для работы с этим учебным курсом требуются программное обеспечение и ресурсы, перечисленные ниже.*

|===
|Программное обеспечение или материал |Требуемая версия 

|link:https://netbeans.org/downloads/index.html[+IDE NetBeans+] |версия 6.9, 7.0, 7.1, 7.2, 7.3, 7.4 или 8.0 

|link:http://java.sun.com/javase/downloads/index.jsp[+Комплект для разработчика на языке Java (JDK)+] |версия 6, 7 или 8 

|link:http://www.open.collab.net/downloads/netbeans/[+Клиентское программное обеспечение Subversion+] |1.6.x или более поздняя 
|===

*Примечание для пользователей Windows. *Входящий в комплект клиент Subversion можно установить как подключаемый модуль IDE NetBeans. Выберите 'Сервис' > 'Подключаемые модули', откройте вкладку 'Доступные подключаемые модули' и установите Bundled Subversion Client для Windows.


== Настройка Subversion

Прежде чем использовать все преимущества поддержки Subversion в среде IDE, необходимо установить клиентское программное обеспечение Subversion. Поддержка Subversion в среде IDE работает путем взаимодействия с клиентом ПО Subversion для выполнения команд контроля версий. В зависимости от системы и пути установки клиентского ПО Subversion, отличающегося от пути по умолчанию, может понадобиться зарегистрировать в среде IDE путь к исполнимому файлу Subversion. Наконец, необходимо убедиться в наличии репозитория Subversion, к которому будет производиться подключение.

* <<getting,Получение программного обеспечения>>
* <<specifying,Указание пути к исполнимому файлу Subversion>>
* <<ensuring,Проверка наличия репозитория для подключения>>


=== Получение программного обеспечения

Необходимо убедиться, что на компьютере установлено следующее программное обеспечение:

* IDE NetBeans (link:https://netbeans.org/downloads/index.html[+загрузка+])
* Java SE Development Kit (link:http://www.oracle.com/technetwork/java/javase/downloads/index.html[+загрузить+])
* Клиентское программное обеспечение Subversion (link:http://www.open.collab.net/downloads/netbeans/[+загрузить+])


=== Укажите путь к исполнимому файлу Subversion.

IDE NetBeans автоматически выполняет попытку определить местоположение исполняемого файла Subversion с помощью системной переменной `$PATH` на компьютере пользователя. Однако, в зависимости от платформы и пути установки клиентского ПО Subversion, отличающегося от пути по умолчанию, может понадобиться указать путь к исполнимому файлу Subversion явным образом.

По умолчанию исполняемый файл Subversion установлен в папке `/usr/bin` или `/usr/local/bin/` на UNIX и OS X компьютера, а также в папке `C:\\Program Files\\Subversion\\bin\\` (или `C:\\Program Files\\CollabNet Subversion\\bin\\`) в Windows.

На компьютерах под управлением *nix местоположение исполнимого файла Subversion можно определить, введя строку `which svn` в окно терминала. На компьютерах под управлением Windows можно запустить поиск файла `svn.exe` по всей системе.

Чтобы указать путь к исполнимому файлу в среде IDE, выполните следующие действия:

1. Выберите 'Сервис' > 'Параметры' ('NetBeans'> 'Предпочтения' в OS X) в главном меню. Откроется диалоговое окно Options (""Параметры"").
2. Выберите значок Miscellaneous (""Разное"") наверху диалогового окна, затем щелкните вкладку Versioning (""Управление версии""). В левой панели под заголовком Versioning Systems (""Системы контроля версий"") выберите Subversion. Параметры пользователя Subversion отображаются в главном окне диалога:

 [.feature]
--
image::images/svn-options-small.png[role=""left"", link=""images/svn-options.png""]
--

3. В текстовом поле Specify the SVN Home Folder (""Указать домашний каталог SVN"") следует либо ввести путь к исполнимому файлу, либо нажать кнопку ""Обзор"" и найти этот путь в системе. Заметим, что нет нужды _включать_ в строку пути исполнимый файл Subversion.
4. Нажмите кнопку ""ОК"" и перезапустите среду IDE, чтобы изменения вступили в силу.


=== Проверка наличия репозитория для подключения

Прежде чем запускать Subversion из среды IDE, необходимо проверить наличие доступа к репозиторию Subversion. Среда IDE _не_ предоставляет средства создания репозиториев Subversion, поскольку эта функция редко используется (в производственной среде репозиторий создается только раз, после того как определится проект размещения репозитория). более того, в этой функции необходимы команды администрирования.

Чтобы поэкспериментировать с поддержкой IDE, используя локальный репозиторий, можно его создать, используя средство link:http://svnbook.red-bean.com/en/1.1/ch09s02.html[+svnadmin+], которое включено в клиентское программное обеспечение Subversion.

Чтобы создать репозиторий Subversion, используется команда `svnadmin create`. В командной строке введите следующее:


[source,java]
----

svnadmin create /path/to/your/repository
----

Дополнительную информацию можно получить в главе link:http://svnbook.red-bean.com/en/1.1/ch05s02.html[+http://svnbook.red-bean.com/en/1.1/ch05s02.html+].

<<top,В начало>>


== Синхронизация локальных файлов с репозиторием

При использовании системы контроля версий выполняется синхронизация локальных файлов с репозиторием, вносятся изменения в локальную копию, затем они фиксируются в репозитории. В следующем списке описываются различные способы синхронизации проекта в IDE NetBeans, в зависимости от определенной ситуации:

* <<opening,Открытие проекта Subversion в среде IDE>>
* <<checking,Взятие файлов для изменения из репозитория>>
* <<importing,Импорт файлов в репозиторий>>


=== Открытие проекта Subversion в среде IDE

Если под контролем Subversion уже имеется проект, с которым ведется работа вне среды IDE, можно открыть его в IDE, и функции контроля версий станут для него доступны автоматически. Среда IDE проверяет открытые проекты на наличие каталогов `.svn`, и для версий проектов в Subversion состояния файлов и контекстно-зависимая поддержка автоматически становятся активными.


=== Получение файлов из репозитория

Если необходимо подключиться к удаленному репозиторию из среды IDE, получить файлы и начать работу с ними, выполните следующее.

1. В IDE NetBeans в главном меню выберите 'Группа' > 'Subversion' > 'Извлечь'. Откроется мастер взятия для изменения. 

*Примечание. *Раскрывающееся меню IDE являются контекстно-зависимыми, то есть доступные параметры зависят от текущего выбранного элемента. Таким образом, во время работы с проектом в Subversion можно выбрать элемент Versioning (""Контроль версий"") > Checkout (""Извлечь"") в главном меню.
2. На первой панели мастера введите URL-адрес, который содержит протокол подключения и путь к репозиторию, к которому необходимо подключиться. 

В среде IDE поддерживаются следующие типы протоколов: 

|===
|Протокол |Метод доступа |Пример 

|*файл* |Прямой доступ к репозиторию (на локальном диске) |`file:///путь_к_репозиторию` 

|*http* |Доступ к серверу с поддержкой Subversion через протокол WebDAV. |`http://имя_узла/путь_к_репозиторию` 

|*https* |Доступ через протокол HTTP с поддержкой шифрования SSL |`https://имя_узла/путь_к_репозиторию` 

|*svn* |Доступ через особый протокол к серверу `svnserve`. |`svn://имя_узла/путь_к_репозиторию` 

|*svn+ssh* |Доступ через протокол SVN с использованием внешнего туннеля SSH |`svn+ssh://имя_узла/путь_к_репозиторию` 
|===

В зависимости от используемого протокола может понадобиться ввести информацию, как, например, имя пользователя или пароль (для `http://`, `https://` или `svn://`), а в случае `svn+ssh://` необходимо указать команду для установления внешнего туннеля. 

*Примечание. *Если выполняется попытка реализации сертифицированной аутентификации с помощью `https`, см: раздел link:http://wiki.netbeans.org/wiki/view/FaqSslUserCert[+Подключение к репозиторию Subversion с помощью аутентификации, сертифицированной пользователем+] 

Дополнительные сведения с `svn+ssh` см. в разделе link:http://wiki.netbeans.org/wiki/view/FaqSubversionSSH[+Настройка SSH с использованием Subversion?+]
3. При использовании прокси необходимо нажать кнопку Proxy Configuration (""Настройка прокси-сервера"") и ввести всю необходимую информацию. Если вы не уверены в правильности параметров подключения к репозиторию, нажмите кнопку ""Далее"".
4. В поле Repository Folder(s) (""Каталог (-и) репозитория"") панели Folders to Checkout (""Каталоги для извлечения"") мастера настройте каталог, который необходимо взять для изменения. Если имя каталога, который необходимо взять для изменения, неизвестно, нажмите кнопку Browse (""Обзор""), чтобы просмотреть каталоги, которые хранятся в репозитории. В диалоговом окне Browse Repository Folders (""Обзор каталогов репозитория"") выберите любой из перечисленных каталогов и нажмите кнопку ""ОК"". Выбранный каталог потом добавляется в поле Repository Folder(s) ('Каталог (-и) репозитория') (каталог 'MyProject&amp;' на снимке экрана ниже).

[.feature]
--
image::images/checkout-small.png[role=""left"", link=""images/checkout.png""]
--

5. Введите номер редакции в поле ""Редакция репозитория"" или оставьте его пустым, что приведет к взятию для изменения каталога _HEAD_ или более поздних редакций.
6. В поле Local Folder (""Локальный каталог"") введите путь к каталогу на компьютере, куда необходимо извлечь файлы. Оставьте установленным флажок ""Поиск проектов Netbeans после выгрузки"", затем нажмите ""Готово"", чтобы инициировать действие взятия. Среда IDE берёт указанные исходные коды для изменения, а в строке состояния IDE отображается ход выполнения загрузки файлов из репозитория в локальный рабочий каталог. Также можно просмотреть файлы и их изъятие в окне 'Выходные данные' (Ctrl-4 в Windows/Cmd-4 в OS X). 

*Примечание. *Если изъятые для использования источники содержат проекты NetBeans, отображается диалоговое окно с запросом на открытие их в IDE. Если в исходных файлах отсутствует проект, появится диалоговое окно с запросом на создание нового проекта из исходных файлов и их открытие в среде IDE. Чтобы создать проект из этих файлов, выберите соответствующую категорию проекта (в мастере создания проекта), затем используйте для нее пункт ""С существующими исходными кодами"".


=== Импорт файлов в репозиторий

В качестве альтернативы можно импортировать проект, с котором вы работаете в среде IDE, в удаленный репозиторий, а затем продолжить с ним работу в среде IDE после его синхронизации.

*Примечание. *При непосредственном _экспорте_ файлов из используемой системы термин 'импорт' используется в системах управления версиями для указания того, что файлы _импортируются в_ репозиторий.

Чтобы импортировать проект в репозиторий, выполните следующее.

1. В окне 'Проекты' (Ctrl-1 в Windows/Cmd-1 в OS X) выберите проект, для которого не осуществляется управление версиями, и выберите 'Управление версиями' > 'Импорт в репозиторий Subversion' в меню правой кнопки мыши этого узла. Открывается мастер импорта в Subversion.
2. В панели ""Репозиторий Subversion"" мастера импорта укажите <<protocolTypes,протокол>> и путь к репозиторию Subversion, как определено в URL-адресе Subversion. В зависимости от сделанного выбора может понадобиться указать такие параметры, как имя пользователя и пароль для репозитория, или, в случае `svn+ssh://`, команду для установления внешнего туннеля. Дополнительные сведения см. в разделе link:http://wiki.netbeans.org/wiki/view/NetBeansUserFAQ#section-NetBeansUserFAQ-VersionControlSystems[+Часто задаваемые вопросы пользователей по Subversion+]. Нажмите кнопку ""Далее"".
3. В панели ""Каталог репозитория"" укажите каталог репозитория, в котором будет находиться проект. По умолчанию в текстовом поле ""Каталог репозитория"" предлагается каталог с названием, совпадающим с названием проекта.
4. В текстовом поле под заголовком ""Укажите сообщение"" введите описание проекта, который импортируется в репозиторий.
5. Нажмите кнопку ""Завершить"" для запуска импорта или кнопку ""Далее"" для перехода на третью панель, которая позволяет просматривать все файлы, приготовленные для импорта. В этой панели можно исключить из импорта отдельные файлы (как показано ниже) или определить типы MIME файлов перед импортом.

[.feature]
--
image::images/import-small.png[role=""left"", link=""images/import.png""]
--

После нажатия кнопки ""Завершить"" среда IDE выгружает в репозиторий файлы проекта, и открывается окно вывода, в котором отображается ход импорта.

<<top,В начало>>


== Изменение файлов исходного кода

Если версия проекта Subversion открыта в среде IDE, можно начать вносить изменения в исходные файлы. Как и в любом проекте, открытом в IDE NetBeans, в редакторе исходного кода можно открывать файлы двойным щелчком на соответствующих узлах по мере их отображения в IDE (например, 'Проекты' (Ctrl-1 в Windows/Cmd-1 в OS X ), 'Файлы'(Ctrl-2 в Windows/Cmd-2 в OS X), 'Избранное' (Ctrl-3 в Windows/Cmd-3 в OS X)).

При работе с файлами исходного кода в среде IDE можно пользоваться различными компонентами пользовательского интерфейса, помогающими как в просмотре, так и в работе с командами контроля версий:

* <<viewingChanges,Просмотр изменений в редакторе исходного кода>>
* <<viewingFileStatus,Просмотр информации о состоянии файла>>
* <<comparing,Сравнение версий файлов>>
* <<merging,Слияние редакций файлов>>


=== Просмотр изменений в редакторе исходного кода

При открытии файла с контролем версий в редакторе исходного кода IDE и внесении в него изменений их можно просматривать в реальном времени в сравнении с ранее полученной версией из репозитория. По ходу работы среда IDE использует условные цвета на полях редактора файлов исходного кода для передачи следующей информации:

|===
|*Синий* (       ) |Обозначает строки, измененные по сравнению с более ранней версией. 

|*Зеленый* (       ) |Обозначает строки, добавленные к более ранней версии. 

|*Красный* (       ) |Обозначает строки, удаленные по сравнению с более ранней версией. 
|===

В левом поле редактора исходного кода отображаются изменения для каждой отдельной строки. При изменении определенной строки изменения немедленно показываются в левом поле.

Можно щелкнуть группирование цвета в поле для вызова команд контроля версий. Например, на снимке экрана ниже показаны элементы оформления, доступные при щелчке красного значка, указывая, что строки были удалены из локальной копии.

На правом поле редактора исходного кода предоставлен обзор изменений, внесенных в файл в целом, сверху донизу. Условные цвета применяются сразу после внесения изменений в файл.

Обратите внимание, что можно щелкнуть определенную точку внутри поля, чтобы немедленно перенести курсор в строке к этому месту файла. Для просмотра числа затронутых строк наведите мышь на цветные значки в правом поле:

|===
|[.feature]
--
image::images/left-ui-small.png[role=""left"", link=""images/left-ui.png""]
--
 
*Левое поле* |image::images/right-ui.png[title=""цветовая кодировка управления версиями отображается на правой границе редактора""] 
*Правое поле* 
|===


=== Просмотр информации о состоянии файла

При работе в окнах ""Проекты"" (CTRL+1 в системе Windows/CMD+1 в системе OS X), ""Файлы"" (CTRL+2 в системе Windows/CMD+2 в системе OS X), ""Избранное"" (CTRL+3 в системе Windows/CMD+3 в системе OS X) или окнах управления версиями некоторые функции отображения среды IDE помогают просматривать информацию о состоянии файла. В примере, приведенном ниже, обратите внимание, как метка (например, image::images/blue-badge.png[]), цвет имени файла и смежная метка состояния соответствуют друг другу для предоставления для пользователей простого и эффективного способа отслеживания данных об изменениях версий файлов: 

image::images/badge-example.png[]

Метки, условные цвета, ярлыки состояния файлов и, что, пожалуй, наиболее важно, окно контроля версий вместе дают дополнительные возможности по просмотру и управлению сведениями о версиях в среде IDE.

* <<badges,Метки и условные цвета>>
* <<fileStatus,Ярлыки состояния файлов>>
* <<versioning,Окно управления версиями>>


==== Метки и условные цвета

Метки относятся к узлам проектов, папок и пакетов. Они сообщают о состоянии файлов внутри соответствующего узла:

Ниже в таблице приведена цветовая схема, используемая для меток.

|===
|Элемент пользовательского интерфейса |Описание 

|*Синяя метка* (image::images/blue-badge.png[]) |Указывает на присутствие файлов, которые были локально изменены, добавлены или удалены. Касательно пакетов, данная метка относится только к самому пакету, но не к его подпакетам. Что касается проектов и папок, метка указывает на изменения как внутри самого элемента, так и внутри любых его подпапок. 

|*Красная метка* (image::images/red-badge.png[]) |Используется для проектов, папок и пакетов, содержащих _конфликтующие_ файлы (например, локальные версии, конфликтующие с версиями, хранящимися в репозитории). Касательно пакетов, данная метка относится только к самому пакету, но не к его подпакетам. Для проектов и папок метка обозначает конфликты этого элемента и всех содержащихся подпапок. 
|===


Цветовое обозначение применяется к именам файлов для обозначения их текущего состояния по сравнению с репозиторием:

|===
|Цвет |Пример |Описание 

|*Синий* |image::images/blue-text.png[] |Обозначает локально измененный файл. 

|*Зеленый* |image::images/green-text.png[] |Обозначает локально добавленный файл. 

|*Красный* |image::images/red-text.png[] |Обозначает, что файл содержит конфликт между локальной рабочей копией и версией в репозитории. 

|*Серый* |image::images/gray-text.png[] |Указывает но то, что файл пропущен системой Subversion и не будет обработан командами контроля версий (такими как ""Update"" (Обновить) и ""Commit"" (Зафиксировать)). Файлы можно сделать игнорируемыми, только если они еще не добавлены под контроль версий. 

|*Перечеркивание* |image::images/strike-through-text.png[] |Указывает на то, что файл исключен из операций фиксации. Перечеркнутый текст отображается только в некоторых местах, например, окно ""Контроль версий"" или диалоговое окно ""Фиксация"", при исключении отдельных файлов из действия фиксации. Такие файлы всё еще могут быть затронуты командами Subversion, такими как ""Update"" (Обновить). 
|===


==== Ярлыки состояния файлов

Ярлыки состояния файлов предоставляют в окнах среды IDE текстовое указание на состояние файлов, включенных в управление версиями. По умолчанию в окнах среды IDE состояние (новый, измененный, игнорируется и т.п.) и информация о папке отображаются в сером цвете справа от файлов, представленных в виде списка. Однако этот формат можно изменить под свои потребности. Например, для добавления номеров редакций к ярлыкам состояния выполните следующее.

1. Выберите 'Сервис' > 'Параметры' ('NetBeans'> 'Предпочтения' на OS X) в главном меню. Откроется окно ""Options"".
2. Выберите кнопку Miscellaneous (""Разное"") наверху диалогового окна, затем щелкните вкладку Versioning (""Контроль версий"") под ним. Убедитесь, что в левой панели под системами управления версиями выбрана система Subversion. (Для справки см. <<svnOptions,снимок экрана>> выше).
3. Нажмите кнопку Add Variable (""Добавить переменную"") справа от текстового поля строки состояния Format (""Формат""). В открывшемся диалоговом окне"" Добавление переменной"" выберите переменную`{revision}` и нажмите ""ОК"". Переменная revision добавляется в текстовое поле ""Формат ярлыка состояния"".
4. Переформатировать метки состояний так, чтобы справа от файлов отображались только их состояние и редакция, можно, изменив порядок следования содержимое текстового поля ""Формат меток состояний"" на следующий:

[source,java]
----

[{status}; {revision}]
----
Нажмите кнопку ""ОК"". Ярлыки состояния теперь показывают состояние файла и номер редакции (где это применимо). 

Ярлыки состояния файлов можно включать и отключать. Для этого в главном меню выберите ""Вид"" > ""Показать ярлыки контроля версий"".


image::images/file-labels.png[]

Ярлыки состояния файлов можно включать и отключать. Для этого в главном меню выберите ""Вид"" > ""Показать ярлыки контроля версий"".


==== Окно контроля версий

Окно контроля версий в Subversion предоставляет в реальном времени список всех изменений, произведенных с файлами локальной рабочей копии выбранной папки. По умолчанию оно открывается в нижней панели среды IDE, и в нем перечислены добавленные, удаленные и измененные файлы.

Чтобы открыть окно контроля версий, выберите версию файла или каталога (например, из окна ""Проекты"", ""Файлы"" или ""Избранное"") и либо выберите ""Subversion"" > ""Показать изменения"" из контекстного меню, либо ""Группа"" > ""Показать изменения"" из главного меню. В нижней панели среды IDE откроется следующее окно:

[.feature]
--
image::images/versioning-window-small.png[role=""left"", link=""images/versioning-window.png""]
--

По умолчанию в окне контроля версий отображается список измененных файлов в выбранном пакете или папке. Кнопки на панели инструментов используются для выбора отображения всех изменений или ограничения списка отображаемых файлов локальными или удаленными измененными файлами. Также можно щелкнуть заголовки столбцов над перечисленными файлами, чтобы отсортировать их по имени, состоянию или местоположению.

*Примечания*

* Для получения уведомления об изменении исходного файла в одном из открытых проектов выберите 'Группа' > 'Показать изменения' в главном меню. Либо если открыто окно 'Управление версиями', можно нажать кнопку 'Обновить состояние'.
* Операции в окне 'Проекты' выполняются только над проектами и не являются рекурсивными. Для отображения изменений вложенных/дочерних проектов можно использовать окно 'Файлы' или 'Избранное'.

На панели инструментов окна контроля версий имеются кнопки, которые позволяют назначать самые распространенные задачи Subversion любому файлу из списка. В приведенной ниже таблице дан список команд Subversion, которые доступны из панели инструментов окна контроля версий.

|===
|Значок |Имя |Функция 

|image::images/refresh.png[] |*Refresh Status (""Обновить состояние"")* |Обновление состояния всех выбранных файлов и папок. Файлы, отображаемые в окне контроля версий, можно обновить для отражения любых изменений, внесенных извне. 

|image::images/diff.png[] |*Diff All (""Сравнить все"")* |Открытие представления различий, предоставляющее параллельное сравнение локальных копий и версий в репозитории. 

|image::images/update.png[] |*Update All (""Обновить все"")* |Обновление всех выбранных файлов в репозитории. 

|image::images/commit.png[] |*Фиксировать все* |Позволяет фиксировать локальные изменения в репозитории. 
|===

Для доступа к другим командам Subversion в окне контроля версий необходимо выбрать строку таблицы, соответствующую измененному файлу, а затем выбрать команду в контекстом меню:

image::images/versioning-right-click.png[]

Для примера, с файлом можно выполнить следующие действия:

|===
|* *Показать аннотации*: 

Сведения об авторе и номере редакции в левом поле файлов, открытых в редакторе исходных файлов.
 |image::images/annotations.png[] 

|* *Поиск в журнале*: 

Позволяет искать и сравнивать ранние редакции выбранного файла в окне просмотра журнала в среде IDE. Из окна просмотра журнала можно вызвать команду <<comparing,сравнения>> или вернуть текущую локальную копию в состояние выбранной редакции.
 |[.feature]
--
image::images/history-viewer-small.png[role=""left"", link=""images/history-viewer.png""]
--
 

|* *Исключить из фиксации*: 

Позволяет исключить файл из процесса фиксации.
 |[.feature]
--
image::images/exclude-from-commit-small.png[role=""left"", link=""images/exclude-from-commit.png""]
--
 

|* *Откатить удаление* 

Открывает диалоговое окно ""Откатить изменения"", при помощи которого можно откатывать любые действия по удалению локальных копий файлов. Указанные файлы извлекаются из локального архива журнала и восстанавливаются в локальную рабочую копию.
 |[.feature]
--
image::images/revert-mods-small.png[role=""left"", link=""images/revert-mods.png""]
--
 

|* *Откатить изменения*: 

Открывает диалоговое окно ""Откатить изменения"", при помощи которого можно указать параметры отката любых локальных изменений для редакций, которые хранятся в репозитории. 

При указании редакций можно нажать кнопку ""Поиск"", чтобы открыть диалоговое окно ""Поиск редакции"". Произойдет поиск по репозиторию и вывод редакций в зависимости от введенной даты.
 |[.feature]
--
image::images/search-rev-small.png[role=""left"", link=""images/search-rev.png""]
--
 
|===


=== Сравнение редакций файлов

Сравнение редакций файлов — это распространенная задача при работу с проектами с контролем версий. Среда IDE позволяет сравнивать редакции, используя команду Diff, доступную в контекстном меню выбранного элемента (Subversion > Diff), а также в окне контроля версий. В окне 'Управление версиями', вы можете выполнить сравнение либо двойным щелчком указанного файла, либо щелкнув значок 'Сравнить все' (image::images/diff.png[]), расположенный на панели инструментов в верхней части.

При выполнении сравнения откроется средство просмотра различий для выбранного файла(-в) и редакций в главном окне IDE. В средстве просмотра различий отображаются две копии на параллельных панелях. Текущая копия отображается в правой части, поэтому при сравнении копии в репозитории с рабочей копией последняя отображается на правой панели:

[.feature]
--
image::images/diff-viewer-small.png[role=""left"", link=""images/diff-viewer.png""]
--

В просмотре различий используются те же <<viewingChanges,условные цвета>>, что используются и в других местах для показа изменений под контролем версий. На снимке экрана выше зеленый блок обозначает содержание, добавленное к последней редакции. Красный блок указывает, что содержание из ранней редакции было позднее удалено. Синий указывает, что в выделенных строках произошли изменения.

Также при выполнении сравнения в группе файлов, таких, как проект, пакет или папка, или при щелчке 'Сравнить все' (image::images/diff.png[]), вы можете переключаться между различиями с помощью щелчков файлов, перечисленных в верхней области 'Средства просмотра различий'.

Средство просмотра различий также предоставляет следующие функции:

* <<makeChanges,Внесение изменений в локальную рабочую копию>>
* <<navigateDifferences,Переходы между различиями>>
* <<changeViewCriteria,Изменение критериев просмотра>>


==== Внесение изменений в локальную рабочую копию

При выполнении различия с локальной рабочей копией среда IDE позволяет вносить изменения непосредственно в средстве просмотра различий. Чтобы сделать это, поместите свой курсор внутри правой панели просмотра различий и измените свой файл соответственно, либо используйте значки, отображающиеся в строке рядом с каждым выделенным изменением:

|===
|*Заменить* (image::images/insert.png[]): |Вставка выделенного текста из предыдущей редакции в текущую редакцию 

|*Переместить все* (image::images/arrow.png[]): |Откат текущей редакции файла к состоянию предыдущей выбранной редакции 

|*Удалить * (image::images/remove.png[]): |Удаление выделенного текста из текущей редакции для зеркального соответствия предыдущей редакции 
|===


==== Переходы между различиями в сравниваемых файлах

Если сравнение содержит несколько изменений, между ними можно переходить, используя значки стрелок, отображающиеся на панели инструментов. Значки стрелок позволяют просматривать появляющиеся различия сверху донизу:

|===
|*Предыдущий* (image::images/diff-prev.png[]): |переход к предыдущему различию, отображенному в сравнении. 

|*Далее* (image::images/diff-next.png[]): |переход к следующему различию, отображенному в сравнении. 
|===


==== Изменение критериев просмотра

Можно выбрать просмотр файлов, содержащих изменения, из локальной рабочей копии, репозитория, или одновременно просмотреть оба файла одновременно:

|===
|*Локальный* ( image::images/locally-mod.png[] ): |Отображение только локально измененных файлов 

|*Удаленный* ( image::images/remotely-mod.png[] ): |Отображение только удаленно измененных файлов 

|*Оба* ( image::images/both-mod.png[] ): |Отображение локально и удаленно измененных файлов 
|===

*Примечание.* Цветовая схема, описанная в разделе <<badges, Метки и условные цвета>> не применяется для приведенных выше значков.


=== Слияние редакций файлов

IDE NetBeans обеспечивает возможность слияния изменений между версиями репозитория и локальной рабочей копии. Можно указать диапазон редакций для слияния. Можно даже объединять диапазон редакций из двух разных каталогов репозитория.

Обычно используется следующая схема работы: имеется взятая из головной ветви версия, сохраненная в папке под именем `JavaApp`, и требуется произвести слияние этой копии с ветвью. В целях демонстрации репозиторий содержит каталог `branches`, в котором находятся все ответвленные файлы:

1. В окне 'Проекты', 'Файлы' или 'Избранное' правой кнопкой мыши щелкните файлы или папки, для которых необходимо выполнить операцию слияния, и выберите 'Subversion' > 'Объединить изменения'. Появляется диалоговое окно Merge (""Слияние"").
2. В раскрывающемся списке Merge From (""Слить из"") выберите One Repository Folder Since Its Origin (""Одна папка репозитория после создания""). Переносятся все изменения, которые были сделаны в отдельном файле после его создания.
3. В текстовом поле папки репозитория введите путь к папке, из которой необходимо перенести изменения (`branches/JavaApp`). Оставьте поле ""Конечная редакция"" пустым, чтобы включить все редакции от первой до _HEAD_ (то есть текущего состояния).

[.feature]
--
image::images/svn-merge-small.png[role=""left"", link=""images/svn-merge.png""]
--

4. Щелкните ""Слить"". Среда IDE объединит все различия, которые будут найдены между редакциями ветви и локальной копией файла. При возникновении конфликтов слияния устанавливается состояние файла <<resolving,Конфликт слияния>> для указания на это.

*Примечание. *После слияния изменений с локальной рабочей копией, все равно необходимо зафиксировать изменения, используя команду Commit для того, чтобы они были добавлены в репозиторий.

<<top,В начало>>


== Фиксация исходных файлов в репозитории

После внесения изменений в исходные файла необходимо выполнить их фиксацию в репозитории. Как правило, рекомендуется обновить все копии в соответствии с репозиторием до выполнения фиксации, чтобы обеспечить отсутствие конфликтов. Однако конфликты все равно могут возникать и должны считаться обычным явлением при одновременной работе с проектом множества разработчиков. Среда IDE предоставляет гибкую поддержку, позволяющую выполнять все эти функции. Она также предоставляет компонент разрешения конфликтов, позволяющий корректно устранять конфликты при их возникновении.

* <<updating,Обновление локальных копий>>
* <<resolving,Разрешение конфликтов>>
* <<performing,Выполнение фиксации>>


=== Обновление локальных копий

Обновление выполняются путем выбора 'Subversion' > 'Обновить' из контекстного меню любого элемента, для которого осуществляется управление версиями, в окнах 'Проекты', 'Файлы' или 'Избранное'. При работе напрямую из окна 'Управление версиями' нужно просто щелкнуть правой кнопкой мыши указанный файл и выбрать 'Обновить'.

Чтобы выполнить обновление всех исходных файлов, можно нажать кнопку 'Обновить все' (image::images/update.png[]) на панели инструментов, расположенной в верхней части окон <<versioning,Окно управления версиями>> и <<comparing,Представление различий>>. Все изменения, которые могли быть внесены в репозитории, отображаются в окне ""Вывод версий"".


=== Разрешение конфликтов

При обновлении или фиксировании файлов средства поддержки Subversion сравнивают файлы с исходными файлами из репозитория, чтобы убедиться, что те же файлы уже не изменены ранее. Если извлеченная (или обновленная) редакция больше не совпадает с _HEAD_ репозитория (т.е. с текущей версией), _и_ области кода, которые изменялись в локальной копии, совпадают с областями в HEAD, которые также изменены, обновление или фиксирование приводят к _конфликтам_.

Как указано в <<badges,Метки и цветовая схема>>, конфликты выделяются в среде IDE красным текстом и рядом с ними отображается красный значок (image::images/red-badge.png[]) при просмотре в окнах 'Проекты', 'Файлы', или 'Избранное'. В окне ""Контроль версий"" конфликты отмечены состоянием файлов.

image::images/conflict-versioning-win.png[]

Любой возникший конфликт необходимо разрешить, прежде чем выполнять фиксацию в репозиторий. В среде IDE конфликты можно разрешить с помощью средства разрешения конфликтов слияния. Средство разрешения конфликтов слияния предлагает интуитивно понятный интерфейс, помогающий последовательно разрешать отдельные конфликты во время просмотра результатов слияния. Для получения доступа к средству разрешения конфликтов слияния в конфликтующем файле щелкните правой кнопкой мыши этот файл и выберите 'Subversion' > 'Разрещить конфликты'.

Средство разрешения конфликтов слияния отображает две конфликтующие копии рядом на верхней панели, выделяя при этом конфликтующие области. На нижней панели изображен файл так, как он отображается во время слияния для отдельных конфликтов между двумя редакциями:

[.feature]
--
image::images/conflict-resolver-small.png[role=""left"", link=""images/conflict-resolver.png""]
--

Для разрешения конфликта примите одну из двух редакций, которые отображаются на верхней панели. В редакции, которую необходимо принять нажмите кнопку ""Принять"". Среда IDE сливает принятую редакцию с исходным файлом, и результаты слияния мгновенно отображаются на нижней панели разрешителя конфликтов слияния. Когда все конфликты будут разрешены, нажмите ""ОК"" для выхода из средства разрешения конфликтов слияния и сохранения измененного файла. Метка конфликта будет удалена, и файл можно будет фиксировать в репозитории.


=== Выполнение фиксации

После редактирования исходных файлов, выполнения обновления и устранения конфликтов выполняется фиксация файлов из локальной рабочей копии в репозиторий. Среда IDE позволяет вызывать команду фиксации следующими способами:

* В окне 'Проекты', 'Файлы' или 'Избранное' правой кнопкой мыши щелкните новые или измененные элементы и выберите 'Subversion' > 'Фиксация'.
* В окне 'Управление версиями' или 'Средства просмотра различий' нажмите кнопку 'Фиксировать все' (image::images/commit.png[]) на панели инструментов.

Откроется диалоговое окно ""Фиксация"", в котором отображаются файлы для фиксации в репозитории:

[.feature]
--
image::images/commit-dialog-small.png[role=""left"", link=""images/commit-dialog.png""]
--

В диалоговом окне ""Фиксация"" перечислено следующее:

* все локально измененные файлы;
* все файлы, которые были локально удалены;
* все новые файлы (то есть, файлы, которых пока нет в репозитории);
* все файлы, которые были переименованы. Для хранения переименованных файлов в Subversion удаляются исходные файлы и создаются дубликаты с новым именем.

В диалоговом окне ""Фиксация"" можно указать исключение отдельных файлов из фиксации. Для этого щелкните столбец ""Действие фиксации"" для выбранного файла и выберите пункт ""Исключить из фиксации"" в раскрывающемся списке. Аналогично, при включении новых файлов можно указать тип MIME, выбрав ""Добавить как исходный файл"" или ""Добавить как текст"" в раскрывающемся списке.

Для фиксации выполните следующее.

1. Введите сообщение о фиксации в текстовой области ""Сообщение о фиксации"". В качестве альтернативы щелкните значок 'Последние сообщения' ( image::images/recent-msgs.png[] ), расположенный в правом верхнем углу, чтобы просмотреть и выбрать необходимое из ранее использованного списка сообщений.
2. После указания действий для отдельных файлов щелкните ""Фиксация"". Среда IDE выполнит фиксацию и отправит локальные изменения в репозиторий. В строке состояния IDE, расположенной в правой нижней части интерфейса, отображается выполнение действия фиксации. При успешной фиксации метки контроля версий перестают отображаться в окнах ""Проекты"", ""Файлы"" и ""Избранное"", а для цветового обозначения фиксированных файлов используется черный цвет.

<<top,В начало>>


== Заключение

На этом завершается обзор возможностей Subversion для IDE NetBeans версии 6.x и более поздних версий. В данном документе описано выполнение основных задач контроля версий в среде IDE на примере стандартного порядка действий при использовании поддержки Subversion в среде IDE. В руководстве показано, как настраивать версию проекта и выполнять основные задачи для файлов под контролем версий с помощью некоторых новых функции Subversion в среде IDE.

link:/about/contact_form.html?to=3&subject=Feedback:%20Using%20Subversion%20Support%20in%20NetBeans%20IDE[+Отправить отзыв по этому учебному курсу+]


<<top,В начало>>


== Дополнительные сведения

Материалы на связанные темы:

* link:http://wiki.netbeans.org/wiki/view/NetBeansUserFAQ#section-NetBeansUserFAQ-VersionControlSystems[+Часто задаваемые вопросы по поддержке Subversion для IDE NetBeans+]
* link:http://wiki.netbeans.org/FaqSubversionClients[+Часто задаваемые вопросы о клиентах Subversion+]
* link:git.html[+Использование поддержки Git в IDE NetBeans+]
* link:mercurial.html[+Использование поддержки Mercurial в IDE NetBeans+]
* link:mercurial-queues.html[+Использование поддержки Mercurial Queues в IDE NetBeans+]
* link:cvs.html[+Использование поддержки CVS в IDE NetBeans+]
* link:clearcase.html[+Использование поддержки ClearCase в IDE NetBeans+]
* link:http://www.oracle.com/pls/topic/lookup?ctx=nb8000&id=NBDAG234[+Управление версиями приложений с помощью системы контроля версий+] в _Разработка приложений с помощью IDE NetBeans_.

<<top,В начало>>

",12489,False,2484.009312595741,median
"// Module included in the following assemblies:
//
// * installing/installing_aws/installing-aws-customizations.adoc
// * installing/installing_aws/installing-aws-government-region.adoc
// * installing/installing_aws/installing-aws-network-customizations.adoc
// * installing/installing_aws/installing-aws-private.adoc
// * installing/installing_aws/installing-aws-vpc.adoc
// * installing/installing_aws/installing-restricted-networks-aws-installer-provisioned.adoc
// * installing/installing_azure/installing-azure-customizations.adoc
// * installing/installing_azure/installing-azure-government-region.adoc
// * installing/installing_azure/installing-azure-network-customizations.adoc
// * installing/installing_azure/installing-azure-private.adoc
// * installing/installing_azure/installing-azure-vnet.adoc
// * installing/installing_bare_metal/installing-bare-metal.adoc
// * installing/installing_gcp/installing-gcp-customizations.adoc
// * installing/installing_gcp/installing-gcp-private.adoc
// * installing/installing_gcp/installing-gcp-network-customizations.adoc
// * installing/installing_gcp/installing-gcp-vpc.adoc
// * installing/installing_gcp/installing-restricted-networks-gcp-installer-provisioned.adoc
// * installing/installing_openstack/installing-openstack-installer-custom.adoc
// * installing/installing_openstack/installing-openstack-installer-kuryr.adoc
// * installing/installing_openstack/installing-openstack-user.adoc
// * installing/installing_openstack/installing-openstack-user-kuryr.adoc
// * installing/installing_rhv/installing-rhv-custom.adoc
// * installing/installing_vmc/installing-vmc-customizations.adoc
// * installing/installing_vmc/installing-vmc-network-customizations.adoc
// * installing/installing_vmc/installing-restricted-networks-vmc.adoc
// * installing/installing_vsphere/installing-vsphere-installer-provisioned-customizations.adoc
// * installing/installing_vsphere/installing-vsphere-installer-provisioned-network-customizations.adoc
// * installing/installing_vsphere/installing-restricted-networks-installer-provisioned-vsphere.adoc

ifeval::[""{context}"" == ""installing-aws-customizations""]
:aws:
endif::[]
ifeval::[""{context}"" == ""installing-aws-government-region""]
:aws:
endif::[]
ifeval::[""{context}"" == ""installing-aws-network-customizations""]
:aws:
endif::[]
ifeval::[""{context}"" == ""installing-aws-private""]
:aws:
endif::[]
ifeval::[""{context}"" == ""installing-aws-vpc""]
:aws:
endif::[]
ifeval::[""{context}"" == ""installing-restricted-networks-aws-installer-provisioned""]
:aws:
endif::[]
ifeval::[""{context}"" == ""installing-azure-customizations""]
:azure:
endif::[]
ifeval::[""{context}"" == ""installing-azure-government-region""]
:azure:
endif::[]
ifeval::[""{context}"" == ""installing-azure-network-customizations""]
:azure:
endif::[]
ifeval::[""{context}"" == ""installing-azure-private""]
:azure:
endif::[]
ifeval::[""{context}"" == ""installing-azure-vnet""]
:azure:
endif::[]
ifeval::[""{context}"" == ""installing-gcp-customizations""]
:gcp:
endif::[]
// OSDOCS-1640 - IPv4/IPv6 dual-stack bare metal only
ifeval::[""{context}"" == ""installing-bare-metal""]
:bare:
endif::[]
// OSDOCS-1640 - IPv4/IPv6 dual-stack bare metal only
ifeval::[""{context}"" == ""installing-bare-metal-network-customizations""]
:bare:
endif::[]
// OSDOCS-1640 - IPv4/IPv6 dual-stack bare metal only
ifeval::[""{context}"" == ""installing-restricted-networks-bare-metal""]
:bare:
endif::[]
ifeval::[""{context}"" == ""installing-gcp-private""]
:gcp:
endif::[]
ifeval::[""{context}"" == ""installing-gcp-network-customizations""]
:gcp:
endif::[]
ifeval::[""{context}"" == ""installing-gcp-vpc""]
:gcp:
endif::[]
ifeval::[""{context}"" == ""installing-restricted-networks-gcp-installer-provisioned""]
:gcp:
endif::[]
ifeval::[""{context}"" == ""installing-aws-customizations""]
:aws:
endif::[]
ifeval::[""{context}"" == ""installing-openstack-installer-custom""]
:osp:
:osp-custom:
endif::[]
ifeval::[""{context}"" == ""installing-openstack-installer-kuryr""]
:osp:
:osp-kuryr:
endif::[]
ifeval::[""{context}"" == ""installing-openstack-user""]
:osp:
:osp-custom:
endif::[]
ifeval::[""{context}"" == ""installing-openstack-user-kuryr""]
:osp:
:osp-kuryr:
endif::[]
ifeval::[""{context}"" == ""installing-openstack-user-sr-iov""]
:osp:
:osp-custom:
endif::[]
ifeval::[""{context}"" == ""installing-openstack-user-sr-iov-kuryr""]
:osp:
:osp-kuryr:
endif::[]
ifeval::[""{context}"" == ""installing-rhv-customizations""]
:rhv:
endif::[]
ifeval::[""{context}"" == ""installing-vsphere-installer-provisioned-customizations""]
:vsphere:
endif::[]
ifeval::[""{context}"" == ""installing-vsphere-installer-provisioned-network-customizations""]
:vsphere:
endif::[]
ifeval::[""{context}"" == ""installing-vmc-customizations""]
:vmc:
endif::[]
ifeval::[""{context}"" == ""installing-vmc-network-customizations""]
:vmc:
endif::[]
ifeval::[""{context}"" == ""installing-restricted-networks-vmc""]
:vmc:
endif::[]
ifeval::[""{context}"" == ""installing-openstack-installer-restricted""]
:osp:
:osp-custom:
endif::[]
ifeval::[""{context}"" == ""installing-restricted-networks-installer-provisioned-vsphere""]
:vsphere:
endif::[]

[id=""installation-configuration-parameters_{context}""]
= Installation configuration parameters

// If install-config.yaml is generated by openshift-install
ifndef::bare[]
Before you deploy an {product-title} cluster, you provide parameter values to describe your account on the cloud platform that hosts your cluster and optionally customize your cluster's platform. When you create the `install-config.yaml` installation configuration file, you provide values for the required parameters through the command line. If you customize your cluster, you can modify the `install-config.yaml` file to provide more details about the platform.
endif::bare[]
// If the user manually creates install-config.yaml
ifdef::bare[]
Before you deploy an {product-title} cluster, you provide a customized `install-config.yaml` installation configuration file that describes the details for your environment.
endif::bare[]

[NOTE]
====
After installation, you cannot modify these parameters in the `install-config.yaml` file.
====

[IMPORTANT]
====
The `openshift-install` command does not validate field names for parameters. If an incorrect name is specified, the related file or object is not created, and no error is reported. Ensure that the field names for any parameters that are specified are correct.
====

[id=""installation-configuration-parameters-required_{context}""]
== Required configuration parameters

Required installation configuration parameters are described in the following table:

.Required parameters
[cols="".^2,.^3,.^5a"",options=""header""]
|====
|Parameter|Description|Values

|`apiVersion`
|The API version for the `install-config.yaml` content. The current version is `v1`. The installer may also support older API versions.
|String

|`baseDomain`
|The base domain of your cloud provider. The base domain is used to create routes to your {product-title} cluster components. The full DNS name for your cluster is a combination of the `baseDomain` and `metadata.name` parameter values that uses the `<metadata.name>.<baseDomain>` format.
|A fully-qualified domain or subdomain name, such as `example.com`.

|`metadata`
|Kubernetes resource `ObjectMeta`, from which only the `name` parameter is consumed.
|Object

|`metadata.name`
|The name of the cluster. DNS records for the cluster are all subdomains of `{{.metadata.name}}.{{.baseDomain}}`.
|String of lowercase letters, hyphens (`-`), and periods (`.`), such as `dev`.
ifdef::osp[]
The string must be 14 characters or fewer long.
endif::osp[]

|`platform`
|The configuration for the specific platform upon which to perform the installation: `aws`, `baremetal`, `azure`, `openstack`, `ovirt`, `vsphere`. For additional information about `platform.<platform>` parameters, consult the table for your specific platform that follows.
|Object

ifndef::openshift-origin[]
|`pullSecret`
|Get a pull secret from link:https://cloud.redhat.com/openshift/install/pull-secret[] to authenticate downloading container images for {product-title} components from services such as Quay.io.
|
[source,json]
----
{
   ""auths"":{
      ""cloud.openshift.com"":{
         ""auth"":""b3Blb="",
         ""email"":""you@example.com""
      },
      ""quay.io"":{
         ""auth"":""b3Blb="",
         ""email"":""you@example.com""
      }
   }
}
----
endif::[]

|====

[id=""installation-configuration-parameters-network_{context}""]
== Network configuration parameters

You can customize your installation configuration based on the requirements of your existing network infrastructure. For example, you can expand the IP address block for the cluster network or provide different IP address blocks than the defaults.

ifndef::bare[]
Only IPv4 addresses are supported.
endif::bare[]
ifdef::bare[]
If you use the OVN-Kubernetes cluster network provider, both IPv4 and IPv6 address families are supported.

If you use the OpenShift SDN cluster network provider, only the IPv4 address family is supported.

If you configure your cluster to use both IP address families, you must specify IPv4 and IPv6 addresses in the same order for all network configuration parameters. For example, in the following configuration IPv4 addresses are listed before IPv6 addresses.

[source,yaml]
----
networking:
  clusterNetwork:
  - cidr: 10.128.0.0/14
    hostPrefix: 23
  - cidr: fd00:10:128::/56
    hostPrefix: 64
  serviceNetwork:
  - 172.30.0.0/16
  - fd00:172:16::/112
----
endif::bare[]

.Network parameters
[cols="".^2,.^3a,.^3a"",options=""header""]
|====
|Parameter|Description|Values

|`networking`
|The configuration for the cluster network.
|Object

[NOTE]
====
You cannot modify parameters specified by the `networking` object after installation.
====

|`networking.networkType`
|The cluster network provider Container Network Interface (CNI) plug-in to install.
|
ifdef::openshift-origin[]
Either `OpenShiftSDN` or `OVNKubernetes`. The default value is `OVNKubernetes`.
endif::openshift-origin[]
ifndef::openshift-origin[]
Either `OpenShiftSDN` or `OVNKubernetes`. The default value is `OpenShiftSDN`.
endif::openshift-origin[]

|`networking.clusterNetwork`
|
The IP address blocks for pods.

The default value is `10.128.0.0/14` with a host prefix of `/23`.

If you specify multiple IP address blocks, the blocks must not overlap.
|An array of objects. For example:

[source,yaml]
----
ifndef::bare[]
networking:
  clusterNetwork:
  - cidr: 10.128.0.0/14
    hostPrefix: 23
endif::bare[]
ifdef::bare[]
networking:
  clusterNetwork:
  - cidr: 10.128.0.0/14
    hostPrefix: 23
  - cidr: fd01::/48
    hostPrefix: 64
endif::bare[]
----

|`networking.clusterNetwork.cidr`
|
Required if you use `networking.clusterNetwork`. An IP address block.

ifndef::bare[]
An IPv4 network.
endif::bare[]
ifdef::bare[]
If you use the OpenShift SDN network provider, specify an IPv4 network. If you use the OVN-Kubernetes network provider, you can specify IPv4 and IPv6 networks.
endif::bare[]
|
An IP address block in Classless Inter-Domain Routing (CIDR) notation.
The prefix length for an IPv4 block is between `0` and `32`.
ifdef::bare[]
The prefix length for an IPv6 block is between `0` and `128`. For example, `10.128.0.0/14` or `fd01::/48`.
endif::bare[]

|`networking.clusterNetwork.hostPrefix`
|The subnet prefix length to assign to each individual node. For example, if `hostPrefix` is set to `23` then each node is assigned a `/23` subnet out of the given `cidr`. A `hostPrefix` value of `23` provides 510 (2^(32 - 23) - 2) pod IP addresses.
|
A subnet prefix.

ifndef::bare[]
The default value is `23`.
endif::bare[]
ifdef::bare[]
For an IPv4 network the default value is `23`.
For an IPv6 network the default value is `64`. The default value is also the minimum value for IPv6.
endif::bare[]

|`networking.serviceNetwork`
|
The IP address block for services. The default value is `172.30.0.0/16`.

The OpenShift SDN and OVN-Kubernetes network providers support only a single IP address block for the service network.

ifdef::bare[]
If you use the OVN-Kubernetes network provider, you can specify an IP address block for both of the IPv4 and IPv6 address families.
endif::bare[]

|
An array with an IP address block in CIDR format. For example:

[source,yaml]
----
ifndef::bare[]
networking:
  serviceNetwork:
   - 172.30.0.0/16
endif::bare[]
ifdef::bare[]
networking:
  serviceNetwork:
   - 172.30.0.0/16
   - fd02::/112
endif::bare[]
----

|`networking.machineNetwork`
|
The IP address blocks for machines.

If you specify multiple IP address blocks, the blocks must not overlap.
|An array of objects. For example:

[source,yaml]
----
networking:
  machineNetwork:
  - cidr: 10.0.0.0/16
----

|`networking.machineNetwork.cidr`
|
Required if you use `networking.machineNetwork`. An IP address block. The default value is `10.0.0.0/16` for all platforms other than libvirt. For libvirt, the default value is `192.168.126.0/24`.
|
An IP network block in CIDR notation.

ifndef::bare[]
For example, `10.0.0.0/16`.
endif::bare[]
ifdef::bare[]
For example, `10.0.0.0/16` or `fd00::/48`.
endif::bare[]

[NOTE]
====
Set the `networking.machineNetwork` to match the CIDR that the preferred NIC resides in.
====

|====

[id=""installation-configuration-parameters-optional_{context}""]
== Optional configuration parameters

Optional installation configuration parameters are described in the following table:

.Optional parameters
[cols="".^2,.^3a,.^3a"",options=""header""]
|====
|Parameter|Description|Values

|`additionalTrustBundle`
|A PEM-encoded X.509 certificate bundle that is added to the nodes' trusted certificate store. This trust bundle may also be used when a proxy has been configured.
|String

|`compute`
|The configuration for the machines that comprise the compute nodes.
|Array of `MachinePool` objects. For details, see the following ""Machine-pool"" table.

|`compute.architecture`
|Determines the instruction set architecture of the machines in the pool. Currently, heteregeneous clusters are not supported, so all pools must specify the same architecture. Valid values are `amd64` (the default).
|String

|`compute.hyperthreading`
|Whether to enable or disable simultaneous multithreading, or `hyperthreading`, on compute machines. By default, simultaneous multithreading is enabled to increase the performance of your machines' cores.
[IMPORTANT]
====
If you disable simultaneous multithreading, ensure that your capacity planning
accounts for the dramatically decreased machine performance.
====
|`Enabled` or `Disabled`

|`compute.name`
|Required if you use `compute`. The name of the machine pool.
|`worker`

|`compute.platform`
|Required if you use `compute`. Use this parameter to specify the cloud provider to host the worker machines. This parameter value must match the `controlPlane.platform` parameter value.
|`aws`, `azure`, `gcp`, `openstack`, `ovirt`, `vsphere`, or `{}`

|`compute.replicas`
|The number of compute machines, which are also known as worker machines, to provision.
|A positive integer greater than or equal to `2`. The default value is `3`.

|`controlPlane`
|The configuration for the machines that comprise the control plane.
|Array of `MachinePool` objects. For details, see the following ""Machine-pool"" table.

|`controlPlane.architecture`
|Determines the instruction set architecture of the machines in the pool. Currently, heterogeneous clusters are not supported, so all pools must specify the same architecture. Valid values are `amd64` (the default).
|String

|`controlPlane.hyperthreading`
|Whether to enable or disable simultaneous multithreading, or `hyperthreading`, on control plane machines. By default, simultaneous multithreading is enabled to increase the performance of your machines' cores.
[IMPORTANT]
====
If you disable simultaneous multithreading, ensure that your capacity planning
accounts for the dramatically decreased machine performance.
====
|`Enabled` or `Disabled`

|`controlPlane.name`
|Required if you use `controlPlane`. The name of the machine pool.
|`master`

|`controlPlane.platform`
|Required if you use `controlPlane`. Use this parameter to specify the cloud provider that hosts the control plane machines. This parameter value must match the `compute.platform` parameter value.
|`aws`, `azure`, `gcp`, `openstack`, `ovirt`, `vsphere`, or `{}`

|`controlPlane.replicas`
|The number of control plane machines to provision.
|The only supported value is `3`, which is the default value.

|`credentialsMode`
|The Cloud Credential Operator (CCO) mode. If no mode is specified, the CCO dynamically tries to determine the capabilities of the provided credentials, with a preference for mint mode on the platforms where multiple modes are supported.
[NOTE]
====
Not all CCO modes are supported for all cloud providers. For more information on CCO modes, see the _Cloud Credential Operator_ entry in the _Red Hat Operators reference_ content.
====
|`Mint`, `Passthrough`, `Manual`, or an empty string (`""""`).
ifndef::openshift-origin[]
|`fips`
|Enable or disable FIPS mode. The default is `false` (disabled). If FIPS mode is enabled, the {op-system-first} machines that {product-title} runs on bypass the default Kubernetes cryptography suite and use the cryptography modules that are provided with {op-system} instead.
[IMPORTANT]
====
The use of FIPS Validated / Modules in Process cryptographic libraries is only supported on {product-title} deployments on the `x86_64` architecture.
====
[NOTE]
====
If you are using Azure File storage, you cannot enable FIPS mode.
====
|`false` or `true`
endif::openshift-origin[]
|`imageContentSources`
|Sources and repositories for the release-image content.
|Array of objects. Includes a `source` and, optionally, `mirrors`, as described in the following rows of this table.

|`imageContentSources.source`
|Required if you use `imageContentSources`. Specify the repository that users refer to, for example, in image pull specifications.
|String

|`imageContentSources.mirrors`
|Specify one or more repositories that may also contain the same images.
|Array of strings

|`publish`
|How to publish or expose the user-facing endpoints of your cluster, such as the Kubernetes API, OpenShift routes.
|
ifdef::aws,azure,gcp[]
`Internal` or `External`. To deploy a private cluster, which cannot be accessed from the internet, set `publish` to `Internal`. The default value is `External`.
endif::[]
ifndef::aws,azure,gcp[]
`Internal` or `External`. The default value is `External`.

Setting this field to `Internal` is not supported on non-cloud platforms.
ifeval::[{product-version} <= 4.7]
[IMPORTANT]
====
If the value of the field is set to `Internal`, the cluster will become non-functional. For more information, refer to link:https://bugzilla.redhat.com/show_bug.cgi?id=1953035[BZ#1953035].
====
endif::[]
endif::[]

|`sshKey`
| The SSH key to authenticate access to your cluster machines.
[NOTE]
====
For production {product-title} clusters on which you want to perform installation debugging or disaster recovery, specify an SSH key that your `ssh-agent` process uses.
====
a|For example, `sshKey: ssh-ed25519 AAAA..`.

|====

ifdef::aws[]
[id=""installation-configuration-parameters-optional-aws_{context}""]
== Optional AWS configuration parameters

Optional AWS configuration parameters are described in the following table:

.Optional AWS parameters
[cols="".^2,.^3,.^5a"",options=""header""]
|====
|Parameter|Description|Values

|`compute.platform.aws.amiID`
|The AWS AMI used to boot compute machines for the cluster. This is required for regions that require a custom {op-system} AMI.
|Any published or custom {op-system} AMI that belongs to the set AWS region.

|`compute.platform.aws.iamRole`
|A pre-existing AWS IAM role applied to the compute machine pool instance profiles. You can use these fields to match naming schemes and include predefined permissions boundaries for your IAM roles. If undefined, the installation program creates a new IAM role.
|The name of a valid AWS IAM role.

|`compute.platform.aws.rootVolume.iops`
|The Input/Output Operations Per Second (IOPS) that is reserved for the root volume.
|Integer, for example `4000`.

|`compute.platform.aws.rootVolume.size`
|The size in GiB of the root volume.
|Integer, for example `500`.

|`compute.platform.aws.rootVolume.type`
|The instance type of the root volume.
|Valid link:https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSVolumeTypes.html[AWS EBS instance type],
such as `io1`.

|`compute.platform.aws.type`
|The EC2 instance type for the compute machines.
|Valid AWS instance type, such as `m4.2xlarge`. See the *Instance types for machines* table that follows.
//add an xref when possible.

|`compute.platform.aws.zones`
|The availability zones where the installation program creates machines for the compute machine pool. If you provide your own VPC, you must provide a subnet in that availability zone.
|A list of valid AWS availability zones, such as `us-east-1c`, in a
link:https://yaml.org/spec/1.2/spec.html#sequence//[YAML sequence].

|`compute.aws.region`
|The AWS region that the installation program creates compute resources in.
|Any valid link:https://docs.aws.amazon.com/general/latest/gr/rande.html[AWS region], such as `us-east-1`.

|`controlPlane.platform.aws.amiID`
|The AWS AMI used to boot control plane machines for the cluster.  This is required for regions that require a custom {op-system} AMI.
|Any published or custom {op-system} AMI that belongs to the set AWS region.

|`controlPlane.platform.aws.iamRole`
|A pre-existing AWS IAM role applied to the control plane machine pool instance profiles. You can use these fields to match naming schemes and include predefined permissions boundaries for your IAM roles. If undefined, the installation program creates a new IAM role.
|The name of a valid AWS IAM role.

|`controlPlane.platform.aws.type`
|The EC2 instance type for the control plane machines.
|Valid AWS instance type, such as `m5.xlarge`. See the *Instance types for machines* table that follows.
//add an xref when possible

|`controlPlane.platform.aws.zones`
|The availability zones where the installation program creates machines for the
control plane machine pool.
|A list of valid AWS availability zones, such as `us-east-1c`, in a link:https://yaml.org/spec/1.2/spec.html#sequence//[YAML sequence].

|`controlPlane.aws.region`
|The AWS region that the installation program creates control plane resources in.
|Valid link:https://docs.aws.amazon.com/general/latest/gr/rande.html[AWS region], such as `us-east-1`.

|`platform.aws.amiID`
|The AWS AMI used to boot all machines for the cluster. If set, the AMI must
belong to the same region as the cluster. This is required for regions that require a custom {op-system} AMI.
|Any published or custom {op-system} AMI that belongs to the set AWS region.

|`platform.aws.hostedZone`
|An existing Route 53 private hosted zone for the cluster. You can only use a pre-existing hosted zone when also supplying your own VPC. The hosted zone must already be associated with the user-provided VPC before installation. Also, the domain of the hosted zone must be the cluster domain or a parent of the cluster domain. If undefined, the installation program creates a new hosted zone.
|String, for example `Z3URY6TWQ91KVV`.

|`platform.aws.serviceEndpoints.name`
|The AWS service endpoint name. Custom endpoints are only required for cases
where alternative AWS endpoints, like FIPS, must be used. Custom API endpoints
can be specified for EC2, S3, IAM, Elastic Load Balancing, Tagging, Route 53,
and STS AWS services.
|Valid link:https://docs.aws.amazon.com/general/latest/gr/rande.html[AWS service endpoint] name.

|`platform.aws.serviceEndpoints.url`
|The AWS service endpoint URL. The URL must use the `https` protocol and the
host must trust the certificate.
|Valid link:https://docs.aws.amazon.com/general/latest/gr/rande.html[AWS service endpoint] URL.

|`platform.aws.userTags`
|A map of keys and values that the installation program adds as tags to all resources that it creates.
|Any valid YAML map, such as key value pairs in the `<key>: <value>` format. For more information about AWS tags, see link:https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/Using_Tags.html[Tagging Your Amazon EC2 Resources] in the AWS documentation.

|`platform.aws.subnets`
|If you provide the VPC instead of allowing the installation program to create the VPC for you, specify the subnet for the cluster to use. The subnet must be part of the same `machineNetwork[].cidr` ranges that you specify. For a standard cluster, specify a public and a private subnet for each availability zone. For a private cluster, specify a private subnet for each availability zone.
|Valid subnet IDs.

|====
endif::aws[]

ifdef::osp[]
[id=""installation-configuration-parameters-additional-osp_{context}""]
== Additional {rh-openstack-first} configuration parameters

Additional {rh-openstack} configuration parameters are described in the following table:

.Additional {rh-openstack} parameters
[cols="".^2m,.^3a,^5a"",options=""header""]
|====
|Parameter|Description|Values

|`compute.platform.openstack.rootVolume.size`
|For compute machines, the size in gigabytes of the root volume. If you do not set this value, machines use ephemeral storage.
|Integer, for example `30`.

|`compute.platform.openstack.rootVolume.type`
|For compute machines, the root volume's type.
|String, for example `performance`.

|`controlPlane.platform.openstack.rootVolume.size`
|For control plane machines, the size in gigabytes of the root volume. If you do not set this value, machines use ephemeral storage.
|Integer, for example `30`.

|`controlPlane.platform.openstack.rootVolume.type`
|For control plane machines, the root volume's type.
|String, for example `performance`.

|`platform.openstack.cloud`
|The name of the {rh-openstack} cloud to use from the list of clouds in the
`clouds.yaml` file.
|String, for example `MyCloud`.

|`platform.openstack.externalNetwork`
|The {rh-openstack} external network name to be used for installation.
|String, for example `external`.

|`platform.openstack.computeFlavor`
|The {rh-openstack} flavor to use for control plane and compute machines.

This property is deprecated. To use a flavor as the default for all machine pools, add it as the value of the `type` key in the `platform.openstack.defaultMachinePlatform` property. You can also set a flavor value for each machine pool individually.

|String, for example `m1.xlarge`.
|====

[id=""installation-configuration-parameters-optional-osp_{context}""]
== Optional {rh-openstack} configuration parameters

Optional {rh-openstack} configuration parameters are described in the following table:

.Optional {rh-openstack} parameters
[%header, cols="".^2,.^3,.^5a""]
|====
|Parameter|Description|Values

|`compute.platform.openstack.additionalNetworkIDs`
|Additional networks that are associated with compute machines. Allowed address pairs are not created for additional networks.
|A list of one or more UUIDs as strings. For example, `fa806b2f-ac49-4bce-b9db-124bc64209bf`.

|`compute.platform.openstack.additionalSecurityGroupIDs`
|Additional security groups that are associated with compute machines.
|A list of one or more UUIDs as strings. For example, `7ee219f3-d2e9-48a1-96c2-e7429f1b0da7`.

|`compute.platform.openstack.zones`
|{rh-openstack} Compute (Nova) availability zones (AZs) to install machines on. If this parameter is not set, the installer relies on the default settings for Nova that the {rh-openstack} administrator configured.

On clusters that use Kuryr, {rh-openstack} Octavia does not support availability zones. Load balancers and, if you are using the Amphora provider driver, {product-title} services that rely on Amphora VMs, are not created according to the value of this property.
|A list of strings. For example, `[""zone-1"", ""zone-2""]`.

|`controlPlane.platform.openstack.additionalNetworkIDs`
|Additional networks that are associated with control plane machines. Allowed address pairs are not created for additional networks.
|A list of one or more UUIDs as strings. For example, `fa806b2f-ac49-4bce-b9db-124bc64209bf`.

|`controlPlane.platform.openstack.additionalSecurityGroupIDs`
|Additional security groups that are associated with control plane machines.
|A list of one or more UUIDs as strings. For example, `7ee219f3-d2e9-48a1-96c2-e7429f1b0da7`.

|`controlPlane.platform.openstack.zones`
|{rh-openstack} Compute (Nova) availability zones (AZs) to install machines on. If this parameter is not set, the installer relies on the default settings for Nova that the {rh-openstack} administrator configured.

On clusters that use Kuryr, {rh-openstack} Octavia does not support availability zones. Load balancers and, if you are using the Amphora provider driver, {product-title} services that rely on Amphora VMs, are not created according to the value of this property.
|A list of strings. For example, `[""zone-1"", ""zone-2""]`.

|`platform.openstack.clusterOSImage`
|The location from which the installer downloads the {op-system} image.

You must set this parameter to perform an installation in a restricted network.
|An HTTP or HTTPS URL, optionally with an SHA-256 checksum.

For example, `\\http://mirror.example.com/images/rhcos-43.81.201912131630.0-openstack.x86_64.qcow2.gz?sha256=ffebbd68e8a1f2a245ca19522c16c86f67f9ac8e4e0c1f0a812b068b16f7265d`.
The value can also be the name of an existing Glance image, for example `my-rhcos`.

|`platform.openstack.clusterOSImageProperties`
|Properties to add to the installer-uploaded ClusterOSImage in Glance. This property is ignored if `platform.openstack.clusterOSImage` is set to an existing Glance image.

You can use this property to exceed the default persistent volume (PV) limit for {rh-openstack} of 26 PVs per node. To exceed the limit, set the `hw_scsi_model` property value to `virtio-scsi` and the `hw_disk_bus` value to  `scsi`.

You can also use this property to enable the QEMU guest agent by including the `hw_qemu_guest_agent` property with a value of `yes`.
|A list of key-value string pairs. For example, `[""hw_scsi_model"": ""virtio-scsi"", ""hw_disk_bus"": ""scsi""]`.

|`platform.openstack.defaultMachinePlatform`
|The default machine pool platform configuration.
|
[source,json]
----
{
   ""type"": ""ml.large"",
   ""rootVolume"": {
      ""size"": 30,
      ""type"": ""performance""
   }
}
----

|`platform.openstack.ingressFloatingIP`
|An existing floating IP address to associate with the Ingress port. To use this property, you must also define the `platform.openstack.externalNetwork` property.
|An IP address, for example `128.0.0.1`.

|`platform.openstack.apiFloatingIP`
|An existing floating IP address to associate with the API load balancer. To use this property, you must also define the `platform.openstack.externalNetwork` property.
|An IP address, for example `128.0.0.1`.

|`platform.openstack.externalDNS`
|IP addresses for external DNS servers that cluster instances use for DNS resolution.
|A list of IP addresses as strings. For example, `[""8.8.8.8"", ""192.168.1.12""]`.

|`platform.openstack.machinesSubnet`
|The UUID of a {rh-openstack} subnet that the cluster's nodes use. Nodes and virtual IP (VIP) ports are created on this subnet.

The first item in `networking.machineNetwork` must match the value of `machinesSubnet`.

If you deploy to a custom subnet, you cannot specify an external DNS server to the {product-title} installer. Instead, link:https://access.redhat.com/documentation/en-us/red_hat_openstack_platform/16.0/html/command_line_interface_reference/subnet[add DNS to the subnet in {rh-openstack}].

|A UUID as a string. For example, `fa806b2f-ac49-4bce-b9db-124bc64209bf`.
|====
endif::osp[]

ifdef::azure[]
[id=""installation-configuration-parameters-additional-azure_{context}""]
== Additional Azure configuration parameters

Additional Azure configuration parameters are described in the following table:

.Additional Azure parameters
[cols="".^2,.^3a,.^3a"",options=""header""]
|====
|Parameter|Description|Values

|`controlPlane.platform.azure.osDisk.diskSizeGB`
|The Azure disk size for the VM.
|Integer that represents the size of the disk in GB. The minimum supported disk size is `1024`.

|`platform.azure.baseDomainResourceGroupName`
|The name of the resource group that contains the DNS zone for your base domain.
|String, for example `production_cluster`.

|`platform.azure.resourceGroupName`
| The name of an already existing resource group to install your cluster to. This resource group must be empty and only used for this specific cluster; the cluster components assume ownership of all resources in the resource group. If you limit the service principal scope of the installation program to this resource group, you must ensure all other resources used by the installation program in your environment have the necessary permissions, such as the public DNS zone and virtual network. Destroying the cluster using the installation program deletes this resource group.
|String, for example `existing_resource_group`.

|`platform.azure.outboundType`
|The outbound routing strategy used to connect your cluster to the internet. If
you are using user-defined routing, you must have pre-existing networking
available where the outbound routing has already been configured prior to
installing a cluster. The installation program is not responsible for
configuring user-defined routing.
|`LoadBalancer` or `UserDefinedRouting`. The default is `LoadBalancer`.

|`platform.azure.region`
|The name of the Azure region that hosts your cluster.
|Any valid region name, such as `centralus`.

|`platform.azure.zone`
|List of availability zones to place machines in. For high availability, specify
at least two zones.
|List of zones, for example `[""1"", ""2"", ""3""]`.

|`platform.azure.networkResourceGroupName`
|The name of the resource group that contains the existing VNet that you want to deploy your cluster to. This name cannot be the same as the `platform.azure.baseDomainResourceGroupName`.
|String.

|`platform.azure.virtualNetwork`
|The name of the existing VNet that you want to deploy your cluster to.
|String.

|`platform.azure.controlPlaneSubnet`
|The name of the existing subnet in your VNet that you want to deploy your control plane machines to.
|Valid CIDR, for example `10.0.0.0/16`.

|`platform.azure.computeSubnet`
|The name of the existing subnet in your VNet that you want to deploy your compute machines to.
|Valid CIDR, for example `10.0.0.0/16`.

|`platform.azure.cloudName`
|The name of the Azure cloud environment that is used to configure the Azure SDK with the appropriate Azure API endpoints. If empty, the default value `AzurePublicCloud` is used.
|Any valid cloud environment, such as `AzurePublicCloud` or `AzureUSGovernmentCloud`.

|====

[NOTE]
====
You cannot customize
link:https://azure.microsoft.com/en-us/global-infrastructure/availability-zones/[Azure Availability Zones]
or
link:https://docs.microsoft.com/en-us/azure/azure-resource-manager/resource-group-using-tags[Use tags to organize your Azure resources]
with an Azure cluster.
====
endif::azure[]

ifdef::gcp[]
[id=""installation-configuration-parameters-additional-gcp_{context}""]
== Additional Google Cloud Platform (GCP) configuration parameters

Additional GCP configuration parameters are described in the following table:

.Additional GCP parameters
[cols="".^2,.^3a,.^3a"",options=""header""]
|====
|Parameter|Description|Values

|`platform.gcp.network`
|The name of the existing VPC that you want to deploy your cluster to.
|String.

|`platform.gcp.type`
|The link:https://cloud.google.com/compute/docs/machine-types[GCP machine type].
|The GCP machine type.

|`platform.gcp.zones`
|The availability zones where the installation program creates machines for the specified MachinePool.
|A list of valid link:https://cloud.google.com/compute/docs/regions-zones#available[GCP availability zones], such as `us-central1-a`, in a
link:https://yaml.org/spec/1.2/spec.html#sequence//[YAML sequence].

|`platform.gcp.controlPlaneSubnet`
|The name of the existing subnet in your VPC that you want to deploy your control plane machines to.
|The subnet name.

|`platform.gcp.computeSubnet`
|The name of the existing subnet in your VPC that you want to deploy your compute machines to.
|The subnet name.

|`controlPlane.platform.gcp.osDisk.encryptionKey.kmsKey.name`
|The name of the customer managed encryption key to be used for control plane machine disk encryption.
|The encryption key name.

|`controlPlane.platform.gcp.osDisk.encryptionKey.kmsKey.keyRing`
|For control plane machines, the name of the KMS key ring to which the KMS key belongs.
|The KMS key ring name.

|`controlPlane.platform.gcp.osDisk.encryptionKey.kmsKey.location`
|For control plane machines, the GCP location in which the key ring exists. For more information on KMS locations, see Google's documentation on link:https://cloud.google.com/kms/docs/locations[Cloud KMS locations].
|The GCP location for the key ring.

|`controlPlane.platform.gcp.osDisk.encryptionKey.kmsKey.projectID`
|For control plane machines, the ID of the project in which the KMS key ring exists. This value defaults to the VM project ID if not set.
|The GCP project ID.

////
`controlPlane.platform.gcp.osDisk.encryptionKey.kmsKeyServiceAccount`

The GCP Compute Engine System service account used for the encryption request for the given KMS key. The Compute Engine default service account is always used for control plane machines during installation, which follows this pattern: `service-<project_number>@compute-system.iam.gserviceaccount.com`. The default service account must have access to the KMS key specified for the control plane machines. The custom service account defined is available for use during post-installation operations. For more information on GCP service accounts, see Google's documentation on link:https://cloud.google.com/iam/docs/service-accounts#types[Types of service accounts].

The GCP Compute Engine System service account email, like `<service_account_name>@<project_id>.iam.gserviceaccount.com`.
////
// kmsKeyServiceAccount not yet fully supported in 4.7. Re-add when more stable.

|`compute.platform.gcp.osDisk.encryptionKey.kmsKey.name`
|The name of the customer managed encryption key to be used for compute machine disk encryption.
|The encryption key name.

|`compute.platform.gcp.osDisk.encryptionKey.kmsKey.keyRing`
|For compute machines, the name of the KMS key ring to which the KMS key belongs.
|The KMS key ring name.

|`compute.platform.gcp.osDisk.encryptionKey.kmsKey.location`
|For compute machines, the GCP location in which the key ring exists. For more information on KMS locations, see Google's documentation on link:https://cloud.google.com/kms/docs/locations[Cloud KMS locations].
|The GCP location for the key ring.

|`compute.platform.gcp.osDisk.encryptionKey.kmsKey.projectID`
|For compute machines, the ID of the project in which the KMS key ring exists. This value defaults to the VM project ID if not set.
|The GCP project ID.

////
`compute.platform.gcp.osDisk.encryptionKey.kmsKeyServiceAccount`

For compute machines, the GCP Compute Engine System service account used for the encryption request for the given KMS key. If left undefined, the Compute Engine default service account is used, which follows this pattern: `service-<project_number>@compute-system.iam.gserviceaccount.com`. For more information on GCP service accounts, see Google's documentation on link:https://cloud.google.com/iam/docs/service-accounts#types[Types of service accounts].

The GCP Compute Engine System service account email, like `<service_account_name>@<project_id>.iam.gserviceaccount.com`.
////
// kmsKeyServiceAccount not yet fully supported in 4.7. Re-add when more stable.
|====

endif::gcp[]

ifdef::rhv[]
[id=""installation-configuration-parameters-additional-rhv_{context}""]
== Additional {rh-virtualization-first} configuration parameters

Additional {rh-virtualization} configuration parameters are described in the following table:

.Additional {rh-virtualization} parameters for clusters
[cols="".^2,.^3a,.^3a"",options=""header""]
|====
|Parameter|Description|Values

|`platform.ovirt.ovirt_cluster_id`
|Required. The Cluster where the VMs will be created.
|String. For example: `68833f9f-e89c-4891-b768-e2ba0815b76b`

|`platform.ovirt.ovirt_storage_domain_id`
|Required. The Storage Domain ID where the VM disks will be created.
|String. For example: `ed7b0f4e-0e96-492a-8fff-279213ee1468`

|`platform.ovirt.ovirt_network_name`
|Required. The network name where the VM nics will be created.
|String. For example: `ocpcluster`

|`platform.ovirt.vnicProfileID`
|Required. The vNIC profile ID of the VM network interfaces. This can be inferred if the cluster network has a single profile.
|String. For example: `3fa86930-0be5-4052-b667-b79f0a729692`

|`platform.ovirt.api_vip`
|Required. An IP address on the machine network that will be assigned to the API virtual IP (VIP). You can access the OpenShift API at this endpoint.
|String. Example: `10.46.8.230`

|`platform.ovirt.ingress_vip`
|Required. An IP address on the machine network that will be assigned to the Ingress virtual IP (VIP).
|String. Example: `10.46.8.232`
|====

[id=""installation-configuration-parameters-additional-machine_{context}""]
== Additional {rh-virtualization} parameters for machine pools

Additional {rh-virtualization} configuration parameters for machine pools are described in the following table:

.Additional {rh-virtualization} parameters for machine pools
[cols="".^2,.^3a,.^3a"",options=""header""]
|====
|Parameter|Description|Values

|`<machine-pool>.platform.ovirt.cpu`
|Optional. Defines the CPU of the VM.
|Object

|`<machine-pool>.platform.ovirt.cpu.cores`
|Required if you use `<machine-pool>.platform.ovirt.cpu`. The number of cores. Total virtual CPUs (vCPUs) is cores * sockets.
|Integer

|`<machine-pool>.platform.ovirt.cpu.sockets`
|Required if you use `<machine-pool>.platform.ovirt.cpu`. The number of sockets per core. Total virtual CPUs (vCPUs) is cores * sockets.
|Integer

|`<machine-pool>.platform.ovirt.memoryMB`
|Optional. Memory of the VM in MiB.
|Integer

|`<machine-pool>.platform.ovirt.instanceTypeID`
|Optional. An instance type UUID, such as `00000009-0009-0009-0009-0000000000f1`, which you can get from the `https://<engine-fqdn>/ovirt-engine/api/instancetypes` endpoint.
|String of UUID

|`<machine-pool>.platform.ovirt.osDisk`
|Optional. Defines the first and bootable disk of the VM.
|String

|`<machine-pool>.platform.ovirt.osDisk.sizeGB`
|Required if you use `<machine-pool>.platform.ovirt.osDisk`. Size of the disk in GiB.
|Number

|`<machine-pool>.platform.ovirt.vmType`
|Optional. The VM workload type, such as `high-performance`, `server`, or `desktop`.
|String
|====

[NOTE]
====
You can replace `<machine-pool>` with `controlPlane` or `compute`.
====

endif::rhv[]

ifdef::vsphere,vmc[]
[id=""installation-configuration-parameters-additional-vsphere_{context}""]
== Additional VMware vSphere configuration parameters

Additional VMware vSphere configuration parameters are described in the following table:

.Additional VMware vSphere cluster parameters
[cols="".^2,.^3a,.^3a"",options=""header""]
|====
|Parameter|Description|Values

|`platform.vsphere.vCenter`
|The fully-qualified hostname or IP address of the vCenter server.
|String

|`platform.vsphere.username`
|The user name to use to connect to the vCenter instance with. This user must have at least
the roles and privileges that are required for
link:https://vmware.github.io/vsphere-storage-for-kubernetes/documentation/vcp-roles.html[static or dynamic persistent volume provisioning]
in vSphere.
|String

|`platform.vsphere.password`
|The password for the vCenter user name.
|String

|`platform.vsphere.datacenter`
|The name of the datacenter to use in the vCenter instance.
|String

|`platform.vsphere.defaultDatastore`
|The name of the default datastore to use for provisioning volumes.
|String

|`platform.vsphere.folder`
|_Optional_. The absolute path of an existing folder where the installation program creates the virtual machines. If you do not provide this value, the installation program creates a folder that is named with the infrastructure ID in the datacenter virtual machine folder.
|String, for example, `/<datacenter_name>/vm/<folder_name>/<subfolder_name>`.

|`platform.vsphere.network`
|The network in the vCenter instance that contains the virtual IP addresses and DNS records that you configured.
|String

|`platform.vsphere.cluster`
|The vCenter cluster to install the {product-title} cluster in.
|String

|`platform.vsphere.apiVIP`
|The virtual IP (VIP) address that you configured for control plane API access.
|An IP address, for example `128.0.0.1`.

|`platform.vsphere.ingressVIP`
|The virtual IP (VIP) address that you configured for cluster ingress.
|An IP address, for example `128.0.0.1`.
|====

[id=""installation-configuration-parameters-optional-vsphere_{context}""]
== Optional VMware vSphere machine pool configuration parameters

Optional VMware vSphere machine pool configuration parameters are described in the following table:

.Optional VMware vSphere machine pool parameters
[cols="".^2,.^3a,.^3a"",options=""header""]
|====
|Parameter|Description|Values

|`platform.vsphere.clusterOSImage`
|The location from which the installer downloads the {op-system} image. You must set this parameter to perform an installation in a restricted network.
|An HTTP or HTTPS URL, optionally with a SHA-256 checksum. For example, `\\https://mirror.openshift.com/images/rhcos-<version>-vmware.<architecture>.ova`.

|`platform.vsphere.osDisk.diskSizeGB`
|The size of the disk in gigabytes.
|Integer

|`platform.vsphere.cpus`
|The total number of virtual processor cores to assign a virtual machine.
|Integer

|`platform.vsphere.coresPerSocket`
|The number of cores per socket in a virtual machine. The number of virtual CPUs (vCPUs) on the virtual machine is `platform.vsphere.cpus`/`platform.vsphere.coresPerSocket`. The default value is `1`
|Integer

|`platform.vsphere.memoryMB`
|The size of a virtual machine's memory in megabytes.
|Integer
|====

endif::vsphere,vmc[]

ifdef::bare[]
:!bare:
endif::bare[]
ifeval::[""{context}"" == ""installing-aws-customizations""]
:!aws:
endif::[]
ifeval::[""{context}"" == ""installing-aws-government-region""]
:!aws:
endif::[]
ifeval::[""{context}"" == ""installing-aws-network-customizations""]
:!aws:
endif::[]
ifeval::[""{context}"" == ""installing-aws-private""]
:!aws:
endif::[]
ifeval::[""{context}"" == ""installing-aws-vpc""]
:!aws:
endif::[]
ifeval::[""{context}"" == ""installing-restricted-networks-aws-installer-provisioned""]
:!aws:
endif::[]
ifeval::[""{context}"" == ""installing-azure-customizations""]
:!azure:
endif::[]
ifeval::[""{context}"" == ""installing-azure-government-region""]
:!azure:
endif::[]
ifeval::[""{context}"" == ""installing-azure-network-customizations""]
:!azure:
endif::[]
ifeval::[""{context}"" == ""installing-azure-private""]
:!azure:
endif::[]
ifeval::[""{context}"" == ""installing-azure-vnet""]
:!azure:
endif::[]
ifeval::[""{context}"" == ""installing-gcp-customizations""]
:!gcp:
endif::[]
ifeval::[""{context}"" == ""installing-gcp-private""]
:!gcp:
endif::[]
ifeval::[""{context}"" == ""installing-gcp-network-customizations""]
:!gcp:
endif::[]
ifeval::[""{context}"" == ""installing-gcp-vpc""]
:!gcp:
endif::[]
ifeval::[""{context}"" == ""installing-restricted-networks-gcp-installer-provisioned""]
:!gcp:
endif::[]
ifeval::[""{context}"" == ""installing-aws-customizations""]
:!aws:
endif::[]
ifeval::[""{context}"" == ""installing-openstack-installer-custom""]
:!osp:
:!osp-custom:
endif::[]
ifeval::[""{context}"" == ""installing-openstack-installer-kuryr""]
:!osp:
:!osp-kuryr:
endif::[]
ifeval::[""{context}"" == ""installing-openstack-user""]
:!osp:
:!osp-custom:
endif::[]
ifeval::[""{context}"" == ""installing-openstack-user-kuryr""]
:!osp:
:!osp-kuryr:
endif::[]
ifeval::[""{context}"" == ""installing-openstack-user-sr-iov""]
:!osp:
:!osp-custom:
endif::[]
ifeval::[""{context}"" == ""installing-openstack-user-sr-iov-kuryr""]
:!osp:
:!osp-kuryr:
endif::[]
ifeval::[""{context}"" == ""installing-rhv-customizations""]
:!rhv:
endif::[]
ifeval::[""{context}"" == ""installing-vsphere-installer-provisioned-customizations""]
:!vsphere:
endif::[]
ifeval::[""{context}"" == ""installing-vsphere-installer-provisioned-network-customizations""]
:!vsphere:
endif::[]
ifeval::[""{context}"" == ""installing-vmc-customizations""]
:!vmc:
endif::[]
ifeval::[""{context}"" == ""installing-vmc-network-customizations""]
:!vmc:
endif::[]
ifeval::[""{context}"" == ""installing-restricted-networks-vmc""]
:!vmc:
endif::[]
ifeval::[""{context}"" == ""installing-openstack-installer-restricted""]
:!osp:
:!osp-custom:
endif::[]
ifeval::[""{context}"" == ""installing-restricted-networks-installer-provisioned-vsphere""]
:!vsphere:
endif::[]
",12350,False,2274.334305176535,median
":spring-data-commons-ref: https://docs.spring.io/spring-data/data-commons/docs/current/reference/html

== Spring Data Cloud Spanner

https://projects.spring.io/spring-data/[Spring Data] is an abstraction for storing and retrieving POJOs in numerous storage technologies.
Spring Cloud GCP adds Spring Data support for https://cloud.google.com/spanner/[Google Cloud Spanner].

Maven coordinates for this module only, using <<getting-started.adoc#_bill_of_materials, Spring Cloud GCP BOM>>:

[source,xml]
----
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-gcp-data-spanner</artifactId>
</dependency>
----

Gradle coordinates:

[source]
----
dependencies {
    implementation(""org.springframework.cloud:spring-cloud-gcp-data-spanner"")
}
----

We provide a link:../spring-cloud-gcp-starters/spring-cloud-gcp-starter-data-spanner[Spring Boot Starter for Spring Data Spanner], with which you can leverage our recommended auto-configuration setup.
To use the starter, see the coordinates see below.


Maven:

[source,xml]
----
<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-gcp-starter-data-spanner</artifactId>
</dependency>
----

Gradle:

[source,subs=""normal""]
----
dependencies {
    implementation(""org.springframework.cloud:spring-cloud-gcp-starter-data-spanner"")
}
----

This setup takes care of bringing in the latest compatible version of Cloud Java Cloud Spanner libraries as well.

=== Configuration

To setup Spring Data Cloud Spanner, you have to configure the following:

* Setup the connection details to Google Cloud Spanner.
* Enable Spring Data Repositories (optional).

==== Cloud Spanner settings

You can the use link:../spring-cloud-gcp-starters/spring-cloud-gcp-starter-data-spanner[Spring Boot Starter for Spring Data Spanner] to autoconfigure Google Cloud Spanner in your Spring application.
It contains all the necessary setup that makes it easy to authenticate with your Google Cloud project.
The following configuration options are available:

|===
| Name | Description | Required | Default value
| `spring.cloud.gcp.spanner.instance-id` | Cloud Spanner instance to use | Yes |
| `spring.cloud.gcp.spanner.database` |
Cloud Spanner database to use | Yes |
| `spring.cloud.gcp.spanner.project-id` | GCP project ID where the Google Cloud Spanner API is hosted, if different from the one in the <<spring-cloud-gcp-core,Spring Cloud GCP Core Module>>
| No |
| `spring.cloud.gcp.spanner.credentials.location` | OAuth2 credentials for authenticating with the
Google Cloud Spanner API, if different from the ones in the
<<spring-cloud-gcp-core,Spring Cloud GCP Core Module>> | No |
| `spring.cloud.gcp.spanner.credentials.encoded-key` | Base64-encoded OAuth2 credentials for authenticating with the
Google Cloud Spanner API, if different from the ones in the
<<spring-cloud-gcp-core,Spring Cloud GCP Core Module>> | No |
| `spring.cloud.gcp.spanner.credentials.scopes` |
https://developers.google.com/identity/protocols/googlescopes[OAuth2 scope] for Spring Cloud GCP
Cloud Spanner credentials | No | https://www.googleapis.com/auth/spanner.data
| `spring.cloud.gcp.spanner.createInterleavedTableDdlOnDeleteCascade` | If `true`, then schema statements generated by `SpannerSchemaUtils` for tables with interleaved parent-child relationships will be ""ON DELETE CASCADE"".
The schema for the tables will be ""ON DELETE NO ACTION"" if `false`. | No | `true`
| `spring.cloud.gcp.spanner.numRpcChannels` | Number of gRPC channels used to connect to Cloud Spanner | No | 4 - Determined by Cloud Spanner client library
| `spring.cloud.gcp.spanner.prefetchChunks` | Number of chunks prefetched by Cloud Spanner for read and query | No | 4 - Determined by Cloud Spanner client library
| `spring.cloud.gcp.spanner.minSessions` | Minimum number of sessions maintained in the session pool | No | 0 - Determined by Cloud Spanner client library
| `spring.cloud.gcp.spanner.maxSessions` | Maximum number of sessions session pool can have | No | 400 - Determined by Cloud Spanner client library
| `spring.cloud.gcp.spanner.maxIdleSessions` | Maximum number of idle sessions session pool will maintain | No | 0 - Determined by Cloud Spanner client library
| `spring.cloud.gcp.spanner.writeSessionsFraction` | Fraction of sessions to be kept prepared for write transactions | No | 0.2 - Determined by Cloud Spanner client library
| `spring.cloud.gcp.spanner.keepAliveIntervalMinutes` | How long to keep idle sessions alive | No | 30 - Determined by Cloud Spanner client library
| `spring.cloud.gcp.spanner.failIfPoolExhausted` |  If all sessions are in use, fail the request by throwing an exception. Otherwise, by default, block until a session becomes available. | No | `false`
| `spring.cloud.gcp.spanner.emulator.enabled` |  Enables the usage of an emulator. If this is set to true, then you should set the `spring.cloud.gcp.spanner.emulator-host` to the host:port of your locally running emulator instance. | No | `false`
| `spring.cloud.gcp.spanner.emulator-host` |  The host and port of the Spanner emulator; can be overridden to specify connecting to an already-running https://cloud.google.com/spanner/docs/emulator#installing_and_running_the_emulator[Spanner emulator] instance. | No | `localhost:9010`
|===

==== Repository settings

Spring Data Repositories can be configured via the `@EnableSpannerRepositories` annotation on your main `@Configuration` class.
With our Spring Boot Starter for Spring Data Cloud Spanner, `@EnableSpannerRepositories` is automatically added.
It is not required to add it to any other class, unless there is a need to override finer grain configuration parameters provided by https://github.com/spring-cloud/spring-cloud-gcp/blob/master/spring-cloud-gcp-data-spanner/src/main/java/org/springframework/cloud/gcp/data/spanner/repository/config/EnableSpannerRepositories.java[`@EnableSpannerRepositories`].

==== Autoconfiguration

Our Spring Boot autoconfiguration creates the following beans available in the Spring application context:

- an instance of `SpannerTemplate`
- an instance of `SpannerDatabaseAdminTemplate` for generating table schemas from object hierarchies and creating and deleting tables and databases
- an instance of all user-defined repositories extending `SpannerRepository`, `CrudRepository`, `PagingAndSortingRepository`, when repositories are enabled
- an instance of `DatabaseClient` from the Google Cloud Java Client for Spanner, for convenience and lower level API access


=== Object Mapping

Spring Data Cloud Spanner allows you to map domain POJOs to Cloud Spanner tables via annotations:

[source,java]
----
@Table(name = ""traders"")
public class Trader {

	@PrimaryKey
	@Column(name = ""trader_id"")
	String traderId;

	String firstName;

	String lastName;

	@NotMapped
	Double temporaryNumber;
}
----

Spring Data Cloud Spanner will ignore any property annotated with `@NotMapped`.
These properties will not be written to or read from Spanner.

==== Constructors

Simple constructors are supported on POJOs.
The constructor arguments can be a subset of the persistent properties.
Every constructor argument needs to have the same name and type as a persistent property on the entity and the constructor should set the property from the given argument.
Arguments that are not directly set to properties are not supported.

[source,java]
----
@Table(name = ""traders"")
public class Trader {
	@PrimaryKey
	@Column(name = ""trader_id"")
	String traderId;

	String firstName;

	String lastName;

	@NotMapped
	Double temporaryNumber;

	public Trader(String traderId, String firstName) {
	    this.traderId = traderId;
	    this.firstName = firstName;
	}
}
----


==== Table

The `@Table` annotation can provide the name of the Cloud Spanner table that stores instances of the annotated class, one per row.
This annotation is optional, and if not given, the name of the table is inferred from the class name with the first character uncapitalized.

===== SpEL expressions for table names

In some cases, you might want the `@Table` table name to be determined dynamically.
To do that, you can use https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#expressions[Spring Expression Language].

For example:

[source, java]
----

@Table(name = ""trades_#{tableNameSuffix}"")
public class Trade {
	// ...
}
----

The table name will be resolved only if the `tableNameSuffix` value/bean in the Spring application context is defined.
For example, if `tableNameSuffix` has the value ""123"", the table name will resolve to `trades_123`.

==== Primary Keys

For a simple table, you may only have a primary key consisting of a single column.
Even in that case, the `@PrimaryKey` annotation is required.
`@PrimaryKey` identifies the one or more ID properties corresponding to the primary key.

Spanner has first class support for composite primary keys of multiple columns.
You have to annotate all of your POJO's fields that the primary key consists of with `@PrimaryKey` as below:

[source,java]
----
@Table(name = ""trades"")
public class Trade {
	@PrimaryKey(keyOrder = 2)
	@Column(name = ""trade_id"")
	private String tradeId;

	@PrimaryKey(keyOrder = 1)
	@Column(name = ""trader_id"")
	private String traderId;

	private String action;

	private BigDecimal price;

	private Double shares;

	private String symbol;
}
----

The `keyOrder` parameter of `@PrimaryKey` identifies the properties corresponding to the primary key columns in order, starting with 1 and increasing consecutively.
Order is important and must reflect the order defined in the Cloud Spanner schema.
In our example the DDL to create the table and its primary key is as follows:

[source,sql]
----
CREATE TABLE trades (
    trader_id STRING(MAX),
    trade_id STRING(MAX),
    action STRING(15),
    symbol STRING(10),
    price NUMERIC,
    shares FLOAT64
) PRIMARY KEY (trader_id, trade_id)
----

Spanner does not have automatic ID generation.
For most use-cases, sequential IDs should be used with caution to avoid creating data hotspots in the system.
Read https://cloud.google.com/spanner/docs/schema-and-data-model#primary_keys[Spanner Primary Keys documentation] for a better understanding of primary keys and recommended practices.


==== Columns

All accessible properties on POJOs are automatically recognized as a Cloud Spanner column.
Column naming is generated by the `PropertyNameFieldNamingStrategy` by default defined on the `SpannerMappingContext` bean.
The `@Column` annotation optionally provides a different column name than that of the property and some other settings:

- `name` is the optional name of the column
- `spannerTypeMaxLength` specifies for `STRING` and `BYTES` columns the maximum length.
This setting is only used when generating DDL schema statements based on domain types.
- `nullable` specifies if the column is created as `NOT NULL`.
This setting is only used when generating DDL schema statements based on domain types.
- `spannerType` is the Cloud Spanner column type you can optionally specify.
If this is not specified then a compatible column type is inferred from the Java property type.
- `spannerCommitTimestamp` is a boolean specifying if this property corresponds to an auto-populated commit timestamp column.
Any value set in this property will be ignored when writing to Cloud Spanner.


==== Embedded Objects

If an object of type `B` is embedded as a property of `A`, then the columns of `B` will be saved in the same Cloud Spanner table as those of `A`.

If `B` has primary key columns, those columns will be included in the primary key of `A`. `B` can also have embedded properties.
Embedding allows reuse of columns between multiple entities, and can be useful for implementing parent-child situations, because Cloud Spanner requires child tables to include the key columns of their parents.

For example:

[source,java]
----
class X {
  @PrimaryKey
  String grandParentId;

  long age;
}

class A {
  @PrimaryKey
  @Embedded
  X grandParent;

  @PrimaryKey(keyOrder = 2)
  String parentId;

  String value;
}

@Table(name = ""items"")
class B {
  @PrimaryKey
  @Embedded
  A parent;

  @PrimaryKey(keyOrder = 2)
  String id;

  @Column(name = ""child_value"")
  String value;
}
----

Entities of `B` can be stored in a table defined as:

[source,sql]
----
CREATE TABLE items (
    grandParentId STRING(MAX),
    parentId STRING(MAX),
    id STRING(MAX),
    value STRING(MAX),
    child_value STRING(MAX),
    age INT64
) PRIMARY KEY (grandParentId, parentId, id)
----

Note that embedded properties' column names must all be unique.


==== Relationships

Spring Data Cloud Spanner supports parent-child relationships using the Cloud Spanner https://cloud.google.com/spanner/docs/schema-and-data-model#creating-interleaved-tables[parent-child interleaved table mechanism].
Cloud Spanner interleaved tables enforce the one-to-many relationship and provide efficient queries and operations on entities of a single domain parent entity.
These relationships can be up to 7 levels deep.
Cloud Spanner also provides automatic cascading delete or enforces the deletion of child entities before parents.

While one-to-one and many-to-many relationships can be implemented in Cloud Spanner and Spring Data Cloud Spanner using constructs of interleaved parent-child tables, only the parent-child relationship is natively supported.
Cloud Spanner does not support the foreign key constraint, though the parent-child key constraint enforces a similar requirement when used with interleaved tables.

For example, the following Java entities:

[source,java]
----
@Table(name = ""Singers"")
class Singer {
  @PrimaryKey
  long SingerId;

  String FirstName;

  String LastName;

  byte[] SingerInfo;

  @Interleaved
  List<Album> albums;
}

@Table(name = ""Albums"")
class Album {
  @PrimaryKey
  long SingerId;

  @PrimaryKey(keyOrder = 2)
  long AlbumId;

  String AlbumTitle;
}
----

These classes can correspond to an existing pair of interleaved tables.
The `@Interleaved` annotation may be applied to `Collection` properties and the inner type is resolved as the child entity type.
The schema needed to create them can also be generated using the `SpannerSchemaUtils` and run by using the `SpannerDatabaseAdminTemplate`:

[source,java]
----

@Autowired
SpannerSchemaUtils schemaUtils;

@Autowired
SpannerDatabaseAdminTemplate databaseAdmin;
...

// Get the create statmenets for all tables in the table structure rooted at Singer
List<String> createStrings = this.schemaUtils.getCreateTableDdlStringsForInterleavedHierarchy(Singer.class);

// Create the tables and also create the database if necessary
this.databaseAdmin.executeDdlStrings(createStrings, true);
----

The `createStrings` list contains table schema statements using column names and types compatible with the provided Java type and any resolved child relationship types contained within based on the configured custom converters.

[source,sql]
----
CREATE TABLE Singers (
  SingerId   INT64 NOT NULL,
  FirstName  STRING(1024),
  LastName   STRING(1024),
  SingerInfo BYTES(MAX),
) PRIMARY KEY (SingerId);

CREATE TABLE Albums (
  SingerId     INT64 NOT NULL,
  AlbumId      INT64 NOT NULL,
  AlbumTitle   STRING(MAX),
) PRIMARY KEY (SingerId, AlbumId),
  INTERLEAVE IN PARENT Singers ON DELETE CASCADE;
----

The `ON DELETE CASCADE` clause indicates that Cloud Spanner will delete all Albums of a singer if the Singer is deleted.
The alternative is `ON DELETE NO ACTION`, where a Singer cannot be deleted until all of its Albums have already been deleted.
When using `SpannerSchemaUtils` to generate the schema strings, the `spring.cloud.gcp.spanner.createInterleavedTableDdlOnDeleteCascade` boolean setting determines if these schema are generated as `ON DELETE CASCADE` for `true` and `ON DELETE NO ACTION` for `false`.

Cloud Spanner restricts these relationships to 7 child layers.
A table may have multiple child tables.

On updating or inserting an object to Cloud Spanner, all of its referenced children objects are also updated or inserted in the same request, respectively.
On read, all of the interleaved child rows are also all read.

===== Lazy Fetch

`@Interleaved` properties are retrieved eagerly by default, but can be fetched lazily for performance in both read and write:

[source,java]
----
@Interleaved(lazy = true)
List<Album> albums;
----

Lazily-fetched interleaved properties are retrieved upon the first interaction with the property.
If a property marked for lazy fetching is never retrieved, then it is also skipped when saving the parent entity.

If used inside a transaction, subsequent operations on lazily-fetched properties use the same transaction context as that of the original parent entity.

===== Declarative Filtering with `@Where`
The `@Where` annotation could be applied to an entity class or to an interleaved property.
This annotation provides an SQL where clause that will be applied at the fetching of interleaved collections or the entity itself.

Let's say we have an `Agreement` with a list of `Participants` which could be assigned to it.
We would like to fetch a list of currently active participants.
For security reasons, all records should remain in the database forever, even if participants become inactive.
That can be easily achieved with the `@Where` annotation, which is demonstrated by this example:

[source, java]
----
@Table(name = ""participants"")
public class Participant {
  //...
  boolean active;
  //...
}

@Table(name = ""agreements"")
public class Agreement {
  //...
  @Interleaved
  @Where(""active = true"")
  List<Participant> participants;
  Person person;
  //...
}
----

==== Supported Types

Spring Data Cloud Spanner natively supports the following types for regular fields but also utilizes custom converters (detailed in following sections) and dozens of pre-defined Spring Data custom converters to handle other common Java types.

Natively supported types:

* `com.google.cloud.ByteArray`
* `com.google.cloud.Date`
* `com.google.cloud.Timestamp`
* `java.lang.Boolean`, `boolean`
* `java.lang.Double`, `double`
* `java.lang.Long`, `long`
* `java.lang.Integer`, `int`
* `java.lang.String`
* `double[]`
* `long[]`
* `boolean[]`
* `java.util.Date`
* `java.time.Instant`
* `java.sql.Date`
* `java.time.LocalDate`
* `java.time.LocalDateTime`


==== Lists

Spanner supports `ARRAY` types for columns.
`ARRAY` columns are mapped to `List` fields in POJOS.

Example:

[source,java]
----
List<Double> curve;
----

The types inside the lists can be any singular property type.

==== Lists of Structs

Cloud Spanner queries can https://cloud.google.com/spanner/docs/query-syntax#using-structs-with-select[construct STRUCT values] that appear as columns in the result.
Cloud Spanner requires STRUCT values appear in ARRAYs at the root level: `SELECT ARRAY(SELECT STRUCT(1 as val1, 2 as val2)) as pair FROM Users`.

Spring Data Cloud Spanner will attempt to read the column STRUCT values into a property that is an `Iterable` of an entity type compatible with the schema of the column STRUCT value.


For the previous array-select example, the following property can be mapped with the constructed `ARRAY<STRUCT>` column: `List<TwoInts> pair;` where the `TwoInts` type is defined:

[source, java]
----
class TwoInts {

  int val1;

  int val2;
}
----

==== Custom types

Custom converters can be used to extend the type support for user defined types.

. Converters need to implement the `org.springframework.core.convert.converter.Converter` interface in both directions.
. The user defined type needs to be mapped to one of the basic types supported by Spanner:

* `com.google.cloud.ByteArray`
* `com.google.cloud.Date`
* `com.google.cloud.Timestamp`
* `java.lang.Boolean`, `boolean`
* `java.lang.Double`, `double`
* `java.lang.Long`, `long`
* `java.lang.String`
* `double[]`
* `long[]`
* `boolean[]`
* `enum` types

. An instance of both Converters needs to be passed to a `ConverterAwareMappingSpannerEntityProcessor`, which then has to be made available as a `@Bean` for `SpannerEntityProcessor`.

For example:

We would like to have a field of type `Person` on our `Trade` POJO:
[source, java]
----

@Table(name = ""trades"")
public class Trade {
  //...
  Person person;
  //...
}
----

Where Person is a simple class:

[source, java]
----
public class Person {

  public String firstName;
  public String lastName;

}
----

We have to define the two converters:

[source, java]
----
  public class PersonWriteConverter implements Converter<Person, String> {

    @Override
    public String convert(Person person) {
      return person.firstName + "" "" + person.lastName;
    }
  }

  public class PersonReadConverter implements Converter<String, Person> {

    @Override
    public Person convert(String s) {
      Person person = new Person();
      person.firstName = s.split("" "")[0];
      person.lastName = s.split("" "")[1];
      return person;
    }
  }
----

That will be configured in our `@Configuration` file:

[source, java]
----
@Configuration
public class ConverterConfiguration {

	@Bean
	public SpannerEntityProcessor spannerEntityProcessor(SpannerMappingContext spannerMappingContext) {
		return new ConverterAwareMappingSpannerEntityProcessor(spannerMappingContext,
				Arrays.asList(new PersonWriteConverter()),
				Arrays.asList(new PersonReadConverter()));
	}
}
----

==== Custom Converter for Struct Array Columns
If a `Converter<Struct, A>` is provided, then properties of type `List<A>` can be used in your entity types.


=== Spanner Operations & Template

`SpannerOperations` and its implementation, `SpannerTemplate`, provides the Template pattern familiar to Spring developers.
It provides:

 - Resource management
 - One-stop-shop to Spanner operations with the Spring Data POJO mapping and conversion features
 - Exception conversion

Using the `autoconfigure` provided by our Spring Boot Starter for Spanner, your Spring application context will contain a fully configured `SpannerTemplate` object that you can easily autowire in your application:

[source,java]
----
@SpringBootApplication
public class SpannerTemplateExample {

	@Autowired
	SpannerTemplate spannerTemplate;

	public void doSomething() {
		this.spannerTemplate.delete(Trade.class, KeySet.all());
		//...
		Trade t = new Trade();
		//...
		this.spannerTemplate.insert(t);
		//...
		List<Trade> tradesByAction = spannerTemplate.findAll(Trade.class);
		//...
	}
}
----

The Template API provides convenience methods for:

- https://cloud.google.com/spanner/docs/reads[Reads], and by providing SpannerReadOptions and
SpannerQueryOptions
   ** Stale read
   ** Read with secondary indices
   ** Read with limits and offsets
   ** Read with sorting
- https://cloud.google.com/spanner/docs/reads#execute_a_query[Queries]
- DML operations (delete, insert, update, upsert)
- Partial reads
   ** You can define a set of columns to be read into your entity
- Partial writes
   ** Persist only a few properties from your entity
- Read-only transactions
- Locking read-write transactions

==== SQL Query

Cloud Spanner has SQL support for running read-only queries.
All the query related methods start with `query` on `SpannerTemplate`.
By using `SpannerTemplate`, you can run SQL queries that map to POJOs:

[source,java]
----
List<Trade> trades = this.spannerTemplate.query(Trade.class, Statement.of(""SELECT * FROM trades""));
----

==== Read

Spanner exposes a https://cloud.google.com/spanner/docs/reads[Read API] for reading single row or multiple rows in a table or in a secondary index.

Using `SpannerTemplate` you can run reads, as the following example shows:

[source,java]
----
List<Trade> trades = this.spannerTemplate.readAll(Trade.class);
----

Main benefit of reads over queries is reading multiple rows of a certain pattern of keys is much easier using the features of the https://github.com/GoogleCloudPlatform/google-cloud-java/blob/master/google-cloud-spanner/src/main/java/com/google/cloud/spanner/KeySet.java[`KeySet`] class.


==== Advanced reads

===== Stale read

All reads and queries are *strong reads* by default.
A *strong read* is a read at a current time and is guaranteed to see all data that has been committed up until the start of this read.
An *exact staleness read* is read at a timestamp in the past.
Cloud Spanner allows you to determine how current the data should be when you read data.
With `SpannerTemplate` you can specify the `Timestamp` by setting it on `SpannerQueryOptions` or `SpannerReadOptions` to the appropriate read or query methods:

Reads:

[source,java]
----
// a read with options:
SpannerReadOptions spannerReadOptions = new SpannerReadOptions().setTimestamp(myTimestamp);
List<Trade> trades = this.spannerTemplate.readAll(Trade.class, spannerReadOptions);
----

Queries:

[source,java]
----
// a query with options:
SpannerQueryOptions spannerQueryOptions = new SpannerQueryOptions().setTimestamp(myTimestamp);
List<Trade> trades = this.spannerTemplate.query(Trade.class, Statement.of(""SELECT * FROM trades""), spannerQueryOptions);
----

You can also read with https://cloud.google.com/spanner/docs/timestamp-bounds[*bounded staleness*] by setting `.setTimestampBound(TimestampBound.ofMinReadTimestamp(myTimestamp))` on the query and read options objects.
Bounded staleness lets Cloud Spanner choose any point in time later than or equal to the given timestampBound, but it cannot be used inside transactions.


===== Read from a secondary index

Using a https://cloud.google.com/spanner/docs/secondary-indexes[secondary index] is available for Reads via the Template API and it is also implicitly available via SQL for Queries.

The following shows how to read rows from a table using a https://cloud.google.com/spanner/docs/secondary-indexes[secondary index] simply by setting `index` on `SpannerReadOptions`:

[source,java]
----
SpannerReadOptions spannerReadOptions = new SpannerReadOptions().setIndex(""TradesByTrader"");
List<Trade> trades = this.spannerTemplate.readAll(Trade.class, spannerReadOptions);
----


===== Read with offsets and limits

Limits and offsets are only supported by Queries.
The following will get only the first two rows of the query:

[source,java]
----
SpannerQueryOptions spannerQueryOptions = new SpannerQueryOptions().setLimit(2).setOffset(3);
List<Trade> trades = this.spannerTemplate.query(Trade.class, Statement.of(""SELECT * FROM trades""), spannerQueryOptions);
----

Note that the above is equivalent of running `SELECT * FROM trades LIMIT 2 OFFSET 3`.

===== Sorting

Reads by keys do not support sorting.
However, queries on the Template API support sorting through standard SQL and also via Spring Data Sort API:

[source,java]
----
List<Trade> trades = this.spannerTemplate.queryAll(Trade.class, Sort.by(""action""));
----

If the provided sorted field name is that of a property of the domain type, then the column name corresponding to that property will be used in the query.
Otherwise, the given field name is assumed to be the name of the column in the Cloud Spanner table.
Sorting on columns of Cloud Spanner types STRING and BYTES can be done while ignoring case:

[source,java]
----
Sort.by(Order.desc(""action"").ignoreCase())
----

===== Partial read

Partial read is only possible when using Queries.
In case the rows returned by the query have fewer columns than the entity that it will be mapped to, Spring Data will map the returned columns only.
This setting also applies to nested structs and their corresponding nested POJO properties.

[source,java]
----
List<Trade> trades = this.spannerTemplate.query(Trade.class, Statement.of(""SELECT action, symbol FROM trades""),
    new SpannerQueryOptions().setAllowMissingResultSetColumns(true));
----

If the setting is set to `false`, then an exception will be thrown if there are missing columns in the query result.

===== Summary of options for Query vs Read

|===
| Feature | Query supports it | Read supports it
| SQL  | yes | no
| Partial read | yes | no
| Limits | yes | no
| Offsets | yes | no
| Secondary index | yes | yes
| Read using index range | no | yes
| Sorting | yes | no
|===

==== Write / Update

The write methods of `SpannerOperations` accept a POJO and writes all of its properties to Spanner.
The corresponding Spanner table and entity metadata is obtained from the given object's actual type.

If a POJO was retrieved from Spanner and its primary key properties values were changed and then written or updated, the operation will occur as if against a row with the new primary key values.
The row with the original primary key values will not be affected.

===== Insert

The `insert` method of `SpannerOperations` accepts a POJO and writes all of its properties to Spanner, which means the operation will fail if a row with the POJO's primary key already exists in the table.

[source, java]
----
Trade t = new Trade();
this.spannerTemplate.insert(t);
----

===== Update

The `update` method of `SpannerOperations` accepts a POJO and writes all of its properties to Spanner, which means the operation will fail if the POJO's primary key does not already exist in the table.

[source, java]
----
// t was retrieved from a previous operation
this.spannerTemplate.update(t);
----

===== Upsert

The `upsert` method of `SpannerOperations` accepts a POJO and writes all of its properties to Spanner using update-or-insert.

[source, java]
----
// t was retrieved from a previous operation or it's new
this.spannerTemplate.upsert(t);
----

===== Partial Update

The update methods of `SpannerOperations` operate by default on all properties within the given object, but also accept `String[]` and `Optional<Set<String>>` of column names.
If the `Optional` of set of column names is empty, then all columns are written to Spanner.
However, if the Optional is occupied by an empty set, then no columns will be written.


[source, java]
----
// t was retrieved from a previous operation or it's new
this.spannerTemplate.update(t, ""symbol"", ""action"");
----

==== DML

DML statements can be run by using `SpannerOperations.executeDmlStatement`.
Inserts, updates, and deletions can affect any number of rows and entities.

You can run https://cloud.google.com/spanner/docs/dml-partitioned[partitioned DML] updates by using the `executePartitionedDmlStatement` method.
Partitioned DML queries have performance benefits but also have restrictions and cannot be used inside transactions.

==== Transactions

`SpannerOperations` provides methods to run `java.util.Function` objects within a single transaction while making available the read and write methods from `SpannerOperations`.

===== Read/Write Transaction

Read and write transactions are provided by `SpannerOperations` via the `performReadWriteTransaction` method:

[source,java]
----

@Autowired
SpannerOperations mySpannerOperations;

public String doWorkInsideTransaction() {
  return mySpannerOperations.performReadWriteTransaction(
    transActionSpannerOperations -> {
      // Work with transActionSpannerOperations here.
      // It is also a SpannerOperations object.

      return ""transaction completed"";
    }
  );
}
----

The `performReadWriteTransaction` method accepts a `Function` that is provided an instance of a `SpannerOperations` object.
The final returned value and type of the function is determined by the user.
You can use this object just as you would a regular `SpannerOperations` with a few exceptions:

- Its read functionality cannot perform stale reads, because all reads and writes happen at the single point in time of the transaction.
- It cannot perform sub-transactions via `performReadWriteTransaction` or `performReadOnlyTransaction`.

As these read-write transactions are locking, it is recommended that you use the `performReadOnlyTransaction` if your function does not perform any writes.

===== Read-only Transaction

The `performReadOnlyTransaction` method is used to perform read-only transactions using a `SpannerOperations`:

[source,java]
----

@Autowired
SpannerOperations mySpannerOperations;

public String doWorkInsideTransaction() {
  return mySpannerOperations.performReadOnlyTransaction(
    transActionSpannerOperations -> {
      // Work with transActionSpannerOperations here.
      // It is also a SpannerOperations object.

      return ""transaction completed"";
    }
  );
}
----

The `performReadOnlyTransaction` method accepts a `Function` that is provided an instance of a
`SpannerOperations` object.
This method also accepts a `ReadOptions` object, but the only attribute used is the timestamp used to determine the snapshot in time to perform the reads in the transaction.
If the timestamp is not set in the read options the transaction is run against the current state of the database.
The final returned value and type of the function is determined by the user.
You can use this object just as you would a regular `SpannerOperations` with
a few exceptions:

- Its read functionality cannot perform stale reads (other than the staleness set on the entire transaction), because all reads happen at the single point in time of the transaction.
- It cannot perform sub-transactions via `performReadWriteTransaction` or `performReadOnlyTransaction`
- It cannot perform any write operations.

Because read-only transactions are non-locking and can be performed on points in time in the past, these are recommended for functions that do not perform write operations.

===== Declarative Transactions with @Transactional Annotation

This feature requires a bean of `SpannerTransactionManager`, which is provided when using `spring-cloud-gcp-starter-data-spanner`.

`SpannerTemplate` and `SpannerRepository` support running methods with the `@Transactional` https://docs.spring.io/spring/docs/current/spring-framework-reference/data-access.html#transaction-declarative[annotation] as transactions.
If a method annotated with `@Transactional` calls another method also annotated, then both methods will work within the same transaction.
`performReadOnlyTransaction` and `performReadWriteTransaction` cannot be used in `@Transactional` annotated methods because Cloud Spanner does not support transactions within transactions.

==== DML Statements

`SpannerTemplate` supports https://cloud.google.com/spanner/docs/dml-tasks:[DML] `Statements`.
DML statements can also be run in transactions by using `performReadWriteTransaction` or by using the `@Transactional` annotation.

=== Repositories

{spring-data-commons-ref}/#repositories[Spring Data Repositories] are a powerful abstraction that can save you a lot of boilerplate code.

For example:

[source,java]
----
public interface TraderRepository extends SpannerRepository<Trader, String> {
}
----

Spring Data generates a working implementation of the specified interface, which can be conveniently autowired into an application.

The `Trader` type parameter to `SpannerRepository` refers to the underlying domain type.
The second type parameter, `String` in this case, refers to the type of the key of the domain type.


For POJOs with a composite primary key, this ID type parameter can be any descendant of `Object[]` compatible with all primary key properties, any descendant of `Iterable`, or `com.google.cloud.spanner.Key`.
If the domain POJO type only has a single primary key column, then the primary key property type can be used or the `Key` type.

For example in case of Trades, that belong to a Trader, `TradeRepository` would look like this:

[source,java]
----
public interface TradeRepository extends SpannerRepository<Trade, String[]> {

}
----

[source,java]
----
public class MyApplication {

	@Autowired
	SpannerTemplate spannerTemplate;

	@Autowired
	StudentRepository studentRepository;

	public void demo() {

		this.tradeRepository.deleteAll();
		String traderId = ""demo_trader"";
		Trade t = new Trade();
		t.symbol = stock;
		t.action = action;
		t.traderId = traderId;
		t.price = new BigDecimal(""100.0"");
		t.shares = 12345.6;
		this.spannerTemplate.insert(t);

		Iterable<Trade> allTrades = this.tradeRepository.findAll();

		int count = this.tradeRepository.countByAction(""BUY"");

	}
}

----

==== CRUD Repository

`CrudRepository` methods work as expected, with one thing Spanner specific: the `save` and `saveAll` methods work as update-or-insert.

==== Paging and Sorting Repository

You can also use `PagingAndSortingRepository` with Spanner Spring Data.
The sorting and pageable `findAll` methods available from this interface operate on the current state of the Spanner database.
As a result, beware that the state of the database (and the results) might change when moving page to page.

==== Spanner Repository

The `SpannerRepository` extends the `PagingAndSortingRepository`, but adds the read-only and the read-write transaction functionality provided by Spanner.
These transactions work very similarly to those of `SpannerOperations`, but is specific to the repository's domain type and provides repository functions instead of template functions.

For example, this is a read-only transaction:

[source,java]
----

@Autowired
SpannerRepository myRepo;

public String doWorkInsideTransaction() {
  return myRepo.performReadOnlyTransaction(
    transactionSpannerRepo -> {
      // Work with the single-transaction transactionSpannerRepo here.
      // This is a SpannerRepository object.

      return ""transaction completed"";
    }
  );
}
----

When creating custom repositories for your own domain types and query methods, you can extend `SpannerRepository` to access Cloud Spanner-specific features as well as all features from `PagingAndSortingRepository` and `CrudRepository`.

=== Query Methods

`SpannerRepository` supports Query Methods.
Described in the following sections, these are methods residing in your custom repository interfaces of which implementations are generated based on their names and annotations.
Query Methods can read, write, and delete entities in Cloud Spanner.
Parameters to these methods can be any Cloud Spanner data type supported directly or via custom configured converters.
Parameters can also be of type `Struct` or POJOs.
If a POJO is given as a parameter, it will be converted to a `Struct` with the same type-conversion logic as used to create write mutations.
Comparisons using Struct parameters are limited to https://cloud.google.com/spanner/docs/data-types#limited-comparisons-for-struct[what is available with Cloud Spanner].


==== Query methods by convention

[source, java]
----
public interface TradeRepository extends SpannerRepository<Trade, String[]> {
    List<Trade> findByAction(String action);

	int countByAction(String action);

	// Named methods are powerful, but can get unwieldy
	List<Trade> findTop3DistinctByActionAndSymbolIgnoreCaseOrTraderIdOrderBySymbolDesc(
  			String action, String symbol, String traderId);
}
----

In the example above, the {spring-data-commons-ref}/#repositories.query-methods[query methods] in `TradeRepository` are generated based on the name of the methods, using the {spring-data-commons-ref}#repositories.query-methods.query-creation[Spring Data Query creation naming convention].

`List<Trade> findByAction(String action)` would translate to a `SELECT * FROM trades WHERE action = ?`.

The function `List<Trade> findTop3DistinctByActionAndSymbolIgnoreCaseOrTraderIdOrderBySymbolDesc(String action, String symbol, String traderId);` will be translated as the equivalent of this SQL query:

[source, sql]
----
SELECT DISTINCT * FROM trades
WHERE ACTION = ? AND LOWER(SYMBOL) = LOWER(?) AND TRADER_ID = ?
ORDER BY SYMBOL DESC
LIMIT 3
----

The following filter options are supported:

* Equality
* Greater than or equals
* Greater than
* Less than or equals
* Less than
* Is null
* Is not null
* Is true
* Is false
* Like a string
* Not like a string
* Contains a string
* Not contains a string
* In
* Not in

Note that the phrase `SymbolIgnoreCase` is translated to `LOWER(SYMBOL) = LOWER(?)` indicating a non-case-sensitive matching.
The `IgnoreCase` phrase may only be appended to fields that correspond to columns of type STRING or BYTES.
The Spring Data ""AllIgnoreCase"" phrase appended at the end of the method name is not supported.

The `Like` or `NotLike` naming conventions:
[source, java]
----
List<Trade> findBySymbolLike(String symbolFragment);
----
The param `symbolFragment` can contain https://cloud.google.com/spanner/docs/functions-and-operators#comparison-operators[wildcard characters] for string matching such as `_` and `%`.

The `Contains` and `NotContains` naming conventions:
[source, java]
----
List<Trade> findBySymbolContains(String symbolFragment);
----
The param `symbolFragment` is a https://cloud.google.com/spanner/docs/functions-and-operators#regexp_contains[regular expression] that is checked for occurrences.

The `In` and `NotIn` keywords must be used with `Iterable` corresponding parameters.

Delete queries are also supported.
For example, query methods such as `deleteByAction` or `removeByAction` delete entities found by `findByAction`.
The delete operation happens in a single transaction.

Delete queries can have the following return types:
* An integer type that is the number of entities deleted
* A collection of entities that were deleted
* `void`

==== Custom SQL/DML query methods

The example above for `List<Trade> fetchByActionNamedQuery(String action)` does not match the {spring-data-commons-ref}#repositories.query-methods.query-creation[Spring Data Query creation naming convention], so we have to map a parametrized Spanner SQL query to it.

The SQL query for the method can be mapped to repository methods in one of two ways:

 * `namedQueries` properties file
 * using the `@Query` annotation

The names of the tags of the SQL correspond to the `@Param` annotated names of the method parameters.

Interleaved properties are loaded eagerly, unless they are annotated with `@Interleaved(lazy = true)`.

Custom SQL query methods can accept a single `Sort` or `Pageable` parameter that is applied on top of the specified custom query.
It is the recommended way to control the sort order of the results, which is not guaranteed by the `ORDER BY` clause in the SQL query.
This is due to the fact that the user-provided query is used as a sub-query, and Cloud Spanner doesn't preserve order in subquery results.

You might want to use `ORDER BY` with `LIMIT` to obtain the top records, according to a specified order.
However, to ensure the correct sort order of the final result set, sort options have to be passed in with a `Pageable`.

[source, java]
----
	@Query(""SELECT * FROM trades"")
	List<Trade> fetchTrades(Pageable pageable);

	@Query(""SELECT * FROM trades ORDER BY price DESC LIMIT 1"")
 	Trade topTrade(Pageable pageable);

----

This can be used:

[source, java]
----
	List<Trade> customSortedTrades = tradeRepository.fetchTrades(PageRequest
  				.of(2, 2, org.springframework.data.domain.Sort.by(Order.asc(""id""))));
----

The results would be sorted by ""id"" in ascending order.

Your query method can also return non-entity types:
[source, java]
----
  	@Query(""SELECT COUNT(1) FROM trades WHERE action = @action"")
  	int countByActionQuery(String action);

  	@Query(""SELECT EXISTS(SELECT COUNT(1) FROM trades WHERE action = @action)"")
  	boolean existsByActionQuery(String action);

  	@Query(""SELECT action FROM trades WHERE action = @action LIMIT 1"")
  	String getFirstString(@Param(""action"") String action);

  	@Query(""SELECT action FROM trades WHERE action = @action"")
  	List<String> getFirstStringList(@Param(""action"") String action);
----

DML statements can also be run by query methods, but the only possible return value is a `long` representing the number of affected rows.
The `dmlStatement` boolean setting must be set on `@Query` to indicate that the query method is run as a DML statement.

[source, java]
----
  	@Query(value = ""DELETE FROM trades WHERE action = @action"", dmlStatement = true)
  	long deleteByActionQuery(String action);
----

===== Query methods with named queries properties

By default, the `namedQueriesLocation` attribute on `@EnableSpannerRepositories` points to the `META-INF/spanner-named-queries.properties` file.
You can specify the query for a method in the properties file by providing the SQL as the value for the ""interface.method"" property:

[source, properties]
----
Trade.fetchByActionNamedQuery=SELECT * FROM trades WHERE trades.action = @tag0
----

[source, java]
----
public interface TradeRepository extends SpannerRepository<Trade, String[]> {
	// This method uses the query from the properties file instead of one generated based on name.
	List<Trade> fetchByActionNamedQuery(@Param(""tag0"") String action);
}
----
===== Query methods with annotation

Using the `@Query` annotation:

[source, java]
----
public interface TradeRepository extends SpannerRepository<Trade, String[]> {
    @Query(""SELECT * FROM trades WHERE trades.action = @tag0"")
    List<Trade> fetchByActionNamedQuery(@Param(""tag0"") String action);
}
----

Table names can be used directly.
For example, ""trades"" in the above example.
Alternatively, table names can be resolved from the `@Table` annotation on domain classes as well.
In this case, the query should refer to table names with fully qualified class names between `:`
characters: `:fully.qualified.ClassName:`.
A full example would look like:

[source, java]
----
@Query(""SELECT * FROM :com.example.Trade: WHERE trades.action = @tag0"")
List<Trade> fetchByActionNamedQuery(String action);
----

This allows table names evaluated with SpEL to be used in custom queries.

SpEL can also be used to provide SQL parameters:

[source, java]
----
@Query(""SELECT * FROM :com.example.Trade: WHERE trades.action = @tag0
  AND price > #{#priceRadius * -1} AND price < #{#priceRadius * 2}"")
List<Trade> fetchByActionNamedQuery(String action, Double priceRadius);
----

When using the `IN` SQL clause, remember to use `IN UNNEST(@iterableParam)` to specify a single `Iterable` parameter.
You can also use a fixed number of singular parameters such as `IN (@stringParam1, @stringParam2)`.

==== Projections
Spring Data Spanner supports {spring-data-commons-ref}/#projections[projections].
You can define projection interfaces based on domain types and add query methods that return them in your repository:

[source, java]
----
public interface TradeProjection {

	String getAction();

	@Value(""#{target.symbol + ' ' + target.action}"")
	String getSymbolAndAction();
}

public interface TradeRepository extends SpannerRepository<Trade, Key> {

	List<Trade> findByTraderId(String traderId);

	List<TradeProjection> findByAction(String action);

	@Query(""SELECT action, symbol FROM trades WHERE action = @action"")
	List<TradeProjection> findByQuery(String action);
}
----

Projections can be provided by name-convention-based query methods as well as by custom SQL queries.
If using custom SQL queries, you can further restrict the columns retrieved from Spanner to just those required by the projection to improve performance.

Properties of projection types defined using SpEL use the fixed name `target` for the underlying domain object.
As a result accessing underlying properties take the form `target.<property-name>`.

==== Empty result handling in repository methods
Java `java.util.Optional` can be used to indicate the potential absence of a return value.

Alternatively, query methods can return the result without a wrapper.
In that case the absence of a query result is indicated by returning `null`.
Repository methods returning collections are guaranteed never to return `null` but rather the corresponding empty collection.

NOTE: You can enable nullability checks. For more details please see https://docs.spring.io/spring/docs/current/spring-framework-reference/core.html#null-safety[Spring Framework’s nullability docs].

==== REST Repositories

When running with Spring Boot, repositories can be exposed as REST services by simply adding this dependency to your pom file:
[source,xml]
----
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-data-rest</artifactId>
</dependency>
----

If you prefer to configure parameters (such as path), you can use `@RepositoryRestResource` annotation:
[source,java]
----
@RepositoryRestResource(collectionResourceRel = ""trades"", path = ""trades"")
public interface TradeRepository extends SpannerRepository<Trade, Key> {
}
----

NOTE: For classes that have composite keys (multiple `@PrimaryKey` fields), only the `Key` type is supported for the repository ID type.

For example, you can retrieve all `Trade` objects in the repository by using `curl \\http://<server>:<port>/trades`, or any specific trade via `curl \\http://<server>:<port>/trades/<trader_id>,<trade_id>`.

The separator between your primary key components, `id` and `trader_id` in this case, is a comma by default, but can be configured to any string not found in your key values by extending the `SpannerKeyIdConverter` class:

[source,java]
----
@Component
class MySpecialIdConverter extends SpannerKeyIdConverter {

    @Override
    protected String getUrlIdSeparator() {
        return "":"";
    }
}
----

You can also write trades using `curl -XPOST -H""Content-Type: application/json"" -d@test.json \\http://<server>:<port>/trades/` where the file `test.json` holds the JSON representation of a `Trade` object.

=== Database and Schema Admin

Databases and tables inside Spanner instances can be created automatically from `SpannerPersistentEntity` objects:

[source,java]
----
@Autowired
private SpannerSchemaUtils spannerSchemaUtils;

@Autowired
private SpannerDatabaseAdminTemplate spannerDatabaseAdminTemplate;

public void createTable(SpannerPersistentEntity entity) {
	if(!spannerDatabaseAdminTemplate.tableExists(entity.tableName()){

	  // The boolean parameter indicates that the database will be created if it does not exist.
	  spannerDatabaseAdminTemplate.executeDdlStrings(Arrays.asList(
            spannerSchemaUtils.getCreateTableDDLString(entity.getType())), true);
	}
}
----

Schemas can be generated for entire object hierarchies with interleaved relationships and composite keys.

=== Events

Spring Data Cloud Spanner publishes events extending the Spring Framework's `ApplicationEvent` to the context that can be received by `ApplicationListener` beans you register.

[options=""header""]
|===
| Type| Description | Contents
| `AfterReadEvent`|Published immediately after entities are read by key from Cloud Spanner by `SpannerTemplate`| The entities loaded. The read options and key-set originally specified for the load operation.
| `AfterQueryEvent`|Published immediately after entities are read by query from Cloud Spanner by `SpannerTemplate`| The entities loaded. The query options and query statement originally specified for the load operation.
| `BeforeExecuteDmlEvent`|Published immediately before DML statements are executed by `SpannerTemplate`| The DML statement to execute.
| `AfterExecuteDmlEvent`|Published immediately after DML statements are executed by `SpannerTemplate`| The DML statement to execute and the number of rows affected by the operation as reported by Cloud Spanner.
| `BeforeSaveEvent`|Published immediately before upsert/update/insert operations are executed by `SpannerTemplate`| The mutations to be sent to Cloud Spanner, the entities to be saved, and optionally the properties in those entities to save.
| `AfterSaveEvent`|Published immediately after upsert/update/insert operations are executed by `SpannerTemplate`| The mutations sent to Cloud Spanner, the entities to be saved, and optionally the properties in those entities to save.
| `BeforeDeleteEvent`|Published immediately before delete operations are executed by `SpannerTemplate`| The mutations to be sent to Cloud Spanner. The target entities, keys, or entity type originally specified for the delete operation.
| `AfterDeleteEvent`|Published immediately after delete operations are executed by `SpannerTemplate`| The mutations sent to Cloud Spanner. The target entities, keys, or entity type originally specified for the delete operation.
|===


=== Auditing

Spring Data Cloud Spanner supports the `@LastModifiedDate` and `@LastModifiedBy` auditing annotations for properties:

[source,java]
----
@Table
public class SimpleEntity {
    @PrimaryKey
    String id;

    @LastModifiedBy
    String lastUser;

    @LastModifiedDate
    DateTime lastTouched;
}
----

Upon insert, update, or save, these properties will be set automatically by the framework before mutations are generated and saved to Cloud Spanner.

To take advantage of these features, add the `@EnableSpannerAuditing` annotation to your configuration class and provide a bean for an `AuditorAware<A>` implementation where the type `A` is the desired property type annotated by `@LastModifiedBy`:

[source,java]
----
@Configuration
@EnableSpannerAuditing
public class Config {

    @Bean
    public AuditorAware<String> auditorProvider() {
        return () -> Optional.of(""YOUR_USERNAME_HERE"");
    }
}
----

The `AuditorAware` interface contains a single method that supplies the value for fields annotated by `@LastModifiedBy` and can be of any type.
One alternative is to use Spring Security's `User` type:

[source,java]
----
class SpringSecurityAuditorAware implements AuditorAware<User> {

  public Optional<User> getCurrentAuditor() {

    return Optional.ofNullable(SecurityContextHolder.getContext())
			  .map(SecurityContext::getAuthentication)
			  .filter(Authentication::isAuthenticated)
			  .map(Authentication::getPrincipal)
			  .map(User.class::cast);
  }
}
----

You can also set a custom provider for properties annotated `@LastModifiedDate` by providing a bean for `DateTimeProvider` and providing the bean name to `@EnableSpannerAuditing(dateTimeProviderRef = ""customDateTimeProviderBean"")`.

=== Multi-Instance Usage

Your application can be configured to use multiple Cloud Spanner instances or databases by providing a custom bean for `DatabaseIdProvider`.
The default bean uses the instance ID, database name, and project ID options you configured in `application.properties`.

[source,java]
----
    @Bean
    public DatabaseIdProvider databaseIdProvider() {
        // return custom connection options provider
    }
----

The `DatabaseId` given by this provider is used as the target database name and instance of each operation Spring Data Cloud Spanner executes.
By providing a custom implementation of this bean (for example, supplying a thread-local `DatabaseId`), you can direct your application to use multiple instances or databases.

Database administrative operations, such as creating tables using `SpannerDatabaseAdminTemplate`, will also utilize the provided `DatabaseId`.

If you would like to configure every aspect of each connection (such as pool size and retry settings), you can supply a bean for `Supplier<DatabaseClient>`.


=== Cloud Spanner Emulator

The https://cloud.google.com/sdk[Cloud SDK] provides a local, in-memory emulator for Cloud Spanner, which you can use to develop and test your application. As the emulator stores data only in memory, it will not persist data across runs. It is intended to help you use Cloud Spanner for local development and testing, not for production deployments.

In order to set up and start the emulator, you can follow https://cloud.google.com/spanner/docs/emulator[these steps].

This command can be used to create Cloud Spanner instances:

----
$ gcloud spanner instances create <instance-name> --config=emulator-config --description=""<description>"" --nodes=1
----

Once the Spanner emulator is running, ensure that the following properties are set in your `application.properties` of your Spring application:

----
spring.cloud.gcp.spanner.emulator.enabled=true
spring.cloud.gcp.spanner.emulator-host=${EMULATOR_HOSTPORT}
----

=== Sample

A https://github.com/spring-cloud/spring-cloud-gcp/tree/master/spring-cloud-gcp-samples/spring-cloud-gcp-data-spanner-sample[sample application] is available.
",12204,False,2035.812792919168,median
"[[salesforce-component]]
= Salesforce Component

*Available as of Camel version 2.12*

This component supports producer and consumer endpoints to communicate
with Salesforce using Java DTOs.  +
 There is a companion maven plugin Camel Salesforce Plugin that
generates these DTOs (see further below).

Maven users will need to add the following dependency to their `pom.xml`
for this component:

[source,xml]
----
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-salesforce</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>
----

NOTE: Developers wishing to contribute to the component are instructed
to look at the https://github.com/apache/camel/tree/master/components/camel-salesforce/camel-salesforce-component/README.md[README.md] file on instructions on how to get started and
setup your environment for running integration tests.

== Authenticating to Salesforce

The component supports three OAuth authentication flows:

* https://help.salesforce.com/articleView?id=remoteaccess_oauth_username_password_flow.htm[OAuth 2.0 Username-Password Flow]
* https://help.salesforce.com/articleView?id=remoteaccess_oauth_refresh_token_flow.htm[OAuth 2.0 Refresh Token Flow]
* https://help.salesforce.com/articleView?id=remoteaccess_oauth_jwt_flow.htm[OAuth 2.0 JWT Bearer Token Flow]

For each of the flow different set of properties needs to be set:

.Properties to set for each authentication flow
|===
| Property     | Where to find it on Salesforce     | Flow

| clientId     | Connected App, Consumer Key        | All flows
| clientSecret | Connected App, Consumer Secret     | Username-Password, Refresh Token
| userName     | Salesforce user username           | Username-Password, JWT Bearer Token
| password     | Salesforce user password           | Username-Password
| refreshToken | From OAuth flow callback           | Refresh Token
| keystore     | Connected App, Digital Certificate | JWT Bearer Token
|===

The component auto determines what flow you're trying to configure, to
be remove ambiguity set the `authenticationType` property.

NOTE: Using Username-Password Flow in production is not encouraged.

NOTE: The certificate used in JWT Bearer Token Flow can be a selfsigned 
certificate. The KeyStore holding the certificate and the private key
must contain only single certificate-private key entry.

== URI format

When used as a consumer, receiving streaming events, the URI scheme is:

[source,java]
----
salesforce:topic?options
----

When used as a producer, invoking the Salesforce REST APIs, the URI
scheme is:

[source,java]
----
salesforce:operationName?options
----

You can append query options to the URI in the following format,
`?option=value&option=value&...`

== Passing in Salesforce headers and fetching Salesforce response headers

There is support to pass https://developer.salesforce.com/docs/atlas.en-us.api_rest.meta/api_rest/headers.htm[Salesforce headers]
via inbound message headers, header names that start with `Sforce` or
`x-sfdc` on the Camel message will be passed on in the request, and
response headers that start with `Sforce` will be present in the outbound
message headers.

For example to fetch API limits you can specify:

[source,java]
----
// in your Camel route set the header before Salesforce endpoint
//...
  .setHeader(""Sforce-Limit-Info"", constant(""api-usage""))
  .to(""salesforce:getGlobalObjects"")
  .to(myProcessor);

// myProcessor will receive `Sforce-Limit-Info` header on the outbound
// message
class MyProcessor implements Processor {
    public void process(Exchange exchange) throws Exception {
        Message in = exchange.getIn();
        String apiLimits = in.getHeader(""Sforce-Limit-Info"", String.class);
   }
}
----

== Supported Salesforce APIs

The component supports the following Salesforce APIs

Producer endpoints can use the following APIs. Most of the APIs process
one record at a time, the Query API can retrieve multiple Records.

=== Rest API

You can use the following for `operationName`:

* getVersions - Gets supported Salesforce REST API versions
* getResources - Gets available Salesforce REST Resource endpoints
* getGlobalObjects - Gets metadata for all available SObject types
* getBasicInfo - Gets basic metadata for a specific SObject type
* getDescription - Gets comprehensive metadata for a specific SObject
type
* getSObject - Gets an SObject using its Salesforce Id
* createSObject - Creates an SObject
* updateSObject - Updates an SObject using Id
* deleteSObject - Deletes an SObject using Id
* getSObjectWithId - Gets an SObject using an external (user defined) id
field
* upsertSObject - Updates or inserts an SObject using an external id
* deleteSObjectWithId - Deletes an SObject using an external id
* query - Runs a Salesforce SOQL query
* queryMore - Retrieves more results (in case of large number of
results) using result link returned from the 'query' API
* search - Runs a Salesforce SOSL query
* limits - fetching organization API usage limits
* recent - fetching recent items
* approval - submit a record or records (batch) for approval process
* approvals - fetch a list of all approval processes
* composite - submit up to 25 possibly related REST requests and receive individual responses
* composite-tree - create up to 200 records with parent-child relationships (up to 5 levels) in one go
* composite-batch - submit a composition of requests in batch
* queryAll - Runs a SOQL query. It returns the results that are deleted because of a merge or delete. Also returns the  information about archived Task and Event records.
* getBlobField - Retrieves the specified blob field from an individual record.
* apexCall - Executes a user defined APEX REST API call.

For example, the following producer endpoint uses the upsertSObject API,
with the sObjectIdName parameter specifying 'Name' as the external id
field. 
The request message body should be an SObject DTO generated using the
maven plugin.  
The response message will either be `null` if an existing record was
updated, or `CreateSObjectResult` with an id of the new record, or a
list of errors while creating the new object.

[source,java]
----
...to(""salesforce:upsertSObject?sObjectIdName=Name"")...
----

=== Rest Bulk API

Producer endpoints can use the following APIs. All Job data formats,
i.e. xml, csv, zip/xml, and zip/csv are supported.  +
 The request and response have to be marshalled/unmarshalled by the
route. Usually the request will be some stream source like a CSV file,
 +
 and the response may also be saved to a file to be correlated with the
request.

You can use the following for `operationName`:

* createJob - Creates a Salesforce Bulk Job
* getJob - Gets a Job using its Salesforce Id
* closeJob - Closes a Job
* abortJob - Aborts a Job
* createBatch - Submits a Batch within a Bulk Job
* getBatch - Gets a Batch using Id
* getAllBatches - Gets all Batches for a Bulk Job Id
* getRequest - Gets Request data (XML/CSV) for a Batch
* getResults - Gets the results of the Batch when its complete
* createBatchQuery - Creates a Batch from an SOQL query
* getQueryResultIds - Gets a list of Result Ids for a Batch Query
* getQueryResult - Gets results for a Result Id
* getRecentReports - Gets up to 200 of the reports you most recently viewed by sending a GET request to the Report List resource.
* getReportDescription - Retrieves the report, report type, and related metadata for a report, either in a tabular or summary or matrix format.
* executeSyncReport - Runs a report synchronously with or without changing filters and returns the latest summary data.
* executeAsyncReport - Runs an instance of a report asynchronously with or without filters and returns the summary data with or without details.
* getReportInstances - Returns a list of instances for a report that you requested to be run asynchronously. Each item in the list is treated as a separate instance of the report.
* getReportResults: Contains the results of running a report.

For example, the following producer endpoint uses the createBatch API to
create a Job Batch. The in message must contain a body that can be converted into an
`InputStream` (usually UTF-8 CSV or XML content from a file, etc.) and
header fields 'jobId' for the Job and 'contentType' for the Job content
type, which can be XML, CSV, ZIP_XML or ZIP_CSV. The put message body
will contain `BatchInfo` on success, or throw a `SalesforceException` on
error.

[source,java]
----
...to(""salesforce:createBatchJob"")..
----

=== Rest Streaming API

Consumer endpoints can use the following syntax for streaming endpoints
to receive Salesforce notifications on create/update.

To create and subscribe to a topic

[source,java]
----
from(""salesforce:CamelTestTopic?notifyForFields=ALL&notifyForOperations=ALL&sObjectName=Merchandise__c&updateTopic=true&sObjectQuery=SELECT Id, Name FROM Merchandise__c"")...
----

To subscribe to an existing topic

[source,java]
----
from(""salesforce:CamelTestTopic&sObjectName=Merchandise__c"")...
----

=== Platform events

To emit a platform event use `createSObject` operation. And set the
message body can be JSON string or InputStream with key-value data --
in that case `sObjectName` needs to be set to the API name of the
event, or a class that extends from AbstractDTOBase with the
appropriate class name for the event.

For example using a DTO:

[source,java]
----
class Order_Event__e extends AbstractDTOBase {
  @JsonProperty(""OrderNumber"")
  private String orderNumber;
  // ... other properties and getters/setters
}

from(""timer:tick"")
    .process(exchange -> {
        final Message in = exchange.getIn();
        String orderNumber = ""ORD"" + String.valueOf(in.getHeader(Exchange.TIMER_COUNTER));
        Order_Event__e event = new Order_Event__e();
        event.setOrderNumber(orderNumber);
        in.setBody(event);
    })
    .to(""salesforce:createSObject"");
----

Or using JSON event data:

[source,java]
----
from(""timer:tick"")
    .process(exchange -> {
        final Message in = exchange.getIn();
        String orderNumber = ""ORD"" + String.valueOf(in.getHeader(Exchange.TIMER_COUNTER));
        in.setBody(""{\\""OrderNumber\\"":\\"""" + orderNumber + ""\\""}"");
    })
    .to(""salesforce:createSObject?sObjectName=Order_Event__e"");
----

To receive platform events use the consumer endpoint with the API name of
the platform event prefixed with `event/` (or `/event/`), e.g.:
`salesforce:events/Order_Event__e`. Processor consuming from that
endpoint will receive either `org.apache.camel.component.salesforce.api.dto.PlatformEvent`
object or `org.cometd.bayeux.Message` in the body depending on the
`rawPayload` being `false` or `true` respectively.

For example, in the simplest form to consume one event:

[source,java]
----
PlatformEvent event = consumer.receiveBody(""salesforce:event/Order_Event__e"", PlatformEvent.class);
----

=== Change data capture events

On the one hand, Salesforce could be configured to emit notifications for record changes of select objects.
On the other hand, the Camel Salesforce component could react to such notifications, allowing for instance to
https://trailhead.salesforce.com/en/content/learn/modules/change-data-capture/understand-change-data-capture[synchronize those changes into an external system].

The notifications of interest could be specified in the `from(""salesforce:XXX"")` clause of a Camel route via the subscription channel, e.g:

[source,java]
----
from(""salesforce:data/ChangeEvents?replayId=-1"").log(""being notified of all change events"")
from(""salesforce:data/AccountChangeEvent?replayId=-1"").log(""being notified of change events for Account records"")
from(""salesforce:data/Employee__ChangeEvent?replayId=-1"").log(""being notified of change events for Employee__c custom object"")
----

The received message contains either `java.util.Map<String,Object>` or `org.cometd.bayeux.Message` in the body depending on the `rawPayload` being `false` or `true` respectively. The `CamelSalesforceChangeType` header could be valued to one of `CREATE`, `UPDATE`,  `DELETE` or `UNDELETE`.

More details about how to use the Camel Salesforce component change data capture capabilities could be found in the https://github.com/apache/camel/tree/master/components/camel-salesforce/camel-salesforce-component/src/test/java/org/apache/camel/component/salesforce/ChangeEventsConsumerIntegrationTest.java[ChangeEventsConsumerIntegrationTest].

The https://developer.salesforce.com/docs/atlas.en-us.change_data_capture.meta/change_data_capture/cdc_intro.htm[Salesforce developer guide]
is a good fit to better know the subtleties of implementing a change data capture integration application.
The dynamic nature of change event body fields, high level replication steps as well as security considerations could be of interest.

== Examples

=== Uploading a document to a ContentWorkspace

Create the ContentVersion in Java, using a Processor instance:

[source,java]
----
public class ContentProcessor implements Processor {
    public void process(Exchange exchange) throws Exception {
        Message message = exchange.getIn();

        ContentVersion cv = new ContentVersion();
        ContentWorkspace cw = getWorkspace(exchange);
        cv.setFirstPublishLocationId(cw.getId());
        cv.setTitle(""test document"");
        cv.setPathOnClient(""test_doc.html"");
        byte[] document = message.getBody(byte[].class);
        ObjectMapper mapper = new ObjectMapper();
        String enc = mapper.convertValue(document, String.class);
        cv.setVersionDataUrl(enc);
        message.setBody(cv);
    }

    protected ContentWorkspace getWorkSpace(Exchange exchange) {
        // Look up the content workspace somehow, maybe use enrich() to add it to a
        // header that can be extracted here
        ....
    }
} 
----

Give the output from the processor to the Salesforce component:

[source,java]
----
from(""file:///home/camel/library"")
    .to(new ContentProcessor())     // convert bytes from the file into a ContentVersion SObject 
                                    // for the salesforce component
    .to(""salesforce:createSObject""); 
----

== Using Salesforce Limits API

With `salesforce:limits` operation you can fetch of API limits from Salesforce and then act upon that data received.
The result of `salesforce:limits` operation is mapped to `org.apache.camel.component.salesforce.api.dto.Limits`
class and can be used in a custom processors or expressions.

For instance, consider that you need to limit the API usage of Salesforce so that 10% of daily API requests is left for
other routes. The body of output message contains an instance of
`org.apache.camel.component.salesforce.api.dto.Limits` object that can be used in conjunction with
Content Based Router and Content Based Router and 
xref:spel-language.adoc[Spring Expression Language (SpEL)] to choose when to perform queries.

Notice how multiplying `1.0` with the integer value held in `body.dailyApiRequests.remaining` makes the expression
evaluate as with floating point arithmetic, without it - it would end up making integral division which would result
with either `0` (some API limits consumed) or `1` (no API limits consumed).

[source,java]
----
from(""direct:querySalesforce"")
    .to(""salesforce:limits"")
    .choice()
    .when(spel(""#{1.0 * body.dailyApiRequests.remaining / body.dailyApiRequests.max < 0.1}""))
        .to(""salesforce:query?..."")
    .otherwise()
        .setBody(constant(""Used up Salesforce API limits, leaving 10% for critical routes""))
    .endChoice()
----

== Working with approvals

All the properties are named exactly the same as in the Salesforce REST API prefixed with `approval.`. You can set
approval properties by setting `approval.PropertyName` of the Endpoint these will be used as template -- meaning
that any property not present in either body or header will be taken from the Endpoint configuration. Or you can set
the approval template on the Endpoint by assigning `approval` property to a reference onto a bean in the Registry.

You can also provide header values using the same `approval.PropertyName` in the incoming message headers.

And finally body can contain one `AprovalRequest` or an `Iterable` of `ApprovalRequest` objects to process as
a batch.

The important thing to remember is the priority of the values specified in these three mechanisms:

. value in body takes precedence before any other
. value in message header takes precedence before template value
. value in template is set if no other value in header or body was given

For example to send one record for approval using values in headers use:

Given a route:

[source,java]
----
from(""direct:example1"")//
        .setHeader(""approval.ContextId"", simple(""${body['contextId']}""))
        .setHeader(""approval.NextApproverIds"", simple(""${body['nextApproverIds']}""))
        .to(""salesforce:approval?""//
            + ""approval.actionType=Submit""//
            + ""&approval.comments=this is a test""//
            + ""&approval.processDefinitionNameOrId=Test_Account_Process""//
            + ""&approval.skipEntryCriteria=true"");
----

You could send a record for approval using:

[source,java]
----
final Map<String, String> body = new HashMap<>();
body.put(""contextId"", accountIds.iterator().next());
body.put(""nextApproverIds"", userId);

final ApprovalResult result = template.requestBody(""direct:example1"", body, ApprovalResult.class);
----

== Using Salesforce Recent Items API

To fetch the recent items use `salesforce:recent` operation. This operation returns an `java.util.List` of
`org.apache.camel.component.salesforce.api.dto.RecentItem` objects (`List<RecentItem>`) that in turn contain
the `Id`, `Name` and `Attributes` (with `type` and `url` properties). You can limit the number of returned items
by specifying `limit` parameter set to maximum number of records to return. For example:

[source,java]
----
from(""direct:fetchRecentItems"")
    to(""salesforce:recent"")
        .split().body()
            .log(""${body.name} at ${body.attributes.url}"");
----

== Using Salesforce Composite API to submit SObject tree

To create up to 200 records including parent-child relationships use `salesforce:composite-tree` operation. This
requires an instance of `org.apache.camel.component.salesforce.api.dto.composite.SObjectTree` in the input 
message and returns the same tree of objects in the output message. The 
`org.apache.camel.component.salesforce.api.dto.AbstractSObjectBase` instances within the tree get updated with
the identifier values (`Id` property) or their corresponding
`org.apache.camel.component.salesforce.api.dto.composite.SObjectNode` is populated with `errors` on failure.

Note that for some records operation can succeed and for some it can fail -- so you need to manually check for errors.

Easiest way to use this functionality is to use the DTOs generated by the `camel-salesforce-maven-plugin`, but you
also have the option of customizing the references that identify the each object in the tree, for instance primary keys
from your database.

Lets look at an example:

[source,java]
----
Account account = ...
Contact president = ...
Contact marketing = ...

Account anotherAccount = ...
Contact sales = ...
Asset someAsset = ...

// build the tree
SObjectTree request = new SObjectTree();
request.addObject(account).addChildren(president, marketing);
request.addObject(anotherAccount).addChild(sales).addChild(someAsset);

final SObjectTree response = template.requestBody(""salesforce:composite-tree"", tree, SObjectTree.class);
final Map<Boolean, List<SObjectNode>> result = response.allNodes()
                                                   .collect(Collectors.groupingBy(SObjectNode::hasErrors));

final List<SObjectNode> withErrors = result.get(true);
final List<SObjectNode> succeeded = result.get(false);

final String firstId = succeeded.get(0).getId();
----

== Using Salesforce Composite API to submit multiple requests in a batch
The Composite API batch operation (`composite-batch`) allows you to accumulate multiple requests in a batch and then
submit them in one go, saving the round trip cost of multiple individual requests. Each response is then received in a
list of responses with the order preserved, so that the n-th requests response is in the n-th place of the response.

NOTE: The results can vary from API to API so the result of the request is given as a `java.lang.Object`. In most cases
the result will be a `java.util.Map` with string keys and values or other `java.util.Map` as value. Requests made in
JSON format hold some type information (i.e. it is known what values are strings and what values are numbers), so in
general those will be more type friendly. Note that the responses will vary between XML and JSON, this is due to the
responses from Salesforce API being different. So be careful if you switch between formats without changing the response
handling code.

Lets look at an example:

[source,java]
----
final String acountId = ...
final SObjectBatch batch = new SObjectBatch(""38.0"");

final Account updates = new Account();
updates.setName(""NewName"");
batch.addUpdate(""Account"", accountId, updates);

final Account newAccount = new Account();
newAccount.setName(""Account created from Composite batch API"");
batch.addCreate(newAccount);

batch.addGet(""Account"", accountId, ""Name"", ""BillingPostalCode"");

batch.addDelete(""Account"", accountId);

final SObjectBatchResponse response = template.requestBody(""salesforce:composite-batch?format=JSON"", batch, SObjectBatchResponse.class);

boolean hasErrors = response.hasErrors(); // if any of the requests has resulted in either 4xx or 5xx HTTP status
final List<SObjectBatchResult> results = response.getResults(); // results of three operations sent in batch

final SObjectBatchResult updateResult = results.get(0); // update result
final int updateStatus = updateResult.getStatusCode(); // probably 204
final Object updateResultData = updateResult.getResult(); // probably null

final SObjectBatchResult createResult = results.get(1); // create result
@SuppressWarnings(""unchecked"")
final Map<String, Object> createData = (Map<String, Object>) createResult.getResult();
final String newAccountId = createData.get(""id""); // id of the new account, this is for JSON, for XML it would be createData.get(""Result"").get(""id"")

final SObjectBatchResult retrieveResult = results.get(2); // retrieve result
@SuppressWarnings(""unchecked"")
final Map<String, Object> retrieveData = (Map<String, Object>) retrieveResult.getResult();
final String accountName = retrieveData.get(""Name""); // Name of the retrieved account, this is for JSON, for XML it would be createData.get(""Account"").get(""Name"")
final String accountBillingPostalCode = retrieveData.get(""BillingPostalCode""); // Name of the retrieved account, this is for JSON, for XML it would be createData.get(""Account"").get(""BillingPostalCode"")

final SObjectBatchResult deleteResult = results.get(3); // delete result
final int updateStatus = deleteResult.getStatusCode(); // probably 204
final Object updateResultData = deleteResult.getResult(); // probably null
----

== Using Salesforce Composite API to submit multiple chained requests
The `composite` operation allows submitting up to 25 requests that can be chained together, for instance identifier
generated in previous request can be used in subsequent request. Individual requests and responses are linked with the
provided _reference_.

NOTE: Composite API supports only JSON payloads.

NOTE: As with the batch API the results can vary from API to API so the result of the request is given as a
`java.lang.Object`. In most cases the result will be a `java.util.Map` with string keys and values or other
`java.util.Map` as value. Requests made in JSON format hold some type information (i.e. it is known what values are
strings and what values are numbers), so in general those will be more type friendly.

Lets look at an example:

[source,java]
----
SObjectComposite composite = new SObjectComposite(""38.0"", true);

// first insert operation via an external id
final Account updateAccount = new TestAccount();
updateAccount.setName(""Salesforce"");
updateAccount.setBillingStreet(""Landmark @ 1 Market Street"");
updateAccount.setBillingCity(""San Francisco"");
updateAccount.setBillingState(""California"");
updateAccount.setIndustry(Account_IndustryEnum.TECHNOLOGY);
composite.addUpdate(""Account"", ""001xx000003DIpcAAG"", updateAccount, ""UpdatedAccount"");

final Contact newContact = new TestContact();
newContact.setLastName(""John Doe"");
newContact.setPhone(""1234567890"");
composite.addCreate(newContact, ""NewContact"");

final AccountContactJunction__c junction = new AccountContactJunction__c();
junction.setAccount__c(""001xx000003DIpcAAG"");
junction.setContactId__c(""@{NewContact.id}"");
composite.addCreate(junction, ""JunctionRecord"");

final SObjectCompositeResponse response = template.requestBody(""salesforce:composite?format=JSON"", composite, SObjectCompositeResponse.class);
final List<SObjectCompositeResult> results = response.getCompositeResponse();

final SObjectCompositeResult accountUpdateResult = results.stream().filter(r -> ""UpdatedAccount"".equals(r.getReferenceId())).findFirst().get()
final int statusCode = accountUpdateResult.getHttpStatusCode(); // should be 200
final Map<String, ?> accountUpdateBody = accountUpdateResult.getBody();

final SObjectCompositeResult contactCreationResult = results.stream().filter(r -> ""JunctionRecord"".equals(r.getReferenceId())).findFirst().get()
----

== Generating SOQL query strings

`org.apache.camel.component.salesforce.api.utils.QueryHelper` contains helper
methods to generate SOQL queries. For instance to fetch all custom fields from
_Account_ SObject you can simply generate the SOQL SELECT by invoking:

[source,java]
----
String allCustomFieldsQuery = QueryHelper.queryToFetchFilteredFieldsOf(new Account(), SObjectField::isCustom);
----

== Camel Salesforce Maven Plugin

This Maven plugin generates DTOs for the Camel. 

For obvious security reasons it is recommended that the clientId,
clientSecret, userName and password fields be not set in the pom.xml.  
The plugin should be configured for the rest of the properties, and can
be executed using the following command:

[source,java]
----
mvn camel-salesforce:generate -DcamelSalesforce.clientId=<clientid> -DcamelSalesforce.clientSecret=<clientsecret> \\
    -DcamelSalesforce.userName=<username> -DcamelSalesforce.password=<password>
----

The generated DTOs use Jackson and XStream annotations. All Salesforce
field types are supported. Date and time fields are mapped to
`java.time.ZonedDateTime` by default, and picklist fields are mapped to
generated Java Enumerations.

Please refer to
https://github.com/apache/camel/tree/master/components/camel-salesforce/camel-salesforce-maven-plugin[README.md]
for details on how to generate the DTO.

== Options







// component options: START
The Salesforce component supports 31 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *authenticationType* (security) | Explicit authentication method to be used, one of USERNAME_PASSWORD, REFRESH_TOKEN or JWT. Salesforce component can auto-determine the authentication method to use from the properties set, set this property to eliminate any ambiguity. |  | AuthenticationType
| *loginConfig* (security) | All authentication configuration in one nested bean, all properties set there can be set directly on the component as well |  | SalesforceLoginConfig
| *instanceUrl* (security) | URL of the Salesforce instance used after authentication, by default received from Salesforce on successful authentication |  | String
| *loginUrl* (security) | *Required* URL of the Salesforce instance used for authentication, by default set to \\https://login.salesforce.com | https://login.salesforce.com | String
| *clientId* (security) | *Required* OAuth Consumer Key of the connected app configured in the Salesforce instance setup. Typically a connected app needs to be configured but one can be provided by installing a package. |  | String
| *clientSecret* (security) | OAuth Consumer Secret of the connected app configured in the Salesforce instance setup. |  | String
| *keystore* (security) | KeyStore parameters to use in OAuth JWT flow. The KeyStore should contain only one entry with private key and certificate. Salesforce does not verify the certificate chain, so this can easily be a selfsigned certificate. Make sure that you upload the certificate to the corresponding connected app. |  | KeyStoreParameters
| *refreshToken* (security) | Refresh token already obtained in the refresh token OAuth flow. One needs to setup a web application and configure a callback URL to receive the refresh token, or configure using the builtin callback at \\https://login.salesforce.com/services/oauth2/success or \\https://test.salesforce.com/services/oauth2/success and then retrive the refresh_token from the URL at the end of the flow. Note that in development organizations Salesforce allows hosting the callback web application at localhost. |  | String
| *userName* (security) | Username used in OAuth flow to gain access to access token. It's easy to get started with password OAuth flow, but in general one should avoid it as it is deemed less secure than other flows. |  | String
| *password* (security) | Password used in OAuth flow to gain access to access token. It's easy to get started with password OAuth flow, but in general one should avoid it as it is deemed less secure than other flows. Make sure that you append security token to the end of the password if using one. |  | String
| *lazyLogin* (security) | If set to true prevents the component from authenticating to Salesforce with the start of the component. You would generally set this to the (default) false and authenticate early and be immediately aware of any authentication issues. | false | boolean
| *config* (common) | Global endpoint configuration - use to set values that are common to all endpoints |  | SalesforceEndpoint Config
| *httpClientProperties* (common) | Used to set any properties that can be configured on the underlying HTTP client. Have a look at properties of SalesforceHttpClient and the Jetty HttpClient for all available options. |  | Map
| *longPollingTransport Properties* (common) | Used to set any properties that can be configured on the LongPollingTransport used by the BayeuxClient (CometD) used by the streaming api |  | Map
| *sslContextParameters* (security) | SSL parameters to use, see SSLContextParameters class for all available options. |  | SSLContextParameters
| *useGlobalSslContext Parameters* (security) | Enable usage of global SSL context parameters | false | boolean
| *httpClientIdleTimeout* (common) | Timeout used by the HttpClient when waiting for response from the Salesforce server. | 10000 | long
| *httpClientConnection Timeout* (common) | Connection timeout used by the HttpClient when connecting to the Salesforce server. | 60000 | long
| *httpProxyHost* (proxy) | Hostname of the HTTP proxy server to use. |  | String
| *httpProxyPort* (proxy) | Port number of the HTTP proxy server to use. |  | Integer
| *httpProxyUsername* (security) | Username to use to authenticate against the HTTP proxy server. |  | String
| *httpProxyPassword* (security) | Password to use to authenticate against the HTTP proxy server. |  | String
| *isHttpProxySocks4* (proxy) | If set to true the configures the HTTP proxy to use as a SOCKS4 proxy. | false | boolean
| *isHttpProxySecure* (security) | If set to false disables the use of TLS when accessing the HTTP proxy. | true | boolean
| *httpProxyIncluded Addresses* (proxy) | A list of addresses for which HTTP proxy server should be used. |  | Set
| *httpProxyExcluded Addresses* (proxy) | A list of addresses for which HTTP proxy server should not be used. |  | Set
| *httpProxyAuthUri* (security) | Used in authentication against the HTTP proxy server, needs to match the URI of the proxy server in order for the httpProxyUsername and httpProxyPassword to be used for authentication. |  | String
| *httpProxyRealm* (security) | Realm of the proxy server, used in preemptive Basic/Digest authentication methods against the HTTP proxy server. |  | String
| *httpProxyUseDigest Auth* (security) | If set to true Digest authentication will be used when authenticating to the HTTP proxy,otherwise Basic authorization method will be used | false | boolean
| *packages* (common) | In what packages are the generated DTO classes. Typically the classes would be generated using camel-salesforce-maven-plugin. Set it if using the generated DTOs to gain the benefit of using short SObject names in parameters/header values. |  | String[]
| *basicPropertyBinding* (advanced) | Whether the component should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
|===
// component options: END










// endpoint options: START
The Salesforce endpoint is configured using URI syntax:

----
salesforce:operationName:topicName
----

with the following path and query parameters:

=== Path Parameters (2 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *operationName* | The operation to use |  | OperationName
| *topicName* | The name of the topic/channel to use |  | String
|===


=== Query Parameters (46 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *apexMethod* (common) | APEX method name |  | String
| *apexQueryParams* (common) | Query params for APEX method |  | Map
| *apexUrl* (common) | APEX method URL |  | String
| *apiVersion* (common) | Salesforce API version, defaults to SalesforceEndpointConfig.DEFAULT_VERSION |  | String
| *backoffIncrement* (common) | Backoff interval increment for Streaming connection restart attempts for failures beyond CometD auto-reconnect. |  | long
| *batchId* (common) | Bulk API Batch ID |  | String
| *contentType* (common) | Bulk API content type, one of XML, CSV, ZIP_XML, ZIP_CSV |  | ContentType
| *defaultReplayId* (common) | Default replayId setting if no value is found in initialReplayIdMap |  | Long
| *format* (common) | Payload format to use for Salesforce API calls, either JSON or XML, defaults to JSON |  | PayloadFormat
| *httpClient* (common) | Custom Jetty Http Client to use to connect to Salesforce. |  | SalesforceHttpClient
| *includeDetails* (common) | Include details in Salesforce1 Analytics report, defaults to false. |  | Boolean
| *initialReplayIdMap* (common) | Replay IDs to start from per channel name. |  | Map
| *instanceId* (common) | Salesforce1 Analytics report execution instance ID |  | String
| *jobId* (common) | Bulk API Job ID |  | String
| *limit* (common) | Limit on number of returned records. Applicable to some of the API, check the Salesforce documentation. |  | Integer
| *maxBackoff* (common) | Maximum backoff interval for Streaming connection restart attempts for failures beyond CometD auto-reconnect. |  | long
| *notFoundBehaviour* (common) | Sets the behaviour of 404 not found status received from Salesforce API. Should the body be set to NULL NotFoundBehaviour#NULL or should a exception be signaled on the exchange NotFoundBehaviour#EXCEPTION - the default. |  | NotFoundBehaviour
| *notifyForFields* (common) | Notify for fields, options are ALL, REFERENCED, SELECT, WHERE |  | NotifyForFieldsEnum
| *notifyForOperationCreate* (common) | Notify for create operation, defaults to false (API version = 29.0) |  | Boolean
| *notifyForOperationDelete* (common) | Notify for delete operation, defaults to false (API version = 29.0) |  | Boolean
| *notifyForOperations* (common) | Notify for operations, options are ALL, CREATE, EXTENDED, UPDATE (API version 29.0) |  | NotifyForOperations Enum
| *notifyForOperationUndelete* (common) | Notify for un-delete operation, defaults to false (API version = 29.0) |  | Boolean
| *notifyForOperationUpdate* (common) | Notify for update operation, defaults to false (API version = 29.0) |  | Boolean
| *objectMapper* (common) | Custom Jackson ObjectMapper to use when serializing/deserializing Salesforce objects. |  | ObjectMapper
| *rawPayload* (common) | Use raw payload String for request and response (either JSON or XML depending on format), instead of DTOs, false by default | false | boolean
| *reportId* (common) | Salesforce1 Analytics report Id |  | String
| *reportMetadata* (common) | Salesforce1 Analytics report metadata for filtering |  | ReportMetadata
| *resultId* (common) | Bulk API Result ID |  | String
| *serializeNulls* (common) | Should the NULL values of given DTO be serialized with empty (NULL) values. This affects only JSON data format. | false | boolean
| *sObjectBlobFieldName* (common) | SObject blob field name |  | String
| *sObjectClass* (common) | Fully qualified SObject class name, usually generated using camel-salesforce-maven-plugin |  | String
| *sObjectFields* (common) | SObject fields to retrieve |  | String
| *sObjectId* (common) | SObject ID if required by API |  | String
| *sObjectIdName* (common) | SObject external ID field name |  | String
| *sObjectIdValue* (common) | SObject external ID field value |  | String
| *sObjectName* (common) | SObject name if required or supported by API |  | String
| *sObjectQuery* (common) | Salesforce SOQL query string |  | String
| *sObjectSearch* (common) | Salesforce SOSL search string |  | String
| *updateTopic* (common) | Whether to update an existing Push Topic when using the Streaming API, defaults to false | false | boolean
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *replayId* (consumer) | The replayId value to use when subscribing |  | Long
| *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the consumer will deal with exceptions, that will be logged at WARN or ERROR level and ignored. |  | ExceptionHandler
| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. |  | ExchangePattern
| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. | false | boolean
| *basicPropertyBinding* (advanced) | Whether the endpoint should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported). | false | boolean
|===
// endpoint options: END
// spring-boot-auto-configure options: START
== Spring Boot Auto-Configuration

When using Spring Boot make sure to use the following Maven dependency to have support for auto configuration:

[source,xml]
----
<dependency>
  <groupId>org.apache.camel</groupId>
  <artifactId>camel-salesforce-starter</artifactId>
  <version>x.x.x</version>
  <!-- use the same version as your Camel core version -->
</dependency>
----


The component supports 87 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *camel.component.salesforce.authentication-type* | Explicit authentication method to be used, one of USERNAME_PASSWORD, REFRESH_TOKEN or JWT. Salesforce component can auto-determine the authentication method to use from the properties set, set this property to eliminate any ambiguity. |  | AuthenticationType
| *camel.component.salesforce.basic-property-binding* | Whether the component should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | Boolean
| *camel.component.salesforce.client-id* | OAuth Consumer Key of the connected app configured in the Salesforce instance setup. Typically a connected app needs to be configured but one can be provided by installing a package. |  | String
| *camel.component.salesforce.client-secret* | OAuth Consumer Secret of the connected app configured in the Salesforce instance setup. |  | String
| *camel.component.salesforce.config.apex-method* | APEX method name |  | String
| *camel.component.salesforce.config.apex-query-params* | Query params for APEX method |  | Map
| *camel.component.salesforce.config.apex-url* | APEX method URL |  | String
| *camel.component.salesforce.config.api-version* | Salesforce API version, defaults to SalesforceEndpointConfig.DEFAULT_VERSION |  | String
| *camel.component.salesforce.config.approval* | The approval request for Approval API. |  | ApprovalRequest
| *camel.component.salesforce.config.approval-action-type* | Represents the kind of action to take: Submit, Approve, or Reject. |  | ApprovalRequest$Action
| *camel.component.salesforce.config.approval-comments* | The comment to add to the history step associated with this request. |  | String
| *camel.component.salesforce.config.approval-context-actor-id* | The ID of the submitter who’s requesting the approval record. |  | String
| *camel.component.salesforce.config.approval-context-id* | The ID of the item that is being acted upon. |  | String
| *camel.component.salesforce.config.approval-next-approver-ids* | If the process requires specification of the next approval, the ID of the user to be assigned the next request. |  | List
| *camel.component.salesforce.config.approval-process-definition-name-or-id* | The developer name or ID of the process definition. |  | String
| *camel.component.salesforce.config.approval-skip-entry-criteria* | Determines whether to evaluate the entry criteria for the process (true) or not (false) if the process definition name or ID isn’t null. If the process definition name or ID isn’t specified, this argument is ignored, and standard evaluation is followed based on process order. By default, the entry criteria isn’t skipped if it’s not set by this request. |  | Boolean
| *camel.component.salesforce.config.backoff-increment* | Backoff interval increment for Streaming connection restart attempts for failures beyond CometD auto-reconnect. |  | Long
| *camel.component.salesforce.config.batch-id* | Bulk API Batch ID |  | String
| *camel.component.salesforce.config.content-type* | Bulk API content type, one of XML, CSV, ZIP_XML, ZIP_CSV |  | ContentType
| *camel.component.salesforce.config.default-replay-id* | Default replayId setting if no value is found in {@link #initialReplayIdMap} |  | Long
| *camel.component.salesforce.config.format* | Payload format to use for Salesforce API calls, either JSON or XML, defaults to JSON |  | PayloadFormat
| *camel.component.salesforce.config.http-client* | Custom Jetty Http Client to use to connect to Salesforce. |  | SalesforceHttpClient
| *camel.component.salesforce.config.include-details* | Include details in Salesforce1 Analytics report, defaults to false. |  | Boolean
| *camel.component.salesforce.config.initial-replay-id-map* | Replay IDs to start from per channel name. |  | Map
| *camel.component.salesforce.config.instance-id* | Salesforce1 Analytics report execution instance ID |  | String
| *camel.component.salesforce.config.job-id* | Bulk API Job ID |  | String
| *camel.component.salesforce.config.limit* | Limit on number of returned records. Applicable to some of the API, check the Salesforce documentation. |  | Integer
| *camel.component.salesforce.config.max-backoff* | Maximum backoff interval for Streaming connection restart attempts for failures beyond CometD auto-reconnect. |  | Long
| *camel.component.salesforce.config.not-found-behaviour* | Sets the behaviour of 404 not found status received from Salesforce API. Should the body be set to NULL {@link NotFoundBehaviour#NULL} or should a exception be signaled on the exchange {@link NotFoundBehaviour#EXCEPTION} - the default. |  | NotFoundBehaviour
| *camel.component.salesforce.config.notify-for-fields* | Notify for fields, options are ALL, REFERENCED, SELECT, WHERE |  | NotifyForFieldsEnum
| *camel.component.salesforce.config.notify-for-operation-create* | Notify for create operation, defaults to false (API version >= 29.0) |  | Boolean
| *camel.component.salesforce.config.notify-for-operation-delete* | Notify for delete operation, defaults to false (API version >= 29.0) |  | Boolean
| *camel.component.salesforce.config.notify-for-operation-undelete* | Notify for un-delete operation, defaults to false (API version >= 29.0) |  | Boolean
| *camel.component.salesforce.config.notify-for-operation-update* | Notify for update operation, defaults to false (API version >= 29.0) |  | Boolean
| *camel.component.salesforce.config.notify-for-operations* | Notify for operations, options are ALL, CREATE, EXTENDED, UPDATE (API version < 29.0) |  | NotifyForOperations Enum
| *camel.component.salesforce.config.object-mapper* | Custom Jackson ObjectMapper to use when serializing/deserializing Salesforce objects. |  | ObjectMapper
| *camel.component.salesforce.config.raw-payload* | Use raw payload {@link String} for request and response (either JSON or XML depending on {@code format}), instead of DTOs, false by default | false | Boolean
| *camel.component.salesforce.config.report-id* | Salesforce1 Analytics report Id |  | String
| *camel.component.salesforce.config.report-metadata* | Salesforce1 Analytics report metadata for filtering |  | ReportMetadata
| *camel.component.salesforce.config.result-id* | Bulk API Result ID |  | String
| *camel.component.salesforce.config.s-object-blob-field-name* | SObject blob field name |  | String
| *camel.component.salesforce.config.s-object-class* | Fully qualified SObject class name, usually generated using camel-salesforce-maven-plugin |  | String
| *camel.component.salesforce.config.s-object-fields* | SObject fields to retrieve |  | String
| *camel.component.salesforce.config.s-object-id* | SObject ID if required by API |  | String
| *camel.component.salesforce.config.s-object-id-name* | SObject external ID field name |  | String
| *camel.component.salesforce.config.s-object-id-value* | SObject external ID field value |  | String
| *camel.component.salesforce.config.s-object-name* | SObject name if required or supported by API |  | String
| *camel.component.salesforce.config.s-object-query* | Salesforce SOQL query string |  | String
| *camel.component.salesforce.config.s-object-search* | Salesforce SOSL search string |  | String
| *camel.component.salesforce.config.serialize-nulls* | Should the NULL values of given DTO be serialized with empty (NULL) values. This affects only JSON data format. | false | Boolean
| *camel.component.salesforce.config.update-topic* | Whether to update an existing Push Topic when using the Streaming API, defaults to false | false | Boolean
| *camel.component.salesforce.enabled* | Enable salesforce component | true | Boolean
| *camel.component.salesforce.http-client-connection-timeout* | Connection timeout used by the HttpClient when connecting to the Salesforce server. | 60000 | Long
| *camel.component.salesforce.http-client-idle-timeout* | Timeout used by the HttpClient when waiting for response from the Salesforce server. | 10000 | Long
| *camel.component.salesforce.http-client-properties* | Used to set any properties that can be configured on the underlying HTTP client. Have a look at properties of SalesforceHttpClient and the Jetty HttpClient for all available options. |  | Map
| *camel.component.salesforce.http-proxy-auth-uri* | Used in authentication against the HTTP proxy server, needs to match the URI of the proxy server in order for the httpProxyUsername and httpProxyPassword to be used for authentication. |  | String
| *camel.component.salesforce.http-proxy-excluded-addresses* | A list of addresses for which HTTP proxy server should not be used. |  | Set
| *camel.component.salesforce.http-proxy-host* | Hostname of the HTTP proxy server to use. |  | String
| *camel.component.salesforce.http-proxy-included-addresses* | A list of addresses for which HTTP proxy server should be used. |  | Set
| *camel.component.salesforce.http-proxy-password* | Password to use to authenticate against the HTTP proxy server. |  | String
| *camel.component.salesforce.http-proxy-port* | Port number of the HTTP proxy server to use. |  | Integer
| *camel.component.salesforce.http-proxy-realm* | Realm of the proxy server, used in preemptive Basic/Digest authentication methods against the HTTP proxy server. |  | String
| *camel.component.salesforce.http-proxy-use-digest-auth* | If set to true Digest authentication will be used when authenticating to the HTTP proxy,otherwise Basic authorization method will be used | false | Boolean
| *camel.component.salesforce.http-proxy-username* | Username to use to authenticate against the HTTP proxy server. |  | String
| *camel.component.salesforce.instance-url* | URL of the Salesforce instance used after authentication, by default received from Salesforce on successful authentication |  | String
| *camel.component.salesforce.is-http-proxy-secure* | If set to false disables the use of TLS when accessing the HTTP proxy. | true | Boolean
| *camel.component.salesforce.is-http-proxy-socks4* | If set to true the configures the HTTP proxy to use as a SOCKS4 proxy. | false | Boolean
| *camel.component.salesforce.keystore* | KeyStore parameters to use in OAuth JWT flow. The KeyStore should contain only one entry with private key and certificate. Salesforce does not verify the certificate chain, so this can easily be a selfsigned certificate. Make sure that you upload the certificate to the corresponding connected app. The option is a org.apache.camel.support.jsse.KeyStoreParameters type. |  | String
| *camel.component.salesforce.lazy-login* | If set to true prevents the component from authenticating to Salesforce with the start of the component. You would generally set this to the (default) false and authenticate early and be immediately aware of any authentication issues. | false | Boolean
| *camel.component.salesforce.login-config.client-id* | Salesforce connected application Consumer Key |  | String
| *camel.component.salesforce.login-config.client-secret* | Salesforce connected application Consumer Secret |  | String
| *camel.component.salesforce.login-config.instance-url* | Configuration object for Salesforce login properties |  | String
| *camel.component.salesforce.login-config.keystore* | Keystore parameters for keystore containing certificate and private key needed for OAuth 2.0 JWT Bearer Token Flow. |  | KeyStoreParameters
| *camel.component.salesforce.login-config.lazy-login* | Flag to enable/disable lazy OAuth, default is false. When enabled, OAuth token retrieval or generation is not done until the first API call | false | Boolean
| *camel.component.salesforce.login-config.login-url* | Salesforce login URL, defaults to \\https://login.salesforce.com | https://login.salesforce.com | String
| *camel.component.salesforce.login-config.password* | Salesforce account password |  | String
| *camel.component.salesforce.login-config.refresh-token* | Salesforce connected application Consumer token |  | String
| *camel.component.salesforce.login-config.type* | Salesforce connected application Consumer token |  | AuthenticationType
| *camel.component.salesforce.login-config.user-name* | Salesforce account user name |  | String
| *camel.component.salesforce.login-url* | URL of the Salesforce instance used for authentication, by default set to \\https://login.salesforce.com | https://login.salesforce.com | String
| *camel.component.salesforce.long-polling-transport-properties* | Used to set any properties that can be configured on the LongPollingTransport used by the BayeuxClient (CometD) used by the streaming api |  | Map
| *camel.component.salesforce.packages* | In what packages are the generated DTO classes. Typically the classes would be generated using camel-salesforce-maven-plugin. Set it if using the generated DTOs to gain the benefit of using short SObject names in parameters/header values. |  | String[]
| *camel.component.salesforce.password* | Password used in OAuth flow to gain access to access token. It's easy to get started with password OAuth flow, but in general one should avoid it as it is deemed less secure than other flows. Make sure that you append security token to the end of the password if using one. |  | String
| *camel.component.salesforce.refresh-token* | Refresh token already obtained in the refresh token OAuth flow. One needs to setup a web application and configure a callback URL to receive the refresh token, or configure using the builtin callback at \\https://login.salesforce.com/services/oauth2/success or \\https://test.salesforce.com/services/oauth2/success and then retrive the refresh_token from the URL at the end of the flow. Note that in development organizations Salesforce allows hosting the callback web application at localhost. |  | String
| *camel.component.salesforce.ssl-context-parameters* | SSL parameters to use, see SSLContextParameters class for all available options. The option is a org.apache.camel.support.jsse.SSLContextParameters type. |  | String
| *camel.component.salesforce.use-global-ssl-context-parameters* | Enable usage of global SSL context parameters | false | Boolean
| *camel.component.salesforce.user-name* | Username used in OAuth flow to gain access to access token. It's easy to get started with password OAuth flow, but in general one should avoid it as it is deemed less secure than other flows. |  | String
|===
// spring-boot-auto-configure options: END
",12146,False,2166.0039679867405,median
"#include ""Library.h""
#include <stdio.h>
#include ""d3dx12.h""
#include ""imgui/imgui.h""
#include ""meow_hash_x64_aesni.h""
#include ""cgltf.h""
#include ""stb_image.h""
#include ""CPUAndGPUCommon.h""

#define mz_MAX_NUM_RESOURCES 256
#define mz_MAX_NUM_PIPELINES 64

struct mz_UIFrameResources
{
	ID3D12Resource* VertexBuffer;
	ID3D12Resource* IndexBuffer;
	void* VertexBufferCPUAddress;
	void* IndexBufferCPUAddress;
	uint32_t VertexBufferSize;
	uint32_t IndexBufferSize;
	D3D12_VERTEX_BUFFER_VIEW VertexBufferView;
	D3D12_INDEX_BUFFER_VIEW IndexBufferView;
};

struct mz_UIContext
{
	mz_DX12PipelineState* PipelineState;
	ID3D12Resource* Font;
	D3D12_CPU_DESCRIPTOR_HANDLE FontSRV;
	mz_UIFrameResources Frames[2];
};

struct mz_MipmapGenerator
{
	mz_DX12PipelineState* Pipeline;
	mz_DX12Resource* ScratchTextures[4];
	D3D12_CPU_DESCRIPTOR_HANDLE ScratchTexturesBaseUAV;
	DXGI_FORMAT Format;
};

static void mz_CreateHeaps(mz_GraphicsContext* Gfx);

void* operator new(size_t Size)
{
	return mz_MALLOC(Size);
}

void* operator new[](size_t Size)
{
	return mz_MALLOC(Size);
}

void operator delete(void* P)
{
	mz_FREE(P);
}

void operator delete[](void* P)
{
	mz_FREE(P);
}

void* operator new[](size_t Size, const char* /*Name*/, int /*Flags*/, unsigned /*DebugFlags*/, const char* /*File*/, int /*Line*/)
{
	return mz_MALLOC(Size);
}

void* operator new[](size_t Size, size_t Alignment, size_t AlignmentOffset, const char* /*Name*/, int /*Flags*/, unsigned /*DebugFlags*/, const char* /*File*/, int /*Line*/)
{
	return mz_MALLOC_ALIGNED_OFFSET(Size, Alignment, AlignmentOffset);
}

mz_GraphicsContext*
mz_CreateGraphicsContext(HWND Window, bool bShouldCreateDepthBuffer)
{
	static mz_GraphicsContext Gfx = {};

	if (Gfx.Device != nullptr)
	{
		return &Gfx;
	}

	IDXGIFactory4* Factory;
#ifdef _DEBUG
	mz_VHR(CreateDXGIFactory2(DXGI_CREATE_FACTORY_DEBUG, IID_PPV_ARGS(&Factory)));
#else
	mz_VHR(CreateDXGIFactory2(0, IID_PPV_ARGS(&Factory)));
#endif
#ifdef _DEBUG
	{
		ID3D12Debug* Dbg;
		D3D12GetDebugInterface(IID_PPV_ARGS(&Dbg));
		if (Dbg)
		{
			Dbg->EnableDebugLayer();
			ID3D12Debug1* Dbg1;
			Dbg->QueryInterface(IID_PPV_ARGS(&Dbg1));
			if (Dbg1)
			{
				Dbg1->SetEnableGPUBasedValidation(FALSE);
			}
			mz_SAFE_RELEASE(Dbg);
			mz_SAFE_RELEASE(Dbg1);
		}
	}
#endif
	if (FAILED(D3D12CreateDevice(nullptr, D3D_FEATURE_LEVEL_12_1, IID_PPV_ARGS(&Gfx.Device))))
	{
		MessageBox(Window, ""This application requires Windows 10 (May 2019) or newer and GPU with raytracing support."", ""D3D12CreateDevice failed"", MB_OK | MB_ICONERROR);
		exit(0);
	}

	Gfx.Window = Window;

	D3D12_COMMAND_QUEUE_DESC CmdQueueDesc = {};
	CmdQueueDesc.Flags = D3D12_COMMAND_QUEUE_FLAG_NONE;
	CmdQueueDesc.Priority = D3D12_COMMAND_QUEUE_PRIORITY_NORMAL;
	CmdQueueDesc.Type = D3D12_COMMAND_LIST_TYPE_DIRECT;
	mz_VHR(Gfx.Device->CreateCommandQueue(&CmdQueueDesc, IID_PPV_ARGS(&Gfx.CmdQueue)));

	DXGI_SWAP_CHAIN_DESC SwapChainDesc = {};
	SwapChainDesc.BufferCount = 4;
	SwapChainDesc.BufferDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
	SwapChainDesc.BufferUsage = DXGI_USAGE_RENDER_TARGET_OUTPUT;
	SwapChainDesc.OutputWindow = Window;
	SwapChainDesc.SampleDesc.Count = 1;
	SwapChainDesc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
	SwapChainDesc.Windowed = TRUE;

	IDXGISwapChain* TempSwapChain;
	mz_VHR(Factory->CreateSwapChain(Gfx.CmdQueue, &SwapChainDesc, &TempSwapChain));
	mz_VHR(TempSwapChain->QueryInterface(IID_PPV_ARGS(&Gfx.SwapChain)));
	mz_SAFE_RELEASE(TempSwapChain);
	mz_SAFE_RELEASE(Factory);

	Gfx.Resources = (mz_DX12Resource*)mz_MALLOC(mz_MAX_NUM_RESOURCES * sizeof(mz_DX12Resource));
	memset(Gfx.Resources, 0, mz_MAX_NUM_RESOURCES * sizeof(mz_DX12Resource));

	Gfx.Pipelines = (mz_DX12PipelineState*)mz_MALLOC(mz_MAX_NUM_PIPELINES * sizeof(mz_DX12PipelineState));
	memset(Gfx.Pipelines, 0, mz_MAX_NUM_PIPELINES * sizeof(mz_DX12PipelineState));

	RECT Rect;
	GetClientRect(Window, &Rect);
	Gfx.Resolution[0] = (uint32_t)Rect.right;
	Gfx.Resolution[1] = (uint32_t)Rect.bottom;

	for (uint32_t Idx = 0; Idx < 2; ++Idx)
	{
		mz_VHR(Gfx.Device->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&Gfx.CmdAlloc[Idx])));
	}

	Gfx.DescriptorSize = Gfx.Device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
	Gfx.DescriptorSizeRTV = Gfx.Device->GetDescriptorHandleIncrementSize(D3D12_DESCRIPTOR_HEAP_TYPE_RTV);

	mz_CreateHeaps(&Gfx);

	// Swap-buffer render targets.
	{
		D3D12_CPU_DESCRIPTOR_HANDLE Handle = mz_AllocateDescriptors(&Gfx, D3D12_DESCRIPTOR_HEAP_TYPE_RTV, 4);

		for (uint32_t Idx = 0; Idx < 4; ++Idx)
		{
			{
				ID3D12Resource* Buffer;
				mz_VHR(Gfx.SwapChain->GetBuffer(Idx, IID_PPV_ARGS(&Buffer)));
				Gfx.SwapBuffers[Idx] = mz_AddDX12Resource(&Gfx, Buffer, D3D12_RESOURCE_STATE_PRESENT, SwapChainDesc.BufferDesc.Format);
			}
			Gfx.Device->CreateRenderTargetView(Gfx.SwapBuffers[Idx]->Raw, nullptr, Handle);
			Handle.ptr += Gfx.DescriptorSizeRTV;
		}
	}

	// Depth-stencil target.
	if (bShouldCreateDepthBuffer)
	{
		auto ImageDesc = CD3DX12_RESOURCE_DESC::Tex2D(DXGI_FORMAT_D32_FLOAT, Gfx.Resolution[0], Gfx.Resolution[1], 1, 1);
		ImageDesc.Flags = D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL | D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE;

		Gfx.DepthStencilBuffer = mz_CreateCommittedResource(&Gfx, D3D12_HEAP_TYPE_DEFAULT, D3D12_HEAP_FLAG_NONE, &ImageDesc, D3D12_RESOURCE_STATE_DEPTH_WRITE, &CD3DX12_CLEAR_VALUE(DXGI_FORMAT_D32_FLOAT, 1.0f, 0));

		D3D12_CPU_DESCRIPTOR_HANDLE Handle = mz_AllocateDescriptors(&Gfx, D3D12_DESCRIPTOR_HEAP_TYPE_DSV, 1);

		D3D12_DEPTH_STENCIL_VIEW_DESC ViewDesc = {};
		ViewDesc.Format = DXGI_FORMAT_D32_FLOAT;
		ViewDesc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2D;
		ViewDesc.Flags = D3D12_DSV_FLAG_NONE;
		Gfx.Device->CreateDepthStencilView(Gfx.DepthStencilBuffer->Raw, &ViewDesc, Handle);
	}

	mz_VHR(Gfx.Device->CreateCommandList(0, D3D12_COMMAND_LIST_TYPE_DIRECT, Gfx.CmdAlloc[0], nullptr, IID_PPV_ARGS(&Gfx.CmdList)));
	mz_VHR(Gfx.CmdList->Close());

	mz_VHR(Gfx.Device->CreateFence(0, D3D12_FENCE_FLAG_NONE, IID_PPV_ARGS(&Gfx.FrameFence)));
	Gfx.FrameFenceEvent = CreateEventEx(nullptr, nullptr, 0, EVENT_ALL_ACCESS);

	mz_CmdInit(&Gfx);

	return &Gfx;
}

void
mz_DestroyGraphicsContext(mz_GraphicsContext* Gfx)
{
	mz_ASSERT(Gfx);
	CloseHandle(Gfx->FrameFenceEvent);
	for (uint32_t Idx = 0; Idx < mz_MAX_NUM_RESOURCES; ++Idx)
	{
		mz_ReleaseResource(&Gfx->Resources[Idx]);
	}
	for (uint32_t Idx = 0; Idx < mz_MAX_NUM_PIPELINES; ++Idx)
	{
		mz_SAFE_RELEASE(Gfx->Pipelines[Idx].PSO);
		mz_SAFE_RELEASE(Gfx->Pipelines[Idx].RS);
	}
	Gfx->GraphicsPipelinesMap.clear();
	Gfx->ComputePipelinesMap.clear();
	mz_SAFE_RELEASE(Gfx->CmdList);
	mz_SAFE_RELEASE(Gfx->RTVHeap.Heap);
	mz_SAFE_RELEASE(Gfx->DSVHeap.Heap);
	for (uint32_t Idx = 0; Idx < 2; ++Idx)
	{
		mz_SAFE_RELEASE(Gfx->CmdAlloc[Idx]);
		mz_SAFE_RELEASE(Gfx->GPUDescriptorHeaps[Idx].Heap);
		mz_SAFE_RELEASE(Gfx->GPUUploadMemoryHeaps[Idx].Heap);
	}
	mz_SAFE_RELEASE(Gfx->CPUDescriptorHeap.Heap);
	mz_ReleaseResource(Gfx->DepthStencilBuffer);
	mz_SAFE_RELEASE(Gfx->FrameFence);
	mz_SAFE_RELEASE(Gfx->SwapChain);
	mz_SAFE_RELEASE(Gfx->CmdQueue);
	mz_SAFE_RELEASE(Gfx->Device);
	mz_FREE(Gfx->Pipelines);
	mz_FREE(Gfx->Resources);
}

void
mz_PresentFrame(mz_GraphicsContext* Gfx, uint32_t SwapInterval)
{
	Gfx->SwapChain->Present(SwapInterval, 0);
	Gfx->CmdQueue->Signal(Gfx->FrameFence, ++Gfx->NumFrames);

	uint64_t GPUFrameCount = Gfx->FrameFence->GetCompletedValue();

	if ((Gfx->NumFrames - GPUFrameCount) >= 2)
	{
		Gfx->FrameFence->SetEventOnCompletion(GPUFrameCount + 1, Gfx->FrameFenceEvent);
		WaitForSingleObject(Gfx->FrameFenceEvent, INFINITE);
	}

	Gfx->FrameIndex = !Gfx->FrameIndex;
	Gfx->BackBufferIndex = Gfx->SwapChain->GetCurrentBackBufferIndex();
	Gfx->GPUDescriptorHeaps[Gfx->FrameIndex].Size = 0;
	Gfx->GPUUploadMemoryHeaps[Gfx->FrameIndex].Size = 0;
}

void
mz_WaitForGPU(mz_GraphicsContext* Gfx)
{
	Gfx->CmdQueue->Signal(Gfx->FrameFence, ++Gfx->NumFrames);
	Gfx->FrameFence->SetEventOnCompletion(Gfx->NumFrames, Gfx->FrameFenceEvent);
	WaitForSingleObject(Gfx->FrameFenceEvent, INFINITE);

	Gfx->GPUDescriptorHeaps[Gfx->FrameIndex].Size = 0;
	Gfx->GPUUploadMemoryHeaps[Gfx->FrameIndex].Size = 0;
}

mz_DescriptorHeap*
mz_GetDescriptorHeap(mz_GraphicsContext* Gfx, D3D12_DESCRIPTOR_HEAP_TYPE Type, D3D12_DESCRIPTOR_HEAP_FLAGS Flags, uint32_t* DescriptorSize)
{
	if (Type == D3D12_DESCRIPTOR_HEAP_TYPE_RTV)
	{
		*DescriptorSize = Gfx->DescriptorSizeRTV;
		return &Gfx->RTVHeap;
	}
	else if (Type == D3D12_DESCRIPTOR_HEAP_TYPE_DSV)
	{
		*DescriptorSize = Gfx->DescriptorSizeRTV;
		return &Gfx->DSVHeap;
	}
	else if (Type == D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV)
	{
		*DescriptorSize = Gfx->DescriptorSize;
		if (Flags == D3D12_DESCRIPTOR_HEAP_FLAG_NONE)
		{
			return &Gfx->CPUDescriptorHeap;
		}
		else if (Flags == D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE)
		{
			return &Gfx->GPUDescriptorHeaps[Gfx->FrameIndex];
		}
	}
	mz_ASSERT(0);
	*DescriptorSize = 0;
	return &Gfx->CPUDescriptorHeap;
}

static void
mz_CreateHeaps(mz_GraphicsContext* Gfx)
{
	// Render target descriptor heap (RTV).
	{
		Gfx->RTVHeap.Capacity = 1024;

		D3D12_DESCRIPTOR_HEAP_DESC HeapDesc = {};
		HeapDesc.NumDescriptors = Gfx->RTVHeap.Capacity;
		HeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_RTV;
		HeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
		mz_VHR(Gfx->Device->CreateDescriptorHeap(&HeapDesc, IID_PPV_ARGS(&Gfx->RTVHeap.Heap)));
		Gfx->RTVHeap.CPUStart = Gfx->RTVHeap.Heap->GetCPUDescriptorHandleForHeapStart();
	}
	// Depth-stencil descriptor heap (DSV).
	{
		Gfx->DSVHeap.Capacity = 1024;

		D3D12_DESCRIPTOR_HEAP_DESC HeapDesc = {};
		HeapDesc.NumDescriptors = Gfx->DSVHeap.Capacity;
		HeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_DSV;
		HeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
		mz_VHR(Gfx->Device->CreateDescriptorHeap(&HeapDesc, IID_PPV_ARGS(&Gfx->DSVHeap.Heap)));
		Gfx->DSVHeap.CPUStart = Gfx->DSVHeap.Heap->GetCPUDescriptorHandleForHeapStart();
	}
	// Non-shader visible descriptor heap (CBV, SRV, UAV).
	{
		Gfx->CPUDescriptorHeap.Capacity = 16 * 1024;

		D3D12_DESCRIPTOR_HEAP_DESC HeapDesc = {};
		HeapDesc.NumDescriptors = Gfx->CPUDescriptorHeap.Capacity;
		HeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
		HeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_NONE;
		mz_VHR(Gfx->Device->CreateDescriptorHeap(&HeapDesc, IID_PPV_ARGS(&Gfx->CPUDescriptorHeap.Heap)));
		Gfx->CPUDescriptorHeap.CPUStart = Gfx->CPUDescriptorHeap.Heap->GetCPUDescriptorHandleForHeapStart();
	}
	// Shader visible descriptor heaps (CBV, SRV, UAV).
	{
		for (uint32_t Idx = 0; Idx < 2; ++Idx)
		{
			mz_DescriptorHeap& Heap = Gfx->GPUDescriptorHeaps[Idx];
			Heap.Capacity = 16 * 1024;

			D3D12_DESCRIPTOR_HEAP_DESC HeapDesc = {};
			HeapDesc.NumDescriptors = Heap.Capacity;
			HeapDesc.Type = D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV;
			HeapDesc.Flags = D3D12_DESCRIPTOR_HEAP_FLAG_SHADER_VISIBLE;
			mz_VHR(Gfx->Device->CreateDescriptorHeap(&HeapDesc, IID_PPV_ARGS(&Heap.Heap)));

			Heap.CPUStart = Heap.Heap->GetCPUDescriptorHandleForHeapStart();
			Heap.GPUStart = Heap.Heap->GetGPUDescriptorHandleForHeapStart();
		}
	}
	// Upload Memory Heaps.
	{
		for (uint32_t Index = 0; Index < 2; ++Index)
		{
			mz_GPUMemoryHeap& UploadHeap = Gfx->GPUUploadMemoryHeaps[Index];
			UploadHeap.Size = 0;
			UploadHeap.Capacity = 8 * 1024 * 1024;
			UploadHeap.CPUStart = nullptr;
			UploadHeap.GPUStart = 0;

			mz_VHR(Gfx->Device->CreateCommittedResource(&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(UploadHeap.Capacity), D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&UploadHeap.Heap)));

			mz_VHR(UploadHeap.Heap->Map(0, &CD3DX12_RANGE(0, 0), (void**)&UploadHeap.CPUStart));
			UploadHeap.GPUStart = UploadHeap.Heap->GetGPUVirtualAddress();
		}
	}
}

mz_UIContext*
mz_CreateUIContext(mz_GraphicsContext* Gfx, uint32_t NumSamples, eastl::vector<ID3D12Resource*>* OutTempResources)
{
	// NOTE(mziulek): Only one UI context can exist.
	static mz_UIContext UI = {};

	if (UI.PipelineState != nullptr)
	{
		return &UI;
	}

	ImGuiIO* IO = &ImGui::GetIO();
	IO->KeyMap[ImGuiKey_Tab] = VK_TAB;
	IO->KeyMap[ImGuiKey_LeftArrow] = VK_LEFT;
	IO->KeyMap[ImGuiKey_RightArrow] = VK_RIGHT;
	IO->KeyMap[ImGuiKey_UpArrow] = VK_UP;
	IO->KeyMap[ImGuiKey_DownArrow] = VK_DOWN;
	IO->KeyMap[ImGuiKey_PageUp] = VK_PRIOR;
	IO->KeyMap[ImGuiKey_PageDown] = VK_NEXT;
	IO->KeyMap[ImGuiKey_Home] = VK_HOME;
	IO->KeyMap[ImGuiKey_End] = VK_END;
	IO->KeyMap[ImGuiKey_Delete] = VK_DELETE;
	IO->KeyMap[ImGuiKey_Backspace] = VK_BACK;
	IO->KeyMap[ImGuiKey_Enter] = VK_RETURN;
	IO->KeyMap[ImGuiKey_Escape] = VK_ESCAPE;
	IO->KeyMap[ImGuiKey_A] = 'A';
	IO->KeyMap[ImGuiKey_C] = 'C';
	IO->KeyMap[ImGuiKey_V] = 'V';
	IO->KeyMap[ImGuiKey_X] = 'X';
	IO->KeyMap[ImGuiKey_Y] = 'Y';
	IO->KeyMap[ImGuiKey_Z] = 'Z';
	IO->ImeWindowHandle = Gfx->Window;
	IO->RenderDrawListsFn = nullptr;
	IO->DisplaySize = ImVec2((float)Gfx->Resolution[0], (float)Gfx->Resolution[1]);
	ImGui::GetStyle().WindowRounding = 0.0f;

	uint8_t* Pixels;
	int32_t Width, Height;
	IO->Fonts->AddFontFromFileTTF(""Data/Roboto-Medium.ttf"", 18.0f);
	IO->Fonts->GetTexDataAsRGBA32(&Pixels, &Width, &Height);

	mz_VHR(Gfx->Device->CreateCommittedResource(&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Tex2D(DXGI_FORMAT_R8G8B8A8_UNORM, Width, Height, 1, 1), D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS(&UI.Font)));
	{
		auto BufferDesc = CD3DX12_RESOURCE_DESC::Buffer(GetRequiredIntermediateSize(UI.Font, 0, 1));
		ID3D12Resource* StagingBuffer;
		mz_VHR(Gfx->Device->CreateCommittedResource(&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), D3D12_HEAP_FLAG_NONE, &BufferDesc, D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&StagingBuffer)));
		OutTempResources->push_back(StagingBuffer);

		D3D12_SUBRESOURCE_DATA TextureData = { Pixels, (LONG_PTR)Width * 4 };
		UpdateSubresources<1>(Gfx->CmdList, UI.Font, StagingBuffer, 0, 0, 1, &TextureData);

		Gfx->CmdList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(UI.Font, D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE));
	}

	D3D12_SHADER_RESOURCE_VIEW_DESC SRVDesc = {};
	SRVDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
	SRVDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
	SRVDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2D;
	SRVDesc.Texture2D.MipLevels = 1;

	UI.FontSRV = mz_AllocateDescriptors(Gfx, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, 1);
	Gfx->Device->CreateShaderResourceView(UI.Font, &SRVDesc, UI.FontSRV);

	D3D12_INPUT_ELEMENT_DESC InputElements[] =
	{
		{ ""_Position"", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 0, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
		{ ""_Texcoords"", 0, DXGI_FORMAT_R32G32_FLOAT, 0, 8, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
		{ ""_Color"", 0, DXGI_FORMAT_R8G8B8A8_UNORM, 0, 16, D3D12_INPUT_CLASSIFICATION_PER_VERTEX_DATA, 0 },
	};

	eastl::vector<uint8_t> VSBytecode = mz_LoadFile(""Data/Shaders/UserInterface.vs.cso"");
	eastl::vector<uint8_t> PSBytecode = mz_LoadFile(""Data/Shaders/UserInterface.ps.cso"");

	D3D12_GRAPHICS_PIPELINE_STATE_DESC PSODesc = {};
	PSODesc.InputLayout = { InputElements, (uint32_t)eastl::size(InputElements) };
	PSODesc.VS = { VSBytecode.data(), VSBytecode.size() };
	PSODesc.PS = { PSBytecode.data(), PSBytecode.size() };
	PSODesc.RasterizerState.FillMode = D3D12_FILL_MODE_SOLID;
	PSODesc.RasterizerState.CullMode = D3D12_CULL_MODE_NONE;
	PSODesc.RasterizerState.MultisampleEnable = NumSamples > 1 ? TRUE : FALSE;
	PSODesc.BlendState.RenderTarget[0].BlendEnable = TRUE;
	PSODesc.BlendState.RenderTarget[0].SrcBlend = D3D12_BLEND_SRC_ALPHA;
	PSODesc.BlendState.RenderTarget[0].DestBlend = D3D12_BLEND_INV_SRC_ALPHA;
	PSODesc.BlendState.RenderTarget[0].BlendOp = D3D12_BLEND_OP_ADD;
	PSODesc.BlendState.RenderTarget[0].SrcBlendAlpha = D3D12_BLEND_INV_SRC_ALPHA;
	PSODesc.BlendState.RenderTarget[0].DestBlendAlpha = D3D12_BLEND_ZERO;
	PSODesc.BlendState.RenderTarget[0].BlendOpAlpha = D3D12_BLEND_OP_ADD;
	PSODesc.BlendState.RenderTarget[0].RenderTargetWriteMask = D3D12_COLOR_WRITE_ENABLE_ALL;
	PSODesc.SampleMask = UINT_MAX;
	PSODesc.PrimitiveTopologyType = D3D12_PRIMITIVE_TOPOLOGY_TYPE_TRIANGLE;
	PSODesc.NumRenderTargets = 1;
	PSODesc.RTVFormats[0] = DXGI_FORMAT_R8G8B8A8_UNORM;
	PSODesc.SampleDesc.Count = NumSamples;

	UI.PipelineState = mz_CreateGraphicsPipelineState(Gfx, &PSODesc, ""UserInterface.vs.cso"", ""UserInterface.ps.cso"");

	return &UI;
}

void
mz_DestroyUIContext(mz_UIContext* UI)
{
	mz_ASSERT(UI);
	mz_SAFE_RELEASE(UI->Font);
	for (uint32_t Idx = 0; Idx < eastl::size(UI->Frames); ++Idx)
	{
		mz_SAFE_RELEASE(UI->Frames[Idx].VertexBuffer);
		mz_SAFE_RELEASE(UI->Frames[Idx].IndexBuffer);
	}
}

void
mz_UpdateUI(float DeltaTime)
{
	ImGuiIO* IO = &ImGui::GetIO();
	IO->KeyCtrl = (GetKeyState(VK_CONTROL) & 0x8000) != 0;
	IO->KeyShift = (GetKeyState(VK_SHIFT) & 0x8000) != 0;
	IO->KeyAlt = (GetKeyState(VK_MENU) & 0x8000) != 0;
	IO->DeltaTime = DeltaTime;

	ImGui::NewFrame();
}

void
mz_DrawUI(mz_UIContext* UI, mz_GraphicsContext* Gfx)
{
	mz_ASSERT(UI && Gfx);

	ImGui::Render();

	ImDrawData* DrawData = ImGui::GetDrawData();
	if (!DrawData || DrawData->TotalVtxCount == 0)
	{
		return;
	}

	ImGuiIO* IO = &ImGui::GetIO();
	mz_UIFrameResources& Frame = UI->Frames[Gfx->FrameIndex];

	auto ViewportWidth = (int32_t)(IO->DisplaySize.x * IO->DisplayFramebufferScale.x);
	auto ViewportHeight = (int32_t)(IO->DisplaySize.y * IO->DisplayFramebufferScale.y);
	DrawData->ScaleClipRects(IO->DisplayFramebufferScale);

	// Create or resize vertex buffer if needed.
	if (Frame.VertexBufferSize == 0 || Frame.VertexBufferSize < DrawData->TotalVtxCount * sizeof(ImDrawVert))
	{
		mz_SAFE_RELEASE(Frame.VertexBuffer);
		mz_VHR(Gfx->Device->CreateCommittedResource(&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(DrawData->TotalVtxCount * sizeof(ImDrawVert)), D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&Frame.VertexBuffer)));

		mz_VHR(Frame.VertexBuffer->Map(0, &CD3DX12_RANGE(0, 0), &Frame.VertexBufferCPUAddress));

		Frame.VertexBufferSize = DrawData->TotalVtxCount * sizeof(ImDrawVert);

		Frame.VertexBufferView.BufferLocation = Frame.VertexBuffer->GetGPUVirtualAddress();
		Frame.VertexBufferView.StrideInBytes = sizeof(ImDrawVert);
		Frame.VertexBufferView.SizeInBytes = DrawData->TotalVtxCount * sizeof(ImDrawVert);
	}

	// Create or resize index buffer if needed.
	if (Frame.IndexBufferSize == 0 || Frame.IndexBufferSize < DrawData->TotalIdxCount * sizeof(ImDrawIdx))
	{
		mz_SAFE_RELEASE(Frame.IndexBuffer);
		mz_VHR(Gfx->Device->CreateCommittedResource(&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(DrawData->TotalIdxCount * sizeof(ImDrawIdx)), D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&Frame.IndexBuffer)));

		mz_VHR(Frame.IndexBuffer->Map(0, &CD3DX12_RANGE(0, 0), &Frame.IndexBufferCPUAddress));

		Frame.IndexBufferSize = DrawData->TotalIdxCount * sizeof(ImDrawIdx);

		Frame.IndexBufferView.BufferLocation = Frame.IndexBuffer->GetGPUVirtualAddress();
		Frame.IndexBufferView.Format = sizeof(ImDrawIdx) == 2 ? DXGI_FORMAT_R16_UINT : DXGI_FORMAT_R32_UINT;
		Frame.IndexBufferView.SizeInBytes = DrawData->TotalIdxCount * sizeof(ImDrawIdx);
	}

	// Update vertex and index buffers.
	{
		ImDrawVert* VertexPtr = (ImDrawVert*)Frame.VertexBufferCPUAddress;
		ImDrawIdx* IndexPtr = (ImDrawIdx*)Frame.IndexBufferCPUAddress;

		for (uint32_t CmdListIdx = 0; CmdListIdx < (uint32_t)DrawData->CmdListsCount; ++CmdListIdx)
		{
			ImDrawList* DrawList = DrawData->CmdLists[CmdListIdx];
			memcpy(VertexPtr, &DrawList->VtxBuffer[0], DrawList->VtxBuffer.size() * sizeof(ImDrawVert));
			memcpy(IndexPtr, &DrawList->IdxBuffer[0], DrawList->IdxBuffer.size() * sizeof(ImDrawIdx));
			VertexPtr += DrawList->VtxBuffer.size();
			IndexPtr += DrawList->IdxBuffer.size();
		}
	}

	D3D12_GPU_VIRTUAL_ADDRESS ConstantBufferGPUAddress;
	auto ConstantBufferCPUAddress = (XMFLOAT4X4*)mz_AllocateGPUMemory(Gfx, 64, &ConstantBufferGPUAddress);

	// Update constant buffer.
	{
		XMMATRIX M = XMMatrixTranspose(XMMatrixOrthographicOffCenterLH(0.0f, (float)ViewportWidth, (float)ViewportHeight, 0.0f, 0.0f, 1.0f));
		XMStoreFloat4x4(ConstantBufferCPUAddress, M);
	}

	ID3D12GraphicsCommandList2* CmdList = Gfx->CmdList;

	CmdList->RSSetViewports(1, &CD3DX12_VIEWPORT(0.0f, 0.0f, (float)ViewportWidth, (float)ViewportHeight));

	CmdList->IASetPrimitiveTopology(D3D_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
	CmdList->SetPipelineState(UI->PipelineState->PSO);

	CmdList->SetGraphicsRootSignature(UI->PipelineState->RS);
	CmdList->SetGraphicsRootConstantBufferView(0, ConstantBufferGPUAddress);
	CmdList->SetGraphicsRootDescriptorTable(1, mz_CopyDescriptorsToGPUHeap(Gfx, 1, UI->FontSRV));

	CmdList->IASetVertexBuffers(0, 1, &Frame.VertexBufferView);
	CmdList->IASetIndexBuffer(&Frame.IndexBufferView);


	int32_t VertexOffset = 0;
	uint32_t IndexOffset = 0;
	for (uint32_t CmdListIdx = 0; CmdListIdx < (uint32_t)DrawData->CmdListsCount; ++CmdListIdx)
	{
		ImDrawList* DrawList = DrawData->CmdLists[CmdListIdx];

		for (uint32_t CmdIndex = 0; CmdIndex < (uint32_t)DrawList->CmdBuffer.size(); ++CmdIndex)
		{
			ImDrawCmd* Cmd = &DrawList->CmdBuffer[CmdIndex];

			if (Cmd->UserCallback)
			{
				Cmd->UserCallback(DrawList, Cmd);
			}
			else
			{
				D3D12_RECT R = CD3DX12_RECT((LONG)Cmd->ClipRect.x, (LONG)Cmd->ClipRect.y, (LONG)Cmd->ClipRect.z, (LONG)Cmd->ClipRect.w);
				CmdList->RSSetScissorRects(1, &R);
				CmdList->DrawIndexedInstanced(Cmd->ElemCount, 1, IndexOffset, VertexOffset, 0);
			}
			IndexOffset += Cmd->ElemCount;
		}
		VertexOffset += DrawList->VtxBuffer.size();
	}
}

mz_MipmapGenerator*
mz_CreateMipmapGenerator(mz_GraphicsContext* Gfx, DXGI_FORMAT Format)
{
	// We will support textures up to 2048x2048 for now.

	mz_MipmapGenerator* Generator = (mz_MipmapGenerator*)calloc(1, sizeof(mz_MipmapGenerator));
	if (Generator == nullptr)
	{
		return nullptr;
	}

	uint32_t Width = 2048 / 2;
	uint32_t Height = 2048 / 2;

	for (uint32_t Idx = 0; Idx < eastl::size(Generator->ScratchTextures); ++Idx)
	{
		auto TextureDesc = CD3DX12_RESOURCE_DESC::Tex2D(Format, Width, Height, 1, 1, 1, 0, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS);

		Generator->ScratchTextures[Idx] = mz_CreateCommittedResource(Gfx, D3D12_HEAP_TYPE_DEFAULT, D3D12_HEAP_FLAG_NONE, &TextureDesc, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, nullptr);

		Width /= 2;
		Height /= 2;
	}

	Generator->ScratchTexturesBaseUAV = mz_AllocateDescriptors(Gfx, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, 4);

	D3D12_CPU_DESCRIPTOR_HANDLE CPUHandle = Generator->ScratchTexturesBaseUAV;
	for (uint32_t Idx = 0; Idx < eastl::size(Generator->ScratchTextures); ++Idx)
	{
		Gfx->Device->CreateUnorderedAccessView(Generator->ScratchTextures[Idx]->Raw, nullptr, nullptr, CPUHandle);
		CPUHandle.ptr += Gfx->DescriptorSize;
	}

	{
		D3D12_COMPUTE_PIPELINE_STATE_DESC PSODesc = {};
		Generator->Pipeline = mz_CreateComputePipelineState(Gfx, &PSODesc, ""GenerateMipmaps.cs.cso"");
	}

	Generator->Format = Format;
	return Generator;
}

void
mz_DestroyMipmapGenerator(mz_MipmapGenerator* Generator)
{
	mz_ASSERT(Generator);
	for (uint32_t Idx = 0; Idx < eastl::size(Generator->ScratchTextures); ++Idx)
	{
		mz_ReleaseResource(Generator->ScratchTextures[Idx]);
	}
}

void
mz_GenerateMipmaps(mz_MipmapGenerator* Generator, mz_GraphicsContext* Gfx, mz_DX12Resource* Texture)
{
	mz_ASSERT(Texture && Texture->State == D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);
	mz_ASSERT(Texture->Format == Generator->Format);

	D3D12_RESOURCE_DESC TextureDesc = Texture->Raw->GetDesc();

	mz_ASSERT(TextureDesc.Width <= 2048 && TextureDesc.Height <= 2048);
	mz_ASSERT(TextureDesc.Width == TextureDesc.Height);
	mz_ASSERT(mz_IsPowerOf2(TextureDesc.Width) && mz_IsPowerOf2(TextureDesc.Height));
	mz_ASSERT(TextureDesc.MipLevels > 1);

	ID3D12GraphicsCommandList5* CmdList = Gfx->CmdList;


	for (uint32_t ArraySliceIdx = 0; ArraySliceIdx < TextureDesc.DepthOrArraySize; ++ArraySliceIdx)
	{
		D3D12_CPU_DESCRIPTOR_HANDLE TextureSRV = mz_AllocateDescriptors(Gfx, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, 1);

		D3D12_SHADER_RESOURCE_VIEW_DESC SRVDesc = {};
		SRVDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
		SRVDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DARRAY;
		SRVDesc.Texture2DArray.MostDetailedMip = 0;
		SRVDesc.Texture2DArray.MipLevels = TextureDesc.MipLevels;
		SRVDesc.Texture2DArray.ArraySize = 1;
		SRVDesc.Texture2DArray.FirstArraySlice = ArraySliceIdx;
		Gfx->Device->CreateShaderResourceView(Texture->Raw, &SRVDesc, TextureSRV);

		D3D12_GPU_DESCRIPTOR_HANDLE GPUHandle = mz_CopyDescriptorsToGPUHeap(Gfx, 1, TextureSRV);
		mz_CopyDescriptorsToGPUHeap(Gfx, 4, Generator->ScratchTexturesBaseUAV);

		CmdList->SetPipelineState(Generator->Pipeline->PSO);
		CmdList->SetComputeRootSignature(Generator->Pipeline->RS);

		uint32_t TotalNumMipsToGen = (uint32_t)(TextureDesc.MipLevels - 1);
		uint32_t CurrentSrcMipLevel = 0;

		for (;;)
		{
			uint32_t NumMipsInDispatch = TotalNumMipsToGen >= 4 ? 4 : TotalNumMipsToGen;

			CmdList->SetComputeRoot32BitConstant(0, CurrentSrcMipLevel, 0);
			CmdList->SetComputeRoot32BitConstant(0, NumMipsInDispatch, 1);
			CmdList->SetComputeRootDescriptorTable(1, GPUHandle);
			CmdList->Dispatch((uint32_t)(TextureDesc.Width >> (4 + CurrentSrcMipLevel)), TextureDesc.Height >> (4 + CurrentSrcMipLevel), 1);

			{
				uint32_t NumBarriers = 0;
				CD3DX12_RESOURCE_BARRIER Barriers[5];
				mz_AddTransitionBarrier(Generator->ScratchTextures[0], D3D12_RESOURCE_STATE_COPY_SOURCE, &Barriers[NumBarriers], &NumBarriers);
				mz_AddTransitionBarrier(Generator->ScratchTextures[1], D3D12_RESOURCE_STATE_COPY_SOURCE, &Barriers[NumBarriers], &NumBarriers);
				mz_AddTransitionBarrier(Generator->ScratchTextures[2], D3D12_RESOURCE_STATE_COPY_SOURCE, &Barriers[NumBarriers], &NumBarriers);
				mz_AddTransitionBarrier(Generator->ScratchTextures[3], D3D12_RESOURCE_STATE_COPY_SOURCE, &Barriers[NumBarriers], &NumBarriers);
				mz_AddTransitionBarrier(Texture, D3D12_RESOURCE_STATE_COPY_DEST, &Barriers[NumBarriers], &NumBarriers);
				mz_CmdResourceBarrier(CmdList, NumBarriers, Barriers);
			}

			for (uint32_t MipmapIdx = 0; MipmapIdx < NumMipsInDispatch; ++MipmapIdx)
			{
				auto Dest = CD3DX12_TEXTURE_COPY_LOCATION(Texture->Raw, MipmapIdx + 1 + CurrentSrcMipLevel + ArraySliceIdx * TextureDesc.MipLevels);
				auto Src = CD3DX12_TEXTURE_COPY_LOCATION(Generator->ScratchTextures[MipmapIdx]->Raw, 0);
				auto Box = CD3DX12_BOX(0, 0, 0, (UINT)(TextureDesc.Width >> (MipmapIdx + 1 + CurrentSrcMipLevel)), TextureDesc.Height >> (MipmapIdx + 1 + CurrentSrcMipLevel), 1);
				CmdList->CopyTextureRegion(&Dest, 0, 0, 0, &Src, &Box);
			}

			{
				uint32_t NumBarriers = 0;
				CD3DX12_RESOURCE_BARRIER Barriers[5];
				mz_AddTransitionBarrier(Generator->ScratchTextures[0], D3D12_RESOURCE_STATE_UNORDERED_ACCESS, &Barriers[NumBarriers], &NumBarriers);
				mz_AddTransitionBarrier(Generator->ScratchTextures[1], D3D12_RESOURCE_STATE_UNORDERED_ACCESS, &Barriers[NumBarriers], &NumBarriers);
				mz_AddTransitionBarrier(Generator->ScratchTextures[2], D3D12_RESOURCE_STATE_UNORDERED_ACCESS, &Barriers[NumBarriers], &NumBarriers);
				mz_AddTransitionBarrier(Generator->ScratchTextures[3], D3D12_RESOURCE_STATE_UNORDERED_ACCESS, &Barriers[NumBarriers], &NumBarriers);
				mz_AddTransitionBarrier(Texture, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE, &Barriers[NumBarriers], &NumBarriers);
				mz_CmdResourceBarrier(CmdList, NumBarriers, Barriers);
			}

			if ((TotalNumMipsToGen -= NumMipsInDispatch) == 0)
			{
				break;
			}
			CurrentSrcMipLevel += NumMipsInDispatch;
		}
	}
}

eastl::vector<uint8_t>
mz_LoadFile(const char* Name)
{
	FILE* File = fopen(Name, ""rb"");
	mz_ASSERT(File);
	fseek(File, 0, SEEK_END);
	long Size = ftell(File);
	if (Size <= 0)
	{
		mz_ASSERT(0);
		return eastl::vector<uint8_t>();
	}
	eastl::vector<uint8_t> Content(Size);
	fseek(File, 0, SEEK_SET);
	fread(Content.data(), 1, Content.size(), File);
	fclose(File);
	return Content;
}

void
mz_UpdateFrameStats(HWND Window, const char* Name, double* Time, float* DeltaTime)
{
	static double PreviousTime = -1.0;
	static double HeaderRefreshTime = 0.0;
	static uint32_t NumFrames = 0;

	if (PreviousTime < 0.0)
	{
		PreviousTime = mz_GetTime();
		HeaderRefreshTime = PreviousTime;
	}

	*Time = mz_GetTime();
	*DeltaTime = (float)(*Time - PreviousTime);
	PreviousTime = *Time;

	if ((*Time - HeaderRefreshTime) >= 1.0)
	{
		double FPS = NumFrames / (*Time - HeaderRefreshTime);
		double MS = (1.0 / FPS) * 1000.0;
		char Header[256];
		snprintf(Header, sizeof(Header), ""[%.1f fps  %.3f ms] %s"", FPS, MS, Name);
		SetWindowText(Window, Header);
		HeaderRefreshTime = *Time;
		NumFrames = 0;
	}
	NumFrames++;
}

double
mz_GetTime()
{
	static LARGE_INTEGER StartCounter;
	static LARGE_INTEGER Frequency;
	if (StartCounter.QuadPart == 0)
	{
		QueryPerformanceFrequency(&Frequency);
		QueryPerformanceCounter(&StartCounter);
	}
	LARGE_INTEGER Counter;
	QueryPerformanceCounter(&Counter);
	return (Counter.QuadPart - StartCounter.QuadPart) / (double)Frequency.QuadPart;
}

static LRESULT CALLBACK
mz_ProcessWindowMessage(HWND Window, UINT Message, WPARAM WParam, LPARAM LParam)
{
	ImGuiIO* IO = &ImGui::GetIO();

	switch (Message)
	{
	case WM_LBUTTONDOWN:
		IO->MouseDown[0] = true;
		return 0;
	case WM_LBUTTONUP:
		IO->MouseDown[0] = false;
		return 0;
	case WM_RBUTTONDOWN:
		IO->MouseDown[1] = true;
		return 0;
	case WM_RBUTTONUP:
		IO->MouseDown[1] = false;
		return 0;
	case WM_MBUTTONDOWN:
		IO->MouseDown[2] = true;
		return 0;
	case WM_MBUTTONUP:
		IO->MouseDown[2] = false;
		return 0;
	case WM_MOUSEWHEEL:
		IO->MouseWheel += GET_WHEEL_DELTA_WPARAM(WParam) > 0 ? 1.0f : -1.0f;
		return 0;
	case WM_MOUSEMOVE:
		IO->MousePos.x = (signed short)LParam;
		IO->MousePos.y = (signed short)(LParam >> 16);
		return 0;
	case WM_DESTROY:
		PostQuitMessage(0);
		return 0;
	case WM_KEYDOWN:
	{
		if (WParam < 256)
		{
			IO->KeysDown[WParam] = true;
			if (WParam == VK_ESCAPE)
			{
				PostQuitMessage(0);
			}
			return 0;
		}
	}
	break;
	case WM_KEYUP:
	{
		if (WParam < 256)
		{
			IO->KeysDown[WParam] = false;
			return 0;
		}
	}
	break;
	case WM_CHAR:
	{
		if (WParam > 0 && WParam < 0x10000)
		{
			IO->AddInputCharacter((unsigned short)WParam);
			return 0;
		}
	}
	break;
	}
	return DefWindowProc(Window, Message, WParam, LParam);
}

HWND
mz_CreateWindow(const char* Name, uint32_t Width, uint32_t Height)
{
	WNDCLASS WinClass = {};
	WinClass.lpfnWndProc = mz_ProcessWindowMessage;
	WinClass.hInstance = GetModuleHandle(nullptr);
	WinClass.hCursor = LoadCursor(nullptr, IDC_ARROW);
	WinClass.lpszClassName = Name;
	if (!RegisterClass(&WinClass))
	{
		mz_ASSERT(0);
	}

	RECT Rect = { 0, 0, (LONG)Width, (LONG)Height };
	if (!AdjustWindowRect(&Rect, WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION | WS_MINIMIZEBOX, 0))
	{
		mz_ASSERT(0);
	}

	HWND Window = CreateWindowEx(0, Name, Name, WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION | WS_MINIMIZEBOX | WS_VISIBLE, CW_USEDEFAULT, CW_USEDEFAULT, Rect.right - Rect.left, Rect.bottom - Rect.top, nullptr, nullptr, nullptr, 0);
	mz_ASSERT(Window);
	return Window;
}

mz_DX12Resource*
mz_AddDX12Resource(mz_GraphicsContext* Gfx, ID3D12Resource* RawResource, D3D12_RESOURCE_STATES InitialState, DXGI_FORMAT Format)
{
	mz_DX12Resource* NewResource = nullptr;
	for (uint32_t Idx = 0; Idx < mz_MAX_NUM_RESOURCES; ++Idx)
	{
		if (Gfx->Resources[Idx].Raw == nullptr)
		{
			NewResource = &Gfx->Resources[Idx];
			NewResource->Raw = RawResource;
			NewResource->State = InitialState;
			NewResource->Format = Format;
			break;
		}
	}
	mz_ASSERT(NewResource);
	return NewResource;
}

mz_DX12Resource*
mz_CreateCommittedResource(mz_GraphicsContext* Gfx, D3D12_HEAP_TYPE HeapType, D3D12_HEAP_FLAGS HeapFlags, D3D12_RESOURCE_DESC* Desc, D3D12_RESOURCE_STATES InitialState, D3D12_CLEAR_VALUE* ClearValue)
{
	ID3D12Resource* RawResource;
	mz_VHR(Gfx->Device->CreateCommittedResource(&CD3DX12_HEAP_PROPERTIES(HeapType), HeapFlags, Desc, InitialState, ClearValue, IID_PPV_ARGS(&RawResource)));

	return mz_AddDX12Resource(Gfx, RawResource, InitialState, Desc->Format);
}

mz_DX12PipelineState*
mz_CreateGraphicsPipelineState(mz_GraphicsContext* Gfx, D3D12_GRAPHICS_PIPELINE_STATE_DESC* PSODesc, const char* VSName, const char* PSName)
{
	char Path[MAX_PATH];

	snprintf(Path, sizeof(Path), ""Data/Shaders/%s"", VSName);
	eastl::vector<uint8_t> VSBytecode = mz_LoadFile(Path);

	snprintf(Path, sizeof(Path), ""Data/Shaders/%s"", PSName);
	eastl::vector<uint8_t> PSBytecode = mz_LoadFile(Path);

	uint64_t Hash;
	{
		meow_state HasherState;
		MeowBegin(&HasherState, MeowDefaultSeed);
		MeowAbsorb(&HasherState, VSBytecode.size(), VSBytecode.data());
		MeowAbsorb(&HasherState, PSBytecode.size(), PSBytecode.data());
		MeowAbsorb(&HasherState, sizeof(PSODesc->BlendState), &PSODesc->BlendState);
		MeowAbsorb(&HasherState, sizeof(PSODesc->SampleMask), &PSODesc->SampleMask);
		MeowAbsorb(&HasherState, sizeof(PSODesc->RasterizerState), &PSODesc->RasterizerState);
		MeowAbsorb(&HasherState, sizeof(PSODesc->DepthStencilState), &PSODesc->DepthStencilState);
		for (uint32_t Idx = 0; Idx < PSODesc->InputLayout.NumElements; ++Idx)
		{
			MeowAbsorb(&HasherState, sizeof(PSODesc->InputLayout.pInputElementDescs[0]), (void*)&PSODesc->InputLayout.pInputElementDescs[Idx]);
		}
		MeowAbsorb(&HasherState, sizeof(PSODesc->PrimitiveTopologyType), &PSODesc->PrimitiveTopologyType);
		MeowAbsorb(&HasherState, sizeof(PSODesc->NumRenderTargets), &PSODesc->NumRenderTargets);
		MeowAbsorb(&HasherState, sizeof(PSODesc->RTVFormats), &PSODesc->RTVFormats[0]);
		MeowAbsorb(&HasherState, sizeof(PSODesc->DSVFormat), &PSODesc->DSVFormat);
		MeowAbsorb(&HasherState, sizeof(PSODesc->SampleDesc), &PSODesc->SampleDesc);
		Hash = MeowU64From(MeowEnd(&HasherState, nullptr), 0);
	}

	auto Found = Gfx->GraphicsPipelinesMap.find(Hash);
	if (Found != Gfx->GraphicsPipelinesMap.end())
	{
		return Found->second;
	}

	mz_DX12PipelineState* NewPipeline = nullptr;
	for (uint32_t Idx = 0; Idx < mz_MAX_NUM_PIPELINES; ++Idx)
	{
		if (Gfx->Pipelines[Idx].PSO == nullptr && Gfx->Pipelines[Idx].RS == nullptr)
		{
			NewPipeline = &Gfx->Pipelines[Idx];
			break;
		}
	}
	mz_ASSERT(NewPipeline);

	for (auto Iter = Gfx->GraphicsPipelinesMap.begin(); Iter != Gfx->GraphicsPipelinesMap.end(); ++Iter)
	{
		if (Iter->second == NewPipeline)
		{
			Gfx->GraphicsPipelinesMap.erase(Iter);
			break;
		}
	}

	// NOTE(mziulek): Root signature has to be defined in HLSL code.
	mz_VHR(Gfx->Device->CreateRootSignature(0, VSBytecode.data(), VSBytecode.size(), IID_PPV_ARGS(&NewPipeline->RS)));

	PSODesc->pRootSignature = NewPipeline->RS;
	PSODesc->VS = { VSBytecode.data(), VSBytecode.size() };
	PSODesc->PS = { PSBytecode.data(), PSBytecode.size() };

	mz_VHR(Gfx->Device->CreateGraphicsPipelineState(PSODesc, IID_PPV_ARGS(&NewPipeline->PSO)));

	Gfx->GraphicsPipelinesMap.insert(eastl::make_pair(Hash, NewPipeline));

	return NewPipeline;
}

mz_DX12PipelineState*
mz_CreateComputePipelineState(mz_GraphicsContext* Gfx, D3D12_COMPUTE_PIPELINE_STATE_DESC* PSODesc, const char* CSName)
{
	char Path[MAX_PATH];

	snprintf(Path, sizeof(Path), ""Data/Shaders/%s"", CSName);
	eastl::vector<uint8_t> CSBytecode = mz_LoadFile(Path);

	uint64_t Hash = MeowU64From(MeowHash(MeowDefaultSeed, CSBytecode.size(), CSBytecode.data()), 0);

	auto Found = Gfx->ComputePipelinesMap.find(Hash);
	if (Found != Gfx->ComputePipelinesMap.end())
	{
		return Found->second;
	}

	mz_DX12PipelineState* NewPipeline = nullptr;
	for (uint32_t Idx = 0; Idx < mz_MAX_NUM_PIPELINES; ++Idx)
	{
		if (Gfx->Pipelines[Idx].PSO == nullptr && Gfx->Pipelines[Idx].RS == nullptr)
		{
			NewPipeline = &Gfx->Pipelines[Idx];
			break;
		}
	}
	mz_ASSERT(NewPipeline);

	for (auto Iter = Gfx->ComputePipelinesMap.begin(); Iter != Gfx->ComputePipelinesMap.end(); ++Iter)
	{
		if (Iter->second == NewPipeline)
		{
			Gfx->ComputePipelinesMap.erase(Iter);
			break;
		}
	}

	// NOTE(mziulek): Root signature has to be defined in HLSL code.
	mz_VHR(Gfx->Device->CreateRootSignature(0, CSBytecode.data(), CSBytecode.size(), IID_PPV_ARGS(&NewPipeline->RS)));

	PSODesc->pRootSignature = NewPipeline->RS;
	PSODesc->CS = { CSBytecode.data(), CSBytecode.size() };

	mz_VHR(Gfx->Device->CreateComputePipelineState(PSODesc, IID_PPV_ARGS(&NewPipeline->PSO)));

	Gfx->ComputePipelinesMap.insert(eastl::make_pair(Hash, NewPipeline));

	return NewPipeline;
}

static void
mz_LoadGLTFMesh(cgltf_mesh* InMesh, mz_Mesh* OutMesh, eastl::vector<mz_Vertex>* InOutVertices, eastl::vector<uint32_t>* InOutIndices)
{
	mz_ASSERT(InMesh);

	OutMesh->NumSections = (uint16_t)InMesh->primitives_count;
	if (OutMesh->NumSections > 1)
	{
		OutMesh->Sections = (mz_MeshSection*)calloc(OutMesh->NumSections, sizeof(mz_MeshSection));
		if (!OutMesh->Sections)
		{
			return;
		}
	}

	uint32_t TotalNumVertices = 0;
	uint32_t TotalNumIndices = 0;

	for (uint32_t SectionIdx = 0; SectionIdx < InMesh->primitives_count; ++SectionIdx)
	{
		mz_ASSERT(InMesh->primitives[SectionIdx].indices);
		mz_ASSERT(InMesh->primitives[SectionIdx].attributes);

		TotalNumIndices += (uint32_t)InMesh->primitives[SectionIdx].indices->count;
		TotalNumVertices += (uint32_t)InMesh->primitives[SectionIdx].attributes[0].data->count;
	}

	InOutVertices->reserve(InOutVertices->size() + TotalNumVertices);
	InOutIndices->reserve(InOutIndices->size() + TotalNumIndices);

	eastl::vector<XMFLOAT3> Positions;
	eastl::vector<XMFLOAT3> Normals;
	eastl::vector<XMFLOAT4> Tangents;
	eastl::vector<XMFLOAT2> Texcoords;
	Positions.reserve(TotalNumVertices);
	Normals.reserve(TotalNumVertices);
	Tangents.reserve(TotalNumVertices);
	Texcoords.reserve(TotalNumVertices);

	mz_MeshSection* Sections = mz_GetMeshSections(OutMesh);

	for (uint32_t SectionIdx = 0; SectionIdx < InMesh->primitives_count; ++SectionIdx)
	{
		// Indices.
		{
			cgltf_accessor* Accessor = InMesh->primitives[SectionIdx].indices;

			mz_ASSERT(Accessor->buffer_view);
			mz_ASSERT(Accessor->stride == Accessor->buffer_view->stride || Accessor->buffer_view->stride == 0);
			mz_ASSERT((Accessor->stride * Accessor->count) == Accessor->buffer_view->size);

			auto DataAddr = (uint8_t*)Accessor->buffer_view->buffer->data + Accessor->offset + Accessor->buffer_view->offset;

			Sections[SectionIdx].BaseIndex = (uint32_t)InOutIndices->size();
			Sections[SectionIdx].NumIndices = (uint32_t)Accessor->count;

			if (Accessor->stride == 1)
			{
				uint8_t* DataU8 = (uint8_t*)DataAddr;
				for (uint32_t Idx = 0; Idx < Accessor->count; ++Idx)
				{
					InOutIndices->push_back((uint32_t)*DataU8++);
				}
			}
			else if (Accessor->stride == 2)
			{
				uint16_t* DataU16 = (uint16_t*)DataAddr;
				for (uint32_t Idx = 0; Idx < Accessor->count; ++Idx)
				{
					InOutIndices->push_back((uint32_t)*DataU16++);
				}
			}
			else if (Accessor->stride == 4)
			{
				InOutIndices->resize(InOutIndices->size() + Accessor->count);

				memcpy(InOutIndices->data() + (InOutIndices->size() - Accessor->count), DataAddr, Accessor->count * Accessor->stride);
			}
			else
			{
				mz_ASSERT(0);
			}
		}

		// Attributes.
		{
			uint32_t NumAttribs = (uint32_t)InMesh->primitives[SectionIdx].attributes_count;

			for (uint32_t AttribIdx = 0; AttribIdx < NumAttribs; ++AttribIdx)
			{
				cgltf_attribute* Attrib = &InMesh->primitives[SectionIdx].attributes[AttribIdx];
				cgltf_accessor* Accessor = Attrib->data;

				mz_ASSERT(Accessor->buffer_view);
				mz_ASSERT(Accessor->stride == Accessor->buffer_view->stride || Accessor->buffer_view->stride == 0);
				mz_ASSERT((Accessor->stride * Accessor->count) == Accessor->buffer_view->size);

				auto DataAddr = (uint8_t*)Accessor->buffer_view->buffer->data + Accessor->offset + Accessor->buffer_view->offset;

				if (Attrib->type == cgltf_attribute_type_position)
				{
					mz_ASSERT(Accessor->type == cgltf_type_vec3);
					Positions.resize(Accessor->count);
					memcpy(Positions.data(), DataAddr, Accessor->count * Accessor->stride);
				}
				else if (Attrib->type == cgltf_attribute_type_normal)
				{
					mz_ASSERT(Accessor->type == cgltf_type_vec3);
					Normals.resize(Accessor->count);
					memcpy(Normals.data(), DataAddr, Accessor->count * Accessor->stride);
				}
				else if (Attrib->type == cgltf_attribute_type_tangent)
				{
					mz_ASSERT(Accessor->type == cgltf_type_vec4);
					Tangents.resize(Accessor->count);
					memcpy(Tangents.data(), DataAddr, Accessor->count * Accessor->stride);
				}
				else if (Attrib->type == cgltf_attribute_type_texcoord)
				{
					mz_ASSERT(Accessor->type == cgltf_type_vec2);
					Texcoords.resize(Accessor->count);
					memcpy(Texcoords.data(), DataAddr, Accessor->count * Accessor->stride);
				}
			}

			mz_ASSERT(Positions.size() > 0);
			mz_ASSERT(Positions.size() == Normals.size());
			mz_ASSERT(Positions.size() == Texcoords.size());

			if (Tangents.empty())
			{
				Tangents.resize(Positions.size());
			}

			Sections[SectionIdx].BaseVertex = (uint32_t)InOutVertices->size();
			Sections[SectionIdx].NumVertices = (uint32_t)Positions.size();

			for (uint32_t Idx = 0; Idx < Positions.size(); ++Idx)
			{
				mz_Vertex Vertex;
				Vertex.Position = Positions[Idx];
				Vertex.Normal = Normals[Idx];
				Vertex.Tangent = Tangents[Idx];
				Vertex.Texcoord = Texcoords[Idx];
				InOutVertices->push_back(Vertex);
			}

			Positions.clear();
			Normals.clear();
			Texcoords.clear();
			Tangents.clear();
		}
	}
}

void
mz_LoadGLTFScene(const char* FileName, mz_GraphicsContext* Gfx, mz_SceneData* OutScene, eastl::vector<ID3D12Resource*>* OutTempResources)
{
	mz_ASSERT(OutScene->Meshes.empty() && OutScene->Objects.empty() && OutScene->Materials.empty() && OutScene->Textures.empty() && OutScene->TextureSRVs.empty());

	cgltf_options Options = {};
	cgltf_data* Data = nullptr;
	{
		cgltf_result R = cgltf_parse_file(&Options, FileName, &Data);
		mz_ASSERT(R == cgltf_result_success);

		R = cgltf_load_buffers(&Options, Data, FileName);
		mz_ASSERT(R == cgltf_result_success);

		mz_ASSERT(Data->scenes_count == 1);
	}

	eastl::vector<mz_Vertex> AllVertices;
	eastl::vector<uint32_t> AllIndices;

	// Meshes.
	{
		uint32_t NumMeshes = (uint32_t)Data->meshes_count;
		mz_ASSERT(NumMeshes > 0);

		OutScene->Meshes.reserve(NumMeshes);

		for (uint32_t MeshIdx = 0; MeshIdx < NumMeshes; ++MeshIdx)
		{
			mz_Mesh Mesh = {};
			mz_LoadGLTFMesh(&Data->meshes[MeshIdx], &Mesh, &AllVertices, &AllIndices);

			cgltf_mesh* SrcMesh = &Data->meshes[MeshIdx];

			mz_MeshSection* Sections = mz_GetMeshSections(&Mesh);

			for (uint32_t SectionIdx = 0; SectionIdx < (uint32_t)SrcMesh->primitives_count; ++SectionIdx)
			{
				Sections[SectionIdx].MaterialIndex = (uint16_t)~0;

				for (uint32_t MaterialIdx = 0; MaterialIdx < (uint32_t)Data->materials_count; ++MaterialIdx)
				{
					if (&Data->materials[MaterialIdx] == SrcMesh->primitives[SectionIdx].material)
					{
						Sections[SectionIdx].MaterialIndex = (uint16_t)MaterialIdx;
						break;
					}
				}
				mz_ASSERT(Sections[SectionIdx].MaterialIndex != (uint16_t)~0);
			}

			OutScene->Meshes.push_back(Mesh);
		}
	}

	// Materials.
	{
		uint32_t NumMaterials = (uint32_t)Data->materials_count;
		mz_ASSERT(NumMaterials > 0);

		OutScene->Materials.reserve(NumMaterials);

		for (uint32_t MaterialIdx = 0; MaterialIdx < NumMaterials; ++MaterialIdx)
		{
			cgltf_material* SrcMaterial = &Data->materials[MaterialIdx];
			if (SrcMaterial->has_pbr_metallic_roughness)
			{
				cgltf_pbr_metallic_roughness* PBR = &SrcMaterial->pbr_metallic_roughness;

				mz_Material Material = {};
				Material.BaseColorFactor = XMFLOAT4(PBR->base_color_factor);
				Material.RoughnessFactor = PBR->roughness_factor;
				Material.MetallicFactor = PBR->metallic_factor;

				Material.BaseColorTextureIndex = (uint16_t)~0;
				Material.PBRFactorsTextureIndex = (uint16_t)~0;
				Material.NormalTextureIndex = (uint16_t)~0;

				for (uint32_t ImageIdx = 0; ImageIdx < (uint32_t)Data->images_count; ++ImageIdx)
				{
					cgltf_image* Image = &Data->images[ImageIdx];

					if (PBR->base_color_texture.texture && Image->uri == PBR->base_color_texture.texture->image->uri)
					{
						mz_ASSERT(Material.BaseColorTextureIndex == (uint16_t)~0);
						Material.BaseColorTextureIndex = (uint16_t)ImageIdx;
					}
					if (PBR->metallic_roughness_texture.texture && Image->uri == PBR->metallic_roughness_texture.texture->image->uri)
					{
						mz_ASSERT(Material.PBRFactorsTextureIndex == (uint16_t)~0);
						Material.PBRFactorsTextureIndex = (uint16_t)ImageIdx;
					}
					if (SrcMaterial->normal_texture.texture && Image->uri == SrcMaterial->normal_texture.texture->image->uri)
					{
						mz_ASSERT(Material.NormalTextureIndex == (uint16_t)~0);
						Material.NormalTextureIndex = (uint16_t)ImageIdx;
					}
				}

				OutScene->Materials.push_back(Material);
			}
		}
	}

	uint32_t NumNodes = (uint32_t)Data->nodes_count;
	mz_ASSERT(NumNodes > 0);

	OutScene->Objects.reserve(NumNodes);

	for (uint32_t NodeIdx = 0; NodeIdx < NumNodes; ++NodeIdx)
	{
		if (Data->nodes[NodeIdx].mesh)
		{
			cgltf_mesh* SrcMesh = Data->nodes[NodeIdx].mesh;

			mz_Object Object = {};
			Object.MeshIndex = (uint16_t)~0;

			for (uint32_t MeshIdx = 0; MeshIdx < (uint32_t)Data->meshes_count; ++MeshIdx)
			{
				if (&Data->meshes[MeshIdx] == SrcMesh)
				{
					Object.MeshIndex = (uint16_t)MeshIdx;
					break;
				}
			}
			mz_ASSERT(Object.MeshIndex != (uint16_t)~0);

			cgltf_float WorldTransform[16];
			cgltf_node_transform_world(&Data->nodes[NodeIdx], WorldTransform);

			memcpy(&Object.ObjectToWorld, &XMMatrixTranspose(XMLoadFloat4x4((XMFLOAT4X4*)&WorldTransform[0])), sizeof(XMFLOAT3X4));

			OutScene->Objects.push_back(Object);
		}
	}

	for (uint32_t ImageIdx = 0; ImageIdx < (uint32_t)Data->images_count; ++ImageIdx)
	{
		cgltf_image* Image = &Data->images[ImageIdx];

		char Path[MAX_PATH];
		strcpy(Path, FileName);

		char* C = strrchr(Path, '/');
		mz_ASSERT(C);
		*C = '\\0';

		snprintf(Path, sizeof(Path), ""%s/%s"", Path, Image->uri);

		int Width, Height;
		uint8_t* ImageData = stbi_load(Path, &Width, &Height, nullptr, 4);
		mz_ASSERT(ImageData);

		mz_DX12Resource* Texture = nullptr;
		{
			auto Desc = CD3DX12_RESOURCE_DESC::Tex2D(DXGI_FORMAT_R8G8B8A8_UNORM, (uint64_t)Width, (uint32_t)Height);
			Texture = mz_CreateCommittedResource(Gfx, D3D12_HEAP_TYPE_DEFAULT, D3D12_HEAP_FLAG_NONE, &Desc, D3D12_RESOURCE_STATE_COPY_DEST, nullptr);
			OutScene->Textures.push_back(Texture);

			D3D12_CPU_DESCRIPTOR_HANDLE CPUHandle = mz_AllocateDescriptors(Gfx, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, 1);
			Gfx->Device->CreateShaderResourceView(Texture->Raw, nullptr, CPUHandle);
			OutScene->TextureSRVs.push_back(CPUHandle);
		}

		{
			ID3D12Resource* UploadBuffer;
			auto Desc = CD3DX12_RESOURCE_DESC::Buffer(GetRequiredIntermediateSize(Texture->Raw, 0, 1));
			mz_VHR(Gfx->Device->CreateCommittedResource(&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), D3D12_HEAP_FLAG_NONE, &Desc, D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&UploadBuffer)));
			OutTempResources->push_back(UploadBuffer);

			D3D12_SUBRESOURCE_DATA SrcData = {};
			SrcData.pData = ImageData;
			SrcData.RowPitch = 4 * Width;
			UpdateSubresources<1>(Gfx->CmdList, Texture->Raw, UploadBuffer, 0, 0, 1, &SrcData);
		}

		mz_CmdTransitionBarrier(Gfx->CmdList, Texture, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);

		stbi_image_free(ImageData);
	}

	cgltf_free(Data);


	// Static geometry vertex buffer (single buffer for all static meshes).
	{
		ID3D12Resource* TempVertexBuffer;
		D3D12_RESOURCE_DESC Desc = CD3DX12_RESOURCE_DESC::Buffer(AllVertices.size() * sizeof(mz_Vertex));
		{
			mz_VHR(Gfx->Device->CreateCommittedResource(&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), D3D12_HEAP_FLAG_NONE, &Desc, D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&TempVertexBuffer)));
			OutTempResources->push_back(TempVertexBuffer);

			void* Addr;
			mz_VHR(TempVertexBuffer->Map(0, &CD3DX12_RANGE(0, 0), &Addr));
			memcpy(Addr, AllVertices.data(), AllVertices.size() * sizeof(mz_Vertex));
			TempVertexBuffer->Unmap(0, nullptr);
		}

		OutScene->VertexBuffer = mz_CreateCommittedResource(Gfx, D3D12_HEAP_TYPE_DEFAULT, D3D12_HEAP_FLAG_NONE, &Desc, D3D12_RESOURCE_STATE_COPY_DEST, nullptr);

		Gfx->CmdList->CopyResource(OutScene->VertexBuffer->Raw, TempVertexBuffer);

		mz_CmdTransitionBarrier(Gfx->CmdList, OutScene->VertexBuffer, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);

		OutScene->VertexBufferSRV = mz_AllocateDescriptors(Gfx, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, 1);

		D3D12_SHADER_RESOURCE_VIEW_DESC SRVDesc = {};
		SRVDesc.Format = DXGI_FORMAT_UNKNOWN;
		SRVDesc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
		SRVDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
		SRVDesc.Buffer.NumElements = (uint32_t)AllVertices.size();
		SRVDesc.Buffer.StructureByteStride = sizeof(mz_Vertex);
		Gfx->Device->CreateShaderResourceView(OutScene->VertexBuffer->Raw, &SRVDesc, OutScene->VertexBufferSRV);
	}

	// Static geometry index buffer (single buffer for all static meshes).
	{
		ID3D12Resource* TempIndexBuffer;
		D3D12_RESOURCE_DESC Desc = CD3DX12_RESOURCE_DESC::Buffer(AllIndices.size() * sizeof(uint32_t));
		{
			mz_VHR(Gfx->Device->CreateCommittedResource(&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), D3D12_HEAP_FLAG_NONE, &Desc, D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&TempIndexBuffer)));
			OutTempResources->push_back(TempIndexBuffer);

			void* Addr;
			mz_VHR(TempIndexBuffer->Map(0, &CD3DX12_RANGE(0, 0), &Addr));
			memcpy(Addr, AllIndices.data(), AllIndices.size() * sizeof(uint32_t));
			TempIndexBuffer->Unmap(0, nullptr);
		}

		OutScene->IndexBuffer = mz_CreateCommittedResource(Gfx, D3D12_HEAP_TYPE_DEFAULT, D3D12_HEAP_FLAG_NONE, &Desc, D3D12_RESOURCE_STATE_COPY_DEST, nullptr);

		Gfx->CmdList->CopyResource(OutScene->IndexBuffer->Raw, TempIndexBuffer);

		mz_CmdTransitionBarrier(Gfx->CmdList, OutScene->IndexBuffer, D3D12_RESOURCE_STATE_NON_PIXEL_SHADER_RESOURCE);

		OutScene->IndexBufferSRV = mz_AllocateDescriptors(Gfx, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV, 1);

		D3D12_SHADER_RESOURCE_VIEW_DESC SRVDesc = {};
		SRVDesc.Format = DXGI_FORMAT_R32G32B32_UINT;
		SRVDesc.ViewDimension = D3D12_SRV_DIMENSION_BUFFER;
		SRVDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
		SRVDesc.Buffer.NumElements = (uint32_t)AllIndices.size() / 3;
		Gfx->Device->CreateShaderResourceView(OutScene->IndexBuffer->Raw, &SRVDesc, OutScene->IndexBufferSRV);
	}
}
",16167,True,2717.788278173311,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.
*
****/
// Robin, 4-22-98: Moved set_suicide_frame() here from player.cpp to allow us to 
//				   have one without a hardcoded player.mdl in tf_client.cpp

/*

===== client.cpp ========================================================

  client/server game specific stuff

*/

#include ""extdll.h""
#include ""util.h""
#include ""cbase.h""
#include ""saverestore.h""
#include ""player.h""
#include ""spectator.h""
#include ""client.h""
#include ""soundent.h""
#include ""gamerules.h""
#include ""game.h""
#include ""customentity.h""
#include ""weapons.h""
#include ""weaponinfo.h""
#include ""usercmd.h""
#include ""netadr.h""
#include ""pm_shared.h""
#include ""../cl_dll/ranking.h""

#if !defined ( _WIN32 )
#include <ctype.h>
#endif

extern DLL_GLOBAL ULONG		g_ulModelIndexPlayer;
extern DLL_GLOBAL BOOL		g_fGameOver;
extern DLL_GLOBAL int		g_iSkillLevel;
extern DLL_GLOBAL ULONG		g_ulFrameCount;

extern void CopyToBodyQue(entvars_t* pev);
extern int giPrecacheGrunt;
extern int gmsgSayText;

extern cvar_t allow_spectators;

extern int g_teamplay;

void LinkUserMessages( void );

/*
 * used by kill command and disconnect command
 * ROBIN: Moved here from player.cpp, to allow multiple player models
 */
void set_suicide_frame(entvars_t* pev)
{       
	if (!FStrEq(STRING(pev->model), ""models/player.mdl""))
		return; // allready gibbed

//	pev->frame		= $deatha11;
	pev->solid		= SOLID_NOT;
	pev->movetype	= MOVETYPE_TOSS;
	pev->deadflag	= DEAD_DEAD;
	pev->nextthink	= -1;
}


/*
===========
ClientConnect

called when a player connects to a server
============
*/
BOOL ClientConnect( edict_t *pEntity, const char *pszName, const char *pszAddress, char szRejectReason[ 128 ]  )
{	
	return g_pGameRules->ClientConnected( pEntity, pszName, pszAddress, szRejectReason );

// a client connecting during an intermission can cause problems
//	if (intermission_running)
//		ExitIntermission ();

}


/*
===========
ClientDisconnect

called when a player disconnects from a server

GLOBALS ASSUMED SET:  g_fGameOver
============
*/
void ClientDisconnect( edict_t *pEntity )
{
	if (g_fGameOver)
		return;

	char text[256] = """" ;
	if ( pEntity->v.netname )
		_snprintf( text, sizeof(text), ""- %s has left the game\\n"", STRING(pEntity->v.netname) );
	text[ sizeof(text) - 1 ] = 0;
	MESSAGE_BEGIN( MSG_ALL, gmsgSayText, NULL );
		WRITE_BYTE( ENTINDEX(pEntity) );
		WRITE_STRING( text );
	MESSAGE_END();

	CSound *pSound;
	pSound = CSoundEnt::SoundPointerForIndex( CSoundEnt::ClientSoundIndex( pEntity ) );
	{
		// since this client isn't around to think anymore, reset their sound. 
		if ( pSound )
		{
			pSound->Reset();
		}
	}

// since the edict doesn't get deleted, fix it so it doesn't interfere.
	pEntity->v.takedamage = DAMAGE_NO;// don't attract autoaim
	pEntity->v.solid = SOLID_NOT;// nonsolid
	UTIL_SetOrigin ( &pEntity->v, pEntity->v.origin );

	g_pGameRules->ClientDisconnected( pEntity );
}


// called by ClientKill and DeadThink
void respawn(entvars_t* pev, BOOL fCopyCorpse)
{
	if (gpGlobals->coop || gpGlobals->deathmatch)
	{
		if ( fCopyCorpse )
		{
			// make a copy of the dead body for appearances sake
			CopyToBodyQue(pev);
		}

		// respawn player
		GetClassPtr( (CBasePlayer *)pev)->Spawn( );
	}
	else
	{       // restart the entire server
		SERVER_COMMAND(""reload\\n"");
	}
}

/*
============
ClientKill

Player entered the suicide command

GLOBALS ASSUMED SET:  g_ulModelIndexPlayer
============
*/
void ClientKill( edict_t *pEntity )
{
	entvars_t *pev = &pEntity->v;

	CBasePlayer *pl = (CBasePlayer*) CBasePlayer::Instance( pev );

	if ( pl->m_fNextSuicideTime > gpGlobals->time )
		return;  // prevent suiciding too ofter

	pl->m_fNextSuicideTime = gpGlobals->time + 1;  // don't let them suicide for 5 seconds after suiciding

	// have the player kill themself
	pev->health = 0;
	pl->Killed( pev, GIB_NEVER );

//	pev->modelindex = g_ulModelIndexPlayer;
//	pev->frags -= 2;		// extra penalty
//	respawn( pev );
}

/*
===========
ClientPutInServer

called each time a player is spawned
============
*/
void ClientPutInServer( edict_t *pEntity )
{
	CBasePlayer *pPlayer;

	entvars_t *pev = &pEntity->v;

	pPlayer = GetClassPtr((CBasePlayer *)pev);
	pPlayer->SetCustomDecalFrames(-1); // Assume none;

	// Allocate a CBasePlayer for pev, and call spawn
	pPlayer->Spawn() ;

	// Reset interpolation during first frame
	pPlayer->pev->effects |= EF_NOINTERP;

	pPlayer->pev->iuser1 = 0;	// disable any spec modes
	pPlayer->pev->iuser2 = 0; 
}

#include ""voice_gamemgr.h""
extern CVoiceGameMgr g_VoiceGameMgr;



#if defined( _MSC_VER ) || defined( WIN32 )
typedef wchar_t	uchar16;
typedef unsigned int uchar32;
#else
typedef unsigned short uchar16;
typedef wchar_t uchar32;
#endif

//-----------------------------------------------------------------------------
// Purpose: determine if a uchar32 represents a valid Unicode code point
//-----------------------------------------------------------------------------
bool Q_IsValidUChar32( uchar32 uVal )
{
	// Values > 0x10FFFF are explicitly invalid; ditto for UTF-16 surrogate halves,
	// values ending in FFFE or FFFF, or values in the 0x00FDD0-0x00FDEF reserved range
	return ( uVal < 0x110000u ) && ( (uVal - 0x00D800u) > 0x7FFu ) && ( (uVal & 0xFFFFu) < 0xFFFEu ) && ( ( uVal - 0x00FDD0u ) > 0x1Fu );
}


// Decode one character from a UTF-8 encoded string. Treats 6-byte CESU-8 sequences
// as a single character, as if they were a correctly-encoded 4-byte UTF-8 sequence.
int Q_UTF8ToUChar32( const char *pUTF8_, uchar32 &uValueOut, bool &bErrorOut )
{
	const uint8 *pUTF8 = (const uint8 *)pUTF8_;
	
	int nBytes = 1;
	uint32 uValue = pUTF8[0];
	uint32 uMinValue = 0;
	
	// 0....... single byte
	if ( uValue < 0x80 )
		goto decodeFinishedNoCheck;
	
	// Expecting at least a two-byte sequence with 0xC0 <= first <= 0xF7 (110...... and 11110...)
	if ( (uValue - 0xC0u) > 0x37u || ( pUTF8[1] & 0xC0 ) != 0x80 )
		goto decodeError;
	
	uValue = (uValue << 6) - (0xC0 << 6) + pUTF8[1] - 0x80;
	nBytes = 2;
	uMinValue = 0x80;
	
	// 110..... two-byte lead byte
	if ( !( uValue & (0x20 << 6) ) )
		goto decodeFinished;
	
	// Expecting at least a three-byte sequence
	if ( ( pUTF8[2] & 0xC0 ) != 0x80 )
		goto decodeError;
	
	uValue = (uValue << 6) - (0x20 << 12) + pUTF8[2] - 0x80;
	nBytes = 3;
	uMinValue = 0x800;
	
	// 1110.... three-byte lead byte
	if ( !( uValue & (0x10 << 12) ) )
		goto decodeFinishedMaybeCESU8;
	
	// Expecting a four-byte sequence, longest permissible in UTF-8
	if ( ( pUTF8[3] & 0xC0 ) != 0x80 )
		goto decodeError;
	
	uValue = (uValue << 6) - (0x10 << 18) + pUTF8[3] - 0x80;
	nBytes = 4;
	uMinValue = 0x10000;
	
	// 11110... four-byte lead byte. fall through to finished.
	
decodeFinished:
	if ( uValue >= uMinValue && Q_IsValidUChar32( uValue ) )
	{
decodeFinishedNoCheck:
	uValueOut = uValue;
	bErrorOut = false;
	return nBytes;
	}
decodeError:
	uValueOut = '?';
	bErrorOut = true;
	return nBytes;
	
decodeFinishedMaybeCESU8:
	// Do we have a full UTF-16 surrogate pair that's been UTF-8 encoded afterwards?
	// That is, do we have 0xD800-0xDBFF followed by 0xDC00-0xDFFF? If so, decode it all.
	if ( ( uValue - 0xD800u ) < 0x400u && pUTF8[3] == 0xED && (uint8)( pUTF8[4] - 0xB0 ) < 0x10 && ( pUTF8[5] & 0xC0 ) == 0x80 )
	{
		uValue = 0x10000 + ( ( uValue - 0xD800u ) << 10 ) + ( (uint8)( pUTF8[4] - 0xB0 ) << 6 ) + pUTF8[5] - 0x80;
		nBytes = 6;
		uMinValue = 0x10000;
	}
	goto decodeFinished;
}



//-----------------------------------------------------------------------------
// Purpose: Returns true if UTF-8 string contains invalid sequences.
//-----------------------------------------------------------------------------
bool Q_UnicodeValidate( const char *pUTF8 )
{
	bool bError = false;
	while ( *pUTF8 )
	{
		uchar32 uVal;
		// Our UTF-8 decoder silently fixes up 6-byte CESU-8 (improperly re-encoded UTF-16) sequences.
		// However, these are technically not valid UTF-8. So if we eat 6 bytes at once, it's an error.
		int nCharSize = Q_UTF8ToUChar32( pUTF8, uVal, bError );
		if ( bError || nCharSize == 6 )
			return false;
		pUTF8 += nCharSize;
	}
	return true;
}

//// HOST_SAY
// String comes in as
// say blah blah blah
// or as
// blah blah blah
//
void Host_Say( edict_t *pEntity, int teamonly )
{
	CBasePlayer *client;
	int		j;
	char	*p;
	char	text[128];
	char    szTemp[256];
	const char *cpSay = ""say"";
	const char *cpSayTeam = ""say_team"";
	const char *pcmd = CMD_ARGV(0);

	// We can get a raw string now, without the ""say "" prepended
	if ( CMD_ARGC() == 0 )
		return;

	entvars_t *pev = &pEntity->v;
	CBasePlayer* player = GetClassPtr((CBasePlayer *)pev);

	//Not yet.
	if ( player->m_flNextChatTime > gpGlobals->time )
		 return;

	if ( !stricmp( pcmd, cpSay) || !stricmp( pcmd, cpSayTeam ) )
	{
		if ( CMD_ARGC() >= 2 )
		{
			p = (char *)CMD_ARGS();
		}
		else
		{
			// say with a blank message, nothing to do
			return;
		}
	}
	else  // Raw text, need to prepend argv[0]
	{
		if ( CMD_ARGC() >= 2 )
		{
			sprintf( szTemp, ""%s %s"", ( char * )pcmd, (char *)CMD_ARGS() );
		}
		else
		{
			// Just a one word command, use the first word...sigh
			sprintf( szTemp, ""%s"", ( char * )pcmd );
		}
		p = szTemp;
	}

// remove quotes if present
	if (*p == '""')
	{
		p++;
		p[strlen(p)-1] = 0;
	}

// make sure the text has content

	if ( !p || !p[0] || !Q_UnicodeValidate ( p ) )
		return;  // no character found, so say nothing

// turn on color set 2  (color on,  no sound)
	// turn on color set 2  (color on,  no sound)
	if ( player->IsObserver() && ( teamonly ) )
		sprintf( text, ""%c(SPEC) %s: "", 2, STRING( pEntity->v.netname ) );
	else if ( teamonly )
		sprintf( text, ""%c(TEAM) %s: "", 2, STRING( pEntity->v.netname ) );
	else
		sprintf( text, ""%c%s: "", 2, STRING( pEntity->v.netname ) );

	j = sizeof(text) - 2 - strlen(text);  // -2 for /n and null terminator
	if ( (int)strlen(p) > j )
		p[j] = 0;

	strcat( text, p );
	strcat( text, ""\\n"" );


	player->m_flNextChatTime = gpGlobals->time + CHAT_INTERVAL;

	// loop through all players
	// Start with the first player.
	// This may return the world in single player if the client types something between levels or during spawn
	// so check it, or it will infinite loop

	client = NULL;
	while ( ((client = (CBasePlayer*)UTIL_FindEntityByClassname( client, ""player"" )) != NULL) && (!FNullEnt(client->edict())) ) 
	{
		if ( !client->pev )
			continue;
		
		if ( client->edict() == pEntity )
			continue;

		if ( !(client->IsNetClient()) )	// Not a client ? (should never be true)
			continue;

		// can the receiver hear the sender? or has he muted him?
		if ( g_VoiceGameMgr.PlayerHasBlockedPlayer( client, player ) )
			continue;

		if ( !player->IsObserver() && teamonly && g_pGameRules->PlayerRelationship(client, CBaseEntity::Instance(pEntity)) != GR_TEAMMATE )
			continue;

		// Spectators can only talk to other specs
		if ( player->IsObserver() && teamonly )
			if ( !client->IsObserver() )
				continue;

		MESSAGE_BEGIN( MSG_ONE, gmsgSayText, NULL, client->pev );
			WRITE_BYTE( ENTINDEX(pEntity) );
			WRITE_STRING( text );
		MESSAGE_END();

	}

	// print to the sending client
	MESSAGE_BEGIN( MSG_ONE, gmsgSayText, NULL, &pEntity->v );
		WRITE_BYTE( ENTINDEX(pEntity) );
		WRITE_STRING( text );
	MESSAGE_END();

	// echo to server console
	g_engfuncs.pfnServerPrint( text );

	char * temp;
	if ( teamonly )
		temp = ""say_team"";
	else
		temp = ""say"";
	
	// team match?
	if ( g_teamplay )
	{
		UTIL_LogPrintf( ""\\""%s<%i><%s><%s>\\"" %s \\""%s\\""\\n"", 
			STRING( pEntity->v.netname ), 
			GETPLAYERUSERID( pEntity ),
			GETPLAYERAUTHID( pEntity ),
			g_engfuncs.pfnInfoKeyValue( g_engfuncs.pfnGetInfoKeyBuffer( pEntity ), ""model"" ),
			temp,
			p );
	}
	else
	{
		UTIL_LogPrintf( ""\\""%s<%i><%s><%i>\\"" %s \\""%s\\""\\n"", 
			STRING( pEntity->v.netname ), 
			GETPLAYERUSERID( pEntity ),
			GETPLAYERAUTHID( pEntity ),
			GETPLAYERUSERID( pEntity ),
			temp,
			p );
	}
}


/*
===========
ClientCommand
called each time a player uses a ""cmd"" command
============
*/
extern float g_flWeaponCheat;
extern DLL_GLOBAL float g_ClockFinish;
extern DLL_GLOBAL float g_ClockStart;
extern DLL_GLOBAL char g_szMapId[32];

// Use CMD_ARGV,  CMD_ARGV, and CMD_ARGC to get pointers the character string command.
void ClientCommand( edict_t *pEntity )
{
	const char *pcmd = CMD_ARGV(0);
	const char *pstr;

	// Is the client spawned yet?
	if ( !pEntity->pvPrivateData )
		return;

    entvars_t *pev = &pEntity->v;

    printf(""%s\\n"", pcmd);
	if ( FStrEq(pcmd, ""say"" ) )
	{
		Host_Say( pEntity, 0 );
	}
	else if ( FStrEq(pcmd, ""say_team"" ) )
	{
		Host_Say( pEntity, 1 );
	}
	else if ( FStrEq(pcmd, ""fullupdate"" ) )
	{
		GetClassPtr((CBasePlayer *)pev)->ForceClientDllUpdate(); 
	}
	else if ( FStrEq(pcmd, ""give"" ) )
	{
		if ( g_flWeaponCheat != 0.0)
		{
			int iszItem = ALLOC_STRING( CMD_ARGV(1) );	// Make a copy of the classname
			GetClassPtr((CBasePlayer *)pev)->GiveNamedItem( STRING(iszItem) );
		}
	}

	else if ( FStrEq(pcmd, ""drop"" ) )
	{
		// player is dropping an item. 
		GetClassPtr((CBasePlayer *)pev)->DropPlayerItem((char *)CMD_ARGV(1));
	}
	else if ( FStrEq(pcmd, ""fov"" ) )
	{
		if ( g_flWeaponCheat && CMD_ARGC() > 1)
		{
			GetClassPtr((CBasePlayer *)pev)->m_iFOV = atoi( CMD_ARGV(1) );
		}
		else
		{
			CLIENT_PRINTF( pEntity, print_console, UTIL_VarArgs( ""\\""fov\\"" is \\""%d\\""\\n"", (int)GetClassPtr((CBasePlayer *)pev)->m_iFOV ) );
		}
	}
	else if ( FStrEq(pcmd, ""use"" ) )
	{
		GetClassPtr((CBasePlayer *)pev)->SelectItem((char *)CMD_ARGV(1));
	}
	else if (((pstr = strstr(pcmd, ""weapon_"")) != NULL)  && (pstr == pcmd))
	{
		GetClassPtr((CBasePlayer *)pev)->SelectItem(pcmd);
	}
	else if (FStrEq(pcmd, ""lastinv"" ))
	{
		GetClassPtr((CBasePlayer *)pev)->SelectLastItem();
	}
	else if ( FStrEq( pcmd, ""spectate"" ) )	// clients wants to become a spectator
	{
			// always allow proxies to become a spectator
		if ( (pev->flags & FL_PROXY) || allow_spectators.value  )
		{
			CBasePlayer * pPlayer = GetClassPtr((CBasePlayer *)pev);

			edict_t *pentSpawnSpot = g_pGameRules->GetPlayerSpawnSpot( pPlayer );
			pPlayer->StartObserver( pev->origin, VARS(pentSpawnSpot)->angles);

			// notify other clients of player switching to spectator mode
			UTIL_ClientPrintAll( HUD_PRINTNOTIFY, UTIL_VarArgs( ""%s switched to spectator mode\\n"", 
			 	( pev->netname && STRING(pev->netname)[0] != 0 ) ? STRING(pev->netname) : ""unconnected"" ) );
		}
		else
			ClientPrint( pev, HUD_PRINTCONSOLE, ""Spectator mode is disabled.\\n"" );
			
	}	
	else if ( FStrEq( pcmd, ""specmode"" )  )	// new spectator mode
	{
		CBasePlayer * pPlayer = GetClassPtr((CBasePlayer *)pev);

		if ( pPlayer->IsObserver() )
			pPlayer->Observer_SetMode( atoi( CMD_ARGV(1) ) );
	}
	else if ( FStrEq(pcmd, ""closemenus"" ) )
	{
		// just ignore it
	}
	else if ( FStrEq( pcmd, ""follownext"" )  )	// follow next player
	{
		CBasePlayer * pPlayer = GetClassPtr((CBasePlayer *)pev);

		if ( pPlayer->IsObserver() )
			pPlayer->Observer_FindNextPlayer( atoi( CMD_ARGV(1) )?true:false );
    }
    else if ( FStrEq(pcmd, ""update_map_ranking"" ) )
    {
//        g_Ranking.GetMapRanking(""localhost:55032"");
    }
    else if ( FStrEq(pcmd, ""submit_score"" ) )
    {
        if (CMD_ARGC() > 1)
        {
            float f = float((g_ClockFinish - g_ClockStart) * 1000.0f);

            Ranking::SubmitScore(int(f), g_szMapId, CMD_ARGV(1));
        }
        else
            printf(""no playerid\\n"");
    }
	else if ( g_pGameRules->ClientCommand( GetClassPtr((CBasePlayer *)pev), pcmd ) )
	{
		// MenuSelect returns true only if the command is properly handled,  so don't print a warning
	}
	else
	{
		// tell the user they entered an unknown command
		char command[128];

		// check the length of the command (prevents crash)
		// max total length is 192 ...and we're adding a string below (""Unknown command: %s\\n"")
		strncpy( command, pcmd, 127 );
		command[127] = '\\0';

		// tell the user they entered an unknown command
		ClientPrint( &pEntity->v, HUD_PRINTCONSOLE, UTIL_VarArgs( ""Unknown command: %s\\n"", command ) );
	}
}


/*
========================
ClientUserInfoChanged

called after the player changes
userinfo - gives dll a chance to modify it before
it gets sent into the rest of the engine.
========================
*/
void ClientUserInfoChanged( edict_t *pEntity, char *infobuffer )
{
	// Is the client spawned yet?
	if ( !pEntity->pvPrivateData )
		return;

	// msg everyone if someone changes their name,  and it isn't the first time (changing no name to current name)
	if ( pEntity->v.netname && STRING(pEntity->v.netname)[0] != 0 && !FStrEq( STRING(pEntity->v.netname), g_engfuncs.pfnInfoKeyValue( infobuffer, ""name"" )) )
	{
		char sName[256];
		char *pName = g_engfuncs.pfnInfoKeyValue( infobuffer, ""name"" );
		strncpy( sName, pName, sizeof(sName) - 1 );
		sName[ sizeof(sName) - 1 ] = '\\0';

		// First parse the name and remove any %'s
		for ( char *pApersand = sName; pApersand != NULL && *pApersand != 0; pApersand++ )
		{
			// Replace it with a space
			if ( *pApersand == '%' )
				*pApersand = ' ';
		}

		// Set the name
		g_engfuncs.pfnSetClientKeyValue( ENTINDEX(pEntity), infobuffer, ""name"", sName );

		if (gpGlobals->maxClients > 1)
		{
			char text[256];
			sprintf( text, ""* %s changed name to %s\\n"", STRING(pEntity->v.netname), g_engfuncs.pfnInfoKeyValue( infobuffer, ""name"" ) );
			MESSAGE_BEGIN( MSG_ALL, gmsgSayText, NULL );
				WRITE_BYTE( ENTINDEX(pEntity) );
				WRITE_STRING( text );
			MESSAGE_END();
		}

		// team match?
		if ( g_teamplay )
		{
			UTIL_LogPrintf( ""\\""%s<%i><%s><%s>\\"" changed name to \\""%s\\""\\n"", 
				STRING( pEntity->v.netname ), 
				GETPLAYERUSERID( pEntity ), 
				GETPLAYERAUTHID( pEntity ),
				g_engfuncs.pfnInfoKeyValue( infobuffer, ""model"" ), 
				g_engfuncs.pfnInfoKeyValue( infobuffer, ""name"" ) );
		}
		else
		{
			UTIL_LogPrintf( ""\\""%s<%i><%s><%i>\\"" changed name to \\""%s\\""\\n"", 
				STRING( pEntity->v.netname ), 
				GETPLAYERUSERID( pEntity ), 
				GETPLAYERAUTHID( pEntity ),
				GETPLAYERUSERID( pEntity ), 
				g_engfuncs.pfnInfoKeyValue( infobuffer, ""name"" ) );
		}
	}

	g_pGameRules->ClientUserInfoChanged( GetClassPtr((CBasePlayer *)&pEntity->v), infobuffer );
}

static int g_serveractive = 0;

void ServerDeactivate( void )
{
	// It's possible that the engine will call this function more times than is necessary
	//  Therefore, only run it one time for each call to ServerActivate 
	if ( g_serveractive != 1 )
	{
		return;
	}

	g_serveractive = 0;

	// Peform any shutdown operations here...
	//
}

void ServerActivate( edict_t *pEdictList, int edictCount, int clientMax )
{
	int				i;
	CBaseEntity		*pClass;

	// Every call to ServerActivate should be matched by a call to ServerDeactivate
	g_serveractive = 1;

	// Clients have not been initialized yet
	for ( i = 0; i < edictCount; i++ )
	{
		if ( pEdictList[i].free )
			continue;
		
		// Clients aren't necessarily initialized until ClientPutInServer()
		if ( i < clientMax || !pEdictList[i].pvPrivateData )
			continue;

		pClass = CBaseEntity::Instance( &pEdictList[i] );
		// Activate this entity if it's got a class & isn't dormant
		if ( pClass && !(pClass->pev->flags & FL_DORMANT) )
		{
			pClass->Activate();
		}
		else
		{
			ALERT( at_console, ""Can't instance %s\\n"", STRING(pEdictList[i].v.classname) );
		}
	}

	// Link user messages here to make sure first client can get them...
	LinkUserMessages();
}


/*
================
PlayerPreThink

Called every frame before physics are run
================
*/
void PlayerPreThink( edict_t *pEntity )
{
	entvars_t *pev = &pEntity->v;
	CBasePlayer *pPlayer = (CBasePlayer *)GET_PRIVATE(pEntity);

	if (pPlayer)
		pPlayer->PreThink( );
}

/*
================
PlayerPostThink

Called every frame after physics are run
================
*/
void PlayerPostThink( edict_t *pEntity )
{
	entvars_t *pev = &pEntity->v;
	CBasePlayer *pPlayer = (CBasePlayer *)GET_PRIVATE(pEntity);

	if (pPlayer)
		pPlayer->PostThink( );
}



void ParmsNewLevel( void )
{
}


void ParmsChangeLevel( void )
{
	// retrieve the pointer to the save data
	SAVERESTOREDATA *pSaveData = (SAVERESTOREDATA *)gpGlobals->pSaveData;

	if ( pSaveData )
		pSaveData->connectionCount = BuildChangeList( pSaveData->levelList, MAX_LEVEL_CONNECTIONS );
}


//
// GLOBALS ASSUMED SET:  g_ulFrameCount
//
void StartFrame( void )
{
	if ( g_pGameRules )
		g_pGameRules->Think();

	if ( g_fGameOver )
		return;

	gpGlobals->teamplay = teamplay.value;
	g_ulFrameCount++;
}


void ClientPrecache( void )
{
	// setup precaches always needed
	PRECACHE_SOUND(""player/sprayer.wav"");			// spray paint sound for PreAlpha
	
	// PRECACHE_SOUND(""player/pl_jumpland2.wav"");		// UNDONE: play 2x step sound
	
	PRECACHE_SOUND(""player/pl_fallpain2.wav"");		
	PRECACHE_SOUND(""player/pl_fallpain3.wav"");		
	
	PRECACHE_SOUND(""player/pl_step1.wav"");		// walk on concrete
	PRECACHE_SOUND(""player/pl_step2.wav"");
	PRECACHE_SOUND(""player/pl_step3.wav"");
	PRECACHE_SOUND(""player/pl_step4.wav"");

	PRECACHE_SOUND(""common/npc_step1.wav"");		// NPC walk on concrete
	PRECACHE_SOUND(""common/npc_step2.wav"");
	PRECACHE_SOUND(""common/npc_step3.wav"");
	PRECACHE_SOUND(""common/npc_step4.wav"");

	PRECACHE_SOUND(""player/pl_metal1.wav"");		// walk on metal
	PRECACHE_SOUND(""player/pl_metal2.wav"");
	PRECACHE_SOUND(""player/pl_metal3.wav"");
	PRECACHE_SOUND(""player/pl_metal4.wav"");

	PRECACHE_SOUND(""player/pl_dirt1.wav"");		// walk on dirt
	PRECACHE_SOUND(""player/pl_dirt2.wav"");
	PRECACHE_SOUND(""player/pl_dirt3.wav"");
	PRECACHE_SOUND(""player/pl_dirt4.wav"");

	PRECACHE_SOUND(""player/pl_duct1.wav"");		// walk in duct
	PRECACHE_SOUND(""player/pl_duct2.wav"");
	PRECACHE_SOUND(""player/pl_duct3.wav"");
	PRECACHE_SOUND(""player/pl_duct4.wav"");

	PRECACHE_SOUND(""player/pl_grate1.wav"");		// walk on grate
	PRECACHE_SOUND(""player/pl_grate2.wav"");
	PRECACHE_SOUND(""player/pl_grate3.wav"");
	PRECACHE_SOUND(""player/pl_grate4.wav"");

	PRECACHE_SOUND(""player/pl_slosh1.wav"");		// walk in shallow water
	PRECACHE_SOUND(""player/pl_slosh2.wav"");
	PRECACHE_SOUND(""player/pl_slosh3.wav"");
	PRECACHE_SOUND(""player/pl_slosh4.wav"");

	PRECACHE_SOUND(""player/pl_tile1.wav"");		// walk on tile
	PRECACHE_SOUND(""player/pl_tile2.wav"");
	PRECACHE_SOUND(""player/pl_tile3.wav"");
	PRECACHE_SOUND(""player/pl_tile4.wav"");
	PRECACHE_SOUND(""player/pl_tile5.wav"");

	PRECACHE_SOUND(""player/pl_swim1.wav"");		// breathe bubbles
	PRECACHE_SOUND(""player/pl_swim2.wav"");
	PRECACHE_SOUND(""player/pl_swim3.wav"");
	PRECACHE_SOUND(""player/pl_swim4.wav"");

	PRECACHE_SOUND(""player/pl_ladder1.wav"");	// climb ladder rung
	PRECACHE_SOUND(""player/pl_ladder2.wav"");
	PRECACHE_SOUND(""player/pl_ladder3.wav"");
	PRECACHE_SOUND(""player/pl_ladder4.wav"");

	PRECACHE_SOUND(""player/pl_wade1.wav"");		// wade in water
	PRECACHE_SOUND(""player/pl_wade2.wav"");
	PRECACHE_SOUND(""player/pl_wade3.wav"");
	PRECACHE_SOUND(""player/pl_wade4.wav"");

	PRECACHE_SOUND(""debris/wood1.wav"");			// hit wood texture
	PRECACHE_SOUND(""debris/wood2.wav"");
	PRECACHE_SOUND(""debris/wood3.wav"");

	PRECACHE_SOUND(""plats/train_use1.wav"");		// use a train

	PRECACHE_SOUND(""buttons/spark5.wav"");		// hit computer texture
	PRECACHE_SOUND(""buttons/spark6.wav"");
	PRECACHE_SOUND(""debris/glass1.wav"");
	PRECACHE_SOUND(""debris/glass2.wav"");
	PRECACHE_SOUND(""debris/glass3.wav"");

	PRECACHE_SOUND( SOUND_FLASHLIGHT_ON );
	PRECACHE_SOUND( SOUND_FLASHLIGHT_OFF );

// player gib sounds
	PRECACHE_SOUND(""common/bodysplat.wav"");		               

// player pain sounds
	PRECACHE_SOUND(""player/pl_pain2.wav"");
	PRECACHE_SOUND(""player/pl_pain4.wav"");
	PRECACHE_SOUND(""player/pl_pain5.wav"");
	PRECACHE_SOUND(""player/pl_pain6.wav"");
	PRECACHE_SOUND(""player/pl_pain7.wav"");

	PRECACHE_MODEL(""models/player.mdl"");

	// hud sounds

	PRECACHE_SOUND(""common/wpn_hudoff.wav"");
	PRECACHE_SOUND(""common/wpn_hudon.wav"");
	PRECACHE_SOUND(""common/wpn_moveselect.wav"");
	PRECACHE_SOUND(""common/wpn_select.wav"");
	PRECACHE_SOUND(""common/wpn_denyselect.wav"");


	// geiger sounds

	PRECACHE_SOUND(""player/geiger6.wav"");
	PRECACHE_SOUND(""player/geiger5.wav"");
	PRECACHE_SOUND(""player/geiger4.wav"");
	PRECACHE_SOUND(""player/geiger3.wav"");
	PRECACHE_SOUND(""player/geiger2.wav"");
	PRECACHE_SOUND(""player/geiger1.wav"");

	if (giPrecacheGrunt)
		UTIL_PrecacheOther(""monster_human_grunt"");
}

/*
===============
GetGameDescription

Returns the descriptive name of this .dll.  E.g., Half-Life, or Team Fortress 2
===============
*/
const char *GetGameDescription()
{
	if ( g_pGameRules ) // this function may be called before the world has spawned, and the game rules initialized
		return g_pGameRules->GetGameDescription();
	else
		return ""Half-Life"";
}

/*
================
Sys_Error

Engine is going to shut down, allows setting a breakpoint in game .dll to catch that occasion
================
*/
void Sys_Error( const char *error_string )
{
	// Default case, do nothing.  MOD AUTHORS:  Add code ( e.g., _asm { int 3 }; here to cause a breakpoint for debugging your game .dlls
}

/*
================
PlayerCustomization

A new player customization has been registered on the server
UNDONE:  This only sets the # of frames of the spray can logo
animation right now.
================
*/
void PlayerCustomization( edict_t *pEntity, customization_t *pCust )
{
	entvars_t *pev = &pEntity->v;
	CBasePlayer *pPlayer = (CBasePlayer *)GET_PRIVATE(pEntity);

	if (!pPlayer)
	{
		ALERT(at_console, ""PlayerCustomization:  Couldn't get player!\\n"");
		return;
	}

	if (!pCust)
	{
		ALERT(at_console, ""PlayerCustomization:  NULL customization!\\n"");
		return;
	}

	switch (pCust->resource.type)
	{
	case t_decal:
		pPlayer->SetCustomDecalFrames(pCust->nUserData2); // Second int is max # of frames.
		break;
	case t_sound:
	case t_skin:
	case t_model:
		// Ignore for now.
		break;
	default:
		ALERT(at_console, ""PlayerCustomization:  Unknown customization type!\\n"");
		break;
	}
}

/*
================
SpectatorConnect

A spectator has joined the game
================
*/
void SpectatorConnect( edict_t *pEntity )
{
	entvars_t *pev = &pEntity->v;
	CBaseSpectator *pPlayer = (CBaseSpectator *)GET_PRIVATE(pEntity);

	if (pPlayer)
		pPlayer->SpectatorConnect( );
}

/*
================
SpectatorConnect

A spectator has left the game
================
*/
void SpectatorDisconnect( edict_t *pEntity )
{
	entvars_t *pev = &pEntity->v;
	CBaseSpectator *pPlayer = (CBaseSpectator *)GET_PRIVATE(pEntity);

	if (pPlayer)
		pPlayer->SpectatorDisconnect( );
}

/*
================
SpectatorConnect

A spectator has sent a usercmd
================
*/
void SpectatorThink( edict_t *pEntity )
{
	entvars_t *pev = &pEntity->v;
	CBaseSpectator *pPlayer = (CBaseSpectator *)GET_PRIVATE(pEntity);

	if (pPlayer)
		pPlayer->SpectatorThink( );
}

////////////////////////////////////////////////////////
// PAS and PVS routines for client messaging
//

/*
================
SetupVisibility

A client can have a separate ""view entity"" indicating that his/her view should depend on the origin of that
view entity.  If that's the case, then pViewEntity will be non-NULL and will be used.  Otherwise, the current
entity's origin is used.  Either is offset by the view_ofs to get the eye position.

From the eye position, we set up the PAS and PVS to use for filtering network messages to the client.  At this point, we could
 override the actual PAS or PVS values, or use a different origin.

NOTE:  Do not cache the values of pas and pvs, as they depend on reusable memory in the engine, they are only good for this one frame
================
*/
void SetupVisibility( edict_t *pViewEntity, edict_t *pClient, unsigned char **pvs, unsigned char **pas )
{
	Vector org;
	edict_t *pView = pClient;

	// Find the client's PVS
	if ( pViewEntity )
	{
		pView = pViewEntity;
	}

	if ( pClient->v.flags & FL_PROXY )
	{
		*pvs = NULL;	// the spectator proxy sees
		*pas = NULL;	// and hears everything
		return;
	}

	org = pView->v.origin + pView->v.view_ofs;
	if ( pView->v.flags & FL_DUCKING )
	{
		org = org + ( VEC_HULL_MIN - VEC_DUCK_HULL_MIN );
	}

	*pvs = ENGINE_SET_PVS ( (float *)&org );
	*pas = ENGINE_SET_PAS ( (float *)&org );
}

#include ""entity_state.h""

/*
AddToFullPack

Return 1 if the entity state has been filled in for the ent and the entity will be propagated to the client, 0 otherwise

state is the server maintained copy of the state info that is transmitted to the client
a MOD could alter values copied into state to send the ""host"" a different look for a particular entity update, etc.
e and ent are the entity that is being added to the update, if 1 is returned
host is the player's edict of the player whom we are sending the update to
player is 1 if the ent/e is a player and 0 otherwise
pSet is either the PAS or PVS that we previous set up.  We can use it to ask the engine to filter the entity against the PAS or PVS.
we could also use the pas/ pvs that we set in SetupVisibility, if we wanted to.  Caching the value is valid in that case, but still only for the current frame
*/
int AddToFullPack( struct entity_state_s *state, int e, edict_t *ent, edict_t *host, int hostflags, int player, unsigned char *pSet )
{
	int					i;

	// don't send if flagged for NODRAW and it's not the host getting the message
	if ( ( ent->v.effects & EF_NODRAW ) &&
		 ( ent != host ) )
		return 0;

	// Ignore ents without valid / visible models
	if ( !ent->v.modelindex || !STRING( ent->v.model ) )
		return 0;

	// Don't send spectators to other players
	if ( ( ent->v.flags & FL_SPECTATOR ) && ( ent != host ) )
	{
		return 0;
	}

	// Ignore if not the host and not touching a PVS/PAS leaf
	// If pSet is NULL, then the test will always succeed and the entity will be added to the update
	if ( ent != host )
	{
		if ( !ENGINE_CHECK_VISIBILITY( (const struct edict_s *)ent, pSet ) )
		{
			return 0;
		}
	}


	// Don't send entity to local client if the client says it's predicting the entity itself.
	if ( ent->v.flags & FL_SKIPLOCALHOST )
	{
		if ( ( hostflags & 1 ) && ( ent->v.owner == host ) )
			return 0;
	}
	
	if ( host->v.groupinfo )
	{
		UTIL_SetGroupTrace( host->v.groupinfo, GROUP_OP_AND );

		// Should always be set, of course
		if ( ent->v.groupinfo )
		{
			if ( g_groupop == GROUP_OP_AND )
			{
				if ( !(ent->v.groupinfo & host->v.groupinfo ) )
					return 0;
			}
			else if ( g_groupop == GROUP_OP_NAND )
			{
				if ( ent->v.groupinfo & host->v.groupinfo )
					return 0;
			}
		}

		UTIL_UnsetGroupTrace();
	}

	memset( state, 0, sizeof( *state ) );

	// Assign index so we can track this entity from frame to frame and
	//  delta from it.
	state->number	  = e;
	state->entityType = ENTITY_NORMAL;
	
	// Flag custom entities.
	if ( ent->v.flags & FL_CUSTOMENTITY )
	{
		state->entityType = ENTITY_BEAM;
	}

	// 
	// Copy state data
	//

	// Round animtime to nearest millisecond
	state->animtime   = (int)(1000.0 * ent->v.animtime ) / 1000.0;

	memcpy( state->origin, ent->v.origin, 3 * sizeof( float ) );
	memcpy( state->angles, ent->v.angles, 3 * sizeof( float ) );
	memcpy( state->mins, ent->v.mins, 3 * sizeof( float ) );
	memcpy( state->maxs, ent->v.maxs, 3 * sizeof( float ) );

	memcpy( state->startpos, ent->v.startpos, 3 * sizeof( float ) );
	memcpy( state->endpos, ent->v.endpos, 3 * sizeof( float ) );

	state->impacttime = ent->v.impacttime;
	state->starttime = ent->v.starttime;

	state->modelindex = ent->v.modelindex;
		
	state->frame      = ent->v.frame;

	state->skin       = ent->v.skin;
	state->effects    = ent->v.effects;

	// This non-player entity is being moved by the game .dll and not the physics simulation system
	//  make sure that we interpolate it's position on the client if it moves
	if ( !player &&
		 ent->v.animtime &&
		 ent->v.velocity[ 0 ] == 0 && 
		 ent->v.velocity[ 1 ] == 0 && 
		 ent->v.velocity[ 2 ] == 0 )
	{
		state->eflags |= EFLAG_SLERP;
	}

	state->scale	  = ent->v.scale;
	state->solid	  = ent->v.solid;
	state->colormap   = ent->v.colormap;

	state->movetype   = ent->v.movetype;
	state->sequence   = ent->v.sequence;
	state->framerate  = ent->v.framerate;
	state->body       = ent->v.body;

	for (i = 0; i < 4; i++)
	{
		state->controller[i] = ent->v.controller[i];
	}

	for (i = 0; i < 2; i++)
	{
		state->blending[i]   = ent->v.blending[i];
	}

	state->rendermode    = ent->v.rendermode;
	state->renderamt     = ent->v.renderamt; 
	state->renderfx      = ent->v.renderfx;
	state->rendercolor.r = ent->v.rendercolor.x;
	state->rendercolor.g = ent->v.rendercolor.y;
	state->rendercolor.b = ent->v.rendercolor.z;

	state->aiment = 0;
	if ( ent->v.aiment )
	{
		state->aiment = ENTINDEX( ent->v.aiment );
	}

	state->owner = 0;
	if ( ent->v.owner )
	{
		int owner = ENTINDEX( ent->v.owner );
		
		// Only care if owned by a player
		if ( owner >= 1 && owner <= gpGlobals->maxClients )
		{
			state->owner = owner;	
		}
	}

	// HACK:  Somewhat...
	// Class is overridden for non-players to signify a breakable glass object ( sort of a class? )
	if ( !player )
	{
		state->playerclass  = ent->v.playerclass;
	}

	// Special stuff for players only
	if ( player )
	{
		memcpy( state->basevelocity, ent->v.basevelocity, 3 * sizeof( float ) );

		state->weaponmodel  = MODEL_INDEX( STRING( ent->v.weaponmodel ) );
		state->gaitsequence = ent->v.gaitsequence;
		state->spectator = ent->v.flags & FL_SPECTATOR;
		state->friction     = ent->v.friction;

		state->gravity      = ent->v.gravity;
//		state->team			= ent->v.team;
//		
		state->usehull      = ( ent->v.flags & FL_DUCKING ) ? 1 : 0;
		state->health		= ent->v.health;
	}

	return 1;
}

// defaults for clientinfo messages
#define	DEFAULT_VIEWHEIGHT	28

/*
===================
CreateBaseline

Creates baselines used for network encoding, especially for player data since players are not spawned until connect time.
===================
*/
void CreateBaseline( int player, int eindex, struct entity_state_s *baseline, struct edict_s *entity, int playermodelindex, vec3_t player_mins, vec3_t player_maxs )
{
	baseline->origin		= entity->v.origin;
	baseline->angles		= entity->v.angles;
	baseline->frame			= entity->v.frame;
	baseline->skin			= (short)entity->v.skin;

	// render information
	baseline->rendermode	= (byte)entity->v.rendermode;
	baseline->renderamt		= (byte)entity->v.renderamt;
	baseline->rendercolor.r	= (byte)entity->v.rendercolor.x;
	baseline->rendercolor.g	= (byte)entity->v.rendercolor.y;
	baseline->rendercolor.b	= (byte)entity->v.rendercolor.z;
	baseline->renderfx		= (byte)entity->v.renderfx;

	if ( player )
	{
		baseline->mins			= player_mins;
		baseline->maxs			= player_maxs;

		baseline->colormap		= eindex;
		baseline->modelindex	= playermodelindex;
		baseline->friction		= 1.0;
		baseline->movetype		= MOVETYPE_WALK;

		baseline->scale			= entity->v.scale;
		baseline->solid			= SOLID_SLIDEBOX;
		baseline->framerate		= 1.0;
		baseline->gravity		= 1.0;

	}
	else
	{
		baseline->mins			= entity->v.mins;
		baseline->maxs			= entity->v.maxs;

		baseline->colormap		= 0;
		baseline->modelindex	= entity->v.modelindex;//SV_ModelIndex(pr_strings + entity->v.model);
		baseline->movetype		= entity->v.movetype;

		baseline->scale			= entity->v.scale;
		baseline->solid			= entity->v.solid;
		baseline->framerate		= entity->v.framerate;
		baseline->gravity		= entity->v.gravity;
	}
}

typedef struct
{
	char name[32];
	int	 field;
} entity_field_alias_t;

#define FIELD_ORIGIN0			0
#define FIELD_ORIGIN1			1
#define FIELD_ORIGIN2			2
#define FIELD_ANGLES0			3
#define FIELD_ANGLES1			4
#define FIELD_ANGLES2			5

static entity_field_alias_t entity_field_alias[]=
{
	{ ""origin[0]"",			0 },
	{ ""origin[1]"",			0 },
	{ ""origin[2]"",			0 },
	{ ""angles[0]"",			0 },
	{ ""angles[1]"",			0 },
	{ ""angles[2]"",			0 },
};

void Entity_FieldInit( struct delta_s *pFields )
{
	entity_field_alias[ FIELD_ORIGIN0 ].field		= DELTA_FINDFIELD( pFields, entity_field_alias[ FIELD_ORIGIN0 ].name );
	entity_field_alias[ FIELD_ORIGIN1 ].field		= DELTA_FINDFIELD( pFields, entity_field_alias[ FIELD_ORIGIN1 ].name );
	entity_field_alias[ FIELD_ORIGIN2 ].field		= DELTA_FINDFIELD( pFields, entity_field_alias[ FIELD_ORIGIN2 ].name );
	entity_field_alias[ FIELD_ANGLES0 ].field		= DELTA_FINDFIELD( pFields, entity_field_alias[ FIELD_ANGLES0 ].name );
	entity_field_alias[ FIELD_ANGLES1 ].field		= DELTA_FINDFIELD( pFields, entity_field_alias[ FIELD_ANGLES1 ].name );
	entity_field_alias[ FIELD_ANGLES2 ].field		= DELTA_FINDFIELD( pFields, entity_field_alias[ FIELD_ANGLES2 ].name );
}

/*
==================
Entity_Encode

Callback for sending entity_state_t info over network. 
FIXME:  Move to script
==================
*/
void Entity_Encode( struct delta_s *pFields, const unsigned char *from, const unsigned char *to )
{
	entity_state_t *f, *t;
	int localplayer = 0;
	static int initialized = 0;

	if ( !initialized )
	{
		Entity_FieldInit( pFields );
		initialized = 1;
	}

	f = (entity_state_t *)from;
	t = (entity_state_t *)to;

	// Never send origin to local player, it's sent with more resolution in clientdata_t structure
	localplayer =  ( t->number - 1 ) == ENGINE_CURRENT_PLAYER();
	if ( localplayer )
	{
		DELTA_UNSETBYINDEX( pFields, entity_field_alias[ FIELD_ORIGIN0 ].field );
		DELTA_UNSETBYINDEX( pFields, entity_field_alias[ FIELD_ORIGIN1 ].field );
		DELTA_UNSETBYINDEX( pFields, entity_field_alias[ FIELD_ORIGIN2 ].field );
	}

	if ( ( t->impacttime != 0 ) && ( t->starttime != 0 ) )
	{
		DELTA_UNSETBYINDEX( pFields, entity_field_alias[ FIELD_ORIGIN0 ].field );
		DELTA_UNSETBYINDEX( pFields, entity_field_alias[ FIELD_ORIGIN1 ].field );
		DELTA_UNSETBYINDEX( pFields, entity_field_alias[ FIELD_ORIGIN2 ].field );

		DELTA_UNSETBYINDEX( pFields, entity_field_alias[ FIELD_ANGLES0 ].field );
		DELTA_UNSETBYINDEX( pFields, entity_field_alias[ FIELD_ANGLES1 ].field );
		DELTA_UNSETBYINDEX( pFields, entity_field_alias[ FIELD_ANGLES2 ].field );
	}

	if ( ( t->movetype == MOVETYPE_FOLLOW ) &&
		 ( t->aiment != 0 ) )
	{
		DELTA_UNSETBYINDEX( pFields, entity_field_alias[ FIELD_ORIGIN0 ].field );
		DELTA_UNSETBYINDEX( pFields, entity_field_alias[ FIELD_ORIGIN1 ].field );
		DELTA_UNSETBYINDEX( pFields, entity_field_alias[ FIELD_ORIGIN2 ].field );
	}
	else if ( t->aiment != f->aiment )
	{
		DELTA_SETBYINDEX( pFields, entity_field_alias[ FIELD_ORIGIN0 ].field );
		DELTA_SETBYINDEX( pFields, entity_field_alias[ FIELD_ORIGIN1 ].field );
		DELTA_SETBYINDEX( pFields, entity_field_alias[ FIELD_ORIGIN2 ].field );
	}
}

static entity_field_alias_t player_field_alias[]=
{
	{ ""origin[0]"",			0 },
	{ ""origin[1]"",			0 },
	{ ""origin[2]"",			0 },
};

void Player_FieldInit( struct delta_s *pFields )
{
	player_field_alias[ FIELD_ORIGIN0 ].field		= DELTA_FINDFIELD( pFields, player_field_alias[ FIELD_ORIGIN0 ].name );
	player_field_alias[ FIELD_ORIGIN1 ].field		= DELTA_FINDFIELD( pFields, player_field_alias[ FIELD_ORIGIN1 ].name );
	player_field_alias[ FIELD_ORIGIN2 ].field		= DELTA_FINDFIELD( pFields, player_field_alias[ FIELD_ORIGIN2 ].name );
}

/*
==================
Player_Encode

Callback for sending entity_state_t for players info over network. 
==================
*/
void Player_Encode( struct delta_s *pFields, const unsigned char *from, const unsigned char *to )
{
	entity_state_t *f, *t;
	int localplayer = 0;
	static int initialized = 0;

	if ( !initialized )
	{
		Player_FieldInit( pFields );
		initialized = 1;
	}

	f = (entity_state_t *)from;
	t = (entity_state_t *)to;

	// Never send origin to local player, it's sent with more resolution in clientdata_t structure
	localplayer =  ( t->number - 1 ) == ENGINE_CURRENT_PLAYER();
	if ( localplayer )
	{
		DELTA_UNSETBYINDEX( pFields, entity_field_alias[ FIELD_ORIGIN0 ].field );
		DELTA_UNSETBYINDEX( pFields, entity_field_alias[ FIELD_ORIGIN1 ].field );
		DELTA_UNSETBYINDEX( pFields, entity_field_alias[ FIELD_ORIGIN2 ].field );
	}

	if ( ( t->movetype == MOVETYPE_FOLLOW ) &&
		 ( t->aiment != 0 ) )
	{
		DELTA_UNSETBYINDEX( pFields, entity_field_alias[ FIELD_ORIGIN0 ].field );
		DELTA_UNSETBYINDEX( pFields, entity_field_alias[ FIELD_ORIGIN1 ].field );
		DELTA_UNSETBYINDEX( pFields, entity_field_alias[ FIELD_ORIGIN2 ].field );
	}
	else if ( t->aiment != f->aiment )
	{
		DELTA_SETBYINDEX( pFields, entity_field_alias[ FIELD_ORIGIN0 ].field );
		DELTA_SETBYINDEX( pFields, entity_field_alias[ FIELD_ORIGIN1 ].field );
		DELTA_SETBYINDEX( pFields, entity_field_alias[ FIELD_ORIGIN2 ].field );
	}
}

#define CUSTOMFIELD_ORIGIN0			0
#define CUSTOMFIELD_ORIGIN1			1
#define CUSTOMFIELD_ORIGIN2			2
#define CUSTOMFIELD_ANGLES0			3
#define CUSTOMFIELD_ANGLES1			4
#define CUSTOMFIELD_ANGLES2			5
#define CUSTOMFIELD_SKIN			6
#define CUSTOMFIELD_SEQUENCE		7
#define CUSTOMFIELD_ANIMTIME		8

entity_field_alias_t custom_entity_field_alias[]=
{
	{ ""origin[0]"",			0 },
	{ ""origin[1]"",			0 },
	{ ""origin[2]"",			0 },
	{ ""angles[0]"",			0 },
	{ ""angles[1]"",			0 },
	{ ""angles[2]"",			0 },
	{ ""skin"",				0 },
	{ ""sequence"",			0 },
	{ ""animtime"",			0 },
};

void Custom_Entity_FieldInit( struct delta_s *pFields )
{
	custom_entity_field_alias[ CUSTOMFIELD_ORIGIN0 ].field	= DELTA_FINDFIELD( pFields, custom_entity_field_alias[ CUSTOMFIELD_ORIGIN0 ].name );
	custom_entity_field_alias[ CUSTOMFIELD_ORIGIN1 ].field	= DELTA_FINDFIELD( pFields, custom_entity_field_alias[ CUSTOMFIELD_ORIGIN1 ].name );
	custom_entity_field_alias[ CUSTOMFIELD_ORIGIN2 ].field	= DELTA_FINDFIELD( pFields, custom_entity_field_alias[ CUSTOMFIELD_ORIGIN2 ].name );
	custom_entity_field_alias[ CUSTOMFIELD_ANGLES0 ].field	= DELTA_FINDFIELD( pFields, custom_entity_field_alias[ CUSTOMFIELD_ANGLES0 ].name );
	custom_entity_field_alias[ CUSTOMFIELD_ANGLES1 ].field	= DELTA_FINDFIELD( pFields, custom_entity_field_alias[ CUSTOMFIELD_ANGLES1 ].name );
	custom_entity_field_alias[ CUSTOMFIELD_ANGLES2 ].field	= DELTA_FINDFIELD( pFields, custom_entity_field_alias[ CUSTOMFIELD_ANGLES2 ].name );
	custom_entity_field_alias[ CUSTOMFIELD_SKIN ].field	= DELTA_FINDFIELD( pFields, custom_entity_field_alias[ CUSTOMFIELD_SKIN ].name );
	custom_entity_field_alias[ CUSTOMFIELD_SEQUENCE ].field= DELTA_FINDFIELD( pFields, custom_entity_field_alias[ CUSTOMFIELD_SEQUENCE ].name );
	custom_entity_field_alias[ CUSTOMFIELD_ANIMTIME ].field= DELTA_FINDFIELD( pFields, custom_entity_field_alias[ CUSTOMFIELD_ANIMTIME ].name );
}

/*
==================
Custom_Encode

Callback for sending entity_state_t info ( for custom entities ) over network. 
FIXME:  Move to script
==================
*/
void Custom_Encode( struct delta_s *pFields, const unsigned char *from, const unsigned char *to )
{
	entity_state_t *f, *t;
	int beamType;
	static int initialized = 0;

	if ( !initialized )
	{
		Custom_Entity_FieldInit( pFields );
		initialized = 1;
	}

	f = (entity_state_t *)from;
	t = (entity_state_t *)to;

	beamType = t->rendermode & 0x0f;
		
	if ( beamType != BEAM_POINTS && beamType != BEAM_ENTPOINT )
	{
		DELTA_UNSETBYINDEX( pFields, custom_entity_field_alias[ CUSTOMFIELD_ORIGIN0 ].field );
		DELTA_UNSETBYINDEX( pFields, custom_entity_field_alias[ CUSTOMFIELD_ORIGIN1 ].field );
		DELTA_UNSETBYINDEX( pFields, custom_entity_field_alias[ CUSTOMFIELD_ORIGIN2 ].field );
	}

	if ( beamType != BEAM_POINTS )
	{
		DELTA_UNSETBYINDEX( pFields, custom_entity_field_alias[ CUSTOMFIELD_ANGLES0 ].field );
		DELTA_UNSETBYINDEX( pFields, custom_entity_field_alias[ CUSTOMFIELD_ANGLES1 ].field );
		DELTA_UNSETBYINDEX( pFields, custom_entity_field_alias[ CUSTOMFIELD_ANGLES2 ].field );
	}

	if ( beamType != BEAM_ENTS && beamType != BEAM_ENTPOINT )
	{
		DELTA_UNSETBYINDEX( pFields, custom_entity_field_alias[ CUSTOMFIELD_SKIN ].field );
		DELTA_UNSETBYINDEX( pFields, custom_entity_field_alias[ CUSTOMFIELD_SEQUENCE ].field );
	}

	// animtime is compared by rounding first
	// see if we really shouldn't actually send it
	if ( (int)f->animtime == (int)t->animtime )
	{
		DELTA_UNSETBYINDEX( pFields, custom_entity_field_alias[ CUSTOMFIELD_ANIMTIME ].field );
	}
}

/*
=================
RegisterEncoders

Allows game .dll to override network encoding of certain types of entities and tweak values, etc.
=================
*/
void RegisterEncoders( void )
{
	DELTA_ADDENCODER( ""Entity_Encode"", Entity_Encode );
	DELTA_ADDENCODER( ""Custom_Encode"", Custom_Encode );
	DELTA_ADDENCODER( ""Player_Encode"", Player_Encode );
}

int GetWeaponData( struct edict_s *player, struct weapon_data_s *info )
{
#if defined( CLIENT_WEAPONS )
	int i;
	weapon_data_t *item;
	entvars_t *pev = &player->v;
	CBasePlayer *pl = dynamic_cast< CBasePlayer *>( CBasePlayer::Instance( pev ) );
	CBasePlayerWeapon *gun;
	
	ItemInfo II;

	memset( info, 0, 32 * sizeof( weapon_data_t ) );

	if ( !pl )
		return 1;

	// go through all of the weapons and make a list of the ones to pack
	for ( i = 0 ; i < MAX_ITEM_TYPES ; i++ )
	{
		if ( pl->m_rgpPlayerItems[ i ] )
		{
			// there's a weapon here. Should I pack it?
			CBasePlayerItem *pPlayerItem = pl->m_rgpPlayerItems[ i ];

			while ( pPlayerItem )
			{
				gun = dynamic_cast<CBasePlayerWeapon *>( pPlayerItem->GetWeaponPtr() );
				if ( gun && gun->UseDecrement() )
				{
					// Get The ID.
					memset( &II, 0, sizeof( II ) );
					gun->GetItemInfo( &II );

					if ( II.iId >= 0 && II.iId < 32 )
					{
						item = &info[ II.iId ];
					 	
						item->m_iId						= II.iId;
						item->m_iClip					= gun->m_iClip;

						item->m_flTimeWeaponIdle		= max( gun->m_flTimeWeaponIdle, -0.001 );
						item->m_flNextPrimaryAttack		= max( gun->m_flNextPrimaryAttack, -0.001 );
						item->m_flNextSecondaryAttack	= max( gun->m_flNextSecondaryAttack, -0.001 );
						item->m_fInReload				= gun->m_fInReload;
						item->m_fInSpecialReload		= gun->m_fInSpecialReload;
						item->fuser1					= max( gun->pev->fuser1, -0.001 );
						item->fuser2					= gun->m_flStartThrow;
						item->fuser3					= gun->m_flReleaseThrow;
						item->iuser1					= gun->m_chargeReady;
						item->iuser2					= gun->m_fInAttack;
						item->iuser3					= gun->m_fireState;
						
											
//						item->m_flPumpTime				= max( gun->m_flPumpTime, -0.001 );
					}
				}
				pPlayerItem = pPlayerItem->m_pNext;
			}
		}
	}
#else
	memset( info, 0, 32 * sizeof( weapon_data_t ) );
#endif
	return 1;
}

/*
=================
UpdateClientData

Data sent to current client only
engine sets cd to 0 before calling.
=================
*/
void UpdateClientData ( const edict_t *ent, int sendweapons, struct clientdata_s *cd )
{
	if ( !ent || !ent->pvPrivateData )
		return;
	entvars_t *		pev	= (entvars_t *)&ent->v;
	CBasePlayer *	pl	= dynamic_cast< CBasePlayer *>(CBasePlayer::Instance( pev ));
	entvars_t *		pevOrg = NULL;

	// if user is spectating different player in First person, override some vars
	if ( pl && pl->pev->iuser1 == OBS_IN_EYE )
	{
		if ( pl->m_hObserverTarget )
		{
			pevOrg = pev;
			pev = pl->m_hObserverTarget->pev;
			pl = dynamic_cast< CBasePlayer *>(CBasePlayer::Instance( pev ) );
		}
	}

	cd->flags			= pev->flags;
	cd->health			= pev->health;

	cd->viewmodel		= MODEL_INDEX( STRING( pev->viewmodel ) );

	cd->waterlevel		= pev->waterlevel;
	cd->watertype		= pev->watertype;
	cd->weapons			= pev->weapons;

	// Vectors
	cd->origin			= pev->origin;
	cd->velocity		= pev->velocity;
	cd->view_ofs		= pev->view_ofs;
	cd->punchangle		= pev->punchangle;

	cd->bInDuck			= pev->bInDuck;
	cd->flTimeStepSound = pev->flTimeStepSound;
	cd->flDuckTime		= pev->flDuckTime;
	cd->flSwimTime		= pev->flSwimTime;
	cd->waterjumptime	= pev->teleport_time;

	strcpy( cd->physinfo, ENGINE_GETPHYSINFO( ent ) );

	cd->maxspeed		= pev->maxspeed;
	cd->fov				= pev->fov;
	cd->weaponanim		= pev->weaponanim;

	cd->pushmsec		= pev->pushmsec;

	//Spectator mode
	if ( pevOrg != NULL )
	{
		// don't use spec vars from chased player
		cd->iuser1			= pevOrg->iuser1;
		cd->iuser2			= pevOrg->iuser2;
	}
	else
	{
		cd->iuser1			= pev->iuser1;
		cd->iuser2			= pev->iuser2;
	}

	

#if defined( CLIENT_WEAPONS )
	if ( sendweapons )
	{
		if ( pl )
		{
			cd->m_flNextAttack	= pl->m_flNextAttack;
			cd->fuser2			= pl->m_flNextAmmoBurn;
			cd->fuser3			= pl->m_flAmmoStartCharge;
			cd->vuser1.x		= pl->ammo_9mm;
			cd->vuser1.y		= pl->ammo_357;
			cd->vuser1.z		= pl->ammo_argrens;
			cd->ammo_nails		= pl->ammo_bolts;
			cd->ammo_shells		= pl->ammo_buckshot;
			cd->ammo_rockets	= pl->ammo_rockets;
			cd->ammo_cells		= pl->ammo_uranium;
			cd->vuser2.x		= pl->ammo_hornets;
			

			if ( pl->m_pActiveItem )
			{
				CBasePlayerWeapon *gun;
				gun = (CBasePlayerWeapon *)pl->m_pActiveItem->GetWeaponPtr();
				if ( gun && gun->UseDecrement() )
				{
					ItemInfo II;
					memset( &II, 0, sizeof( II ) );
					gun->GetItemInfo( &II );

					cd->m_iId = II.iId;

					cd->vuser3.z	= gun->m_iSecondaryAmmoType;
					cd->vuser4.x	= gun->m_iPrimaryAmmoType;
					cd->vuser4.y	= pl->m_rgAmmo[gun->m_iPrimaryAmmoType];
					cd->vuser4.z	= pl->m_rgAmmo[gun->m_iSecondaryAmmoType];
					
					if ( pl->m_pActiveItem->m_iId == WEAPON_RPG )
					{
						cd->vuser2.y = ( ( CRpg * )pl->m_pActiveItem)->m_fSpotActive;
						cd->vuser2.z = ( ( CRpg * )pl->m_pActiveItem)->m_cActiveRockets;
					}
				}
			}
		}
	} 
#endif
}

/*
=================
CmdStart

We're about to run this usercmd for the specified player.  We can set up groupinfo and masking here, etc.
This is the time to examine the usercmd for anything extra.  This call happens even if think does not.
=================
*/
void CmdStart( const edict_t *player, const struct usercmd_s *cmd, unsigned int random_seed )
{
	entvars_t *pev = (entvars_t *)&player->v;
	CBasePlayer *pl = dynamic_cast< CBasePlayer *>( CBasePlayer::Instance( pev ) );

	if( !pl )
		return;

	if ( pl->pev->groupinfo != 0 )
	{
		UTIL_SetGroupTrace( pl->pev->groupinfo, GROUP_OP_AND );
	}

	pl->random_seed = random_seed;
}

/*
=================
CmdEnd

Each cmdstart is exactly matched with a cmd end, clean up any group trace flags, etc. here
=================
*/
void CmdEnd ( const edict_t *player )
{
	entvars_t *pev = (entvars_t *)&player->v;
	CBasePlayer *pl = dynamic_cast< CBasePlayer *>( CBasePlayer::Instance( pev ) );

	if( !pl )
		return;
	if ( pl->pev->groupinfo != 0 )
	{
		UTIL_UnsetGroupTrace();
	}
}

/*
================================
ConnectionlessPacket

 Return 1 if the packet is valid.  Set response_buffer_size if you want to send a response packet.  Incoming, it holds the max
  size of the response_buffer, so you must zero it out if you choose not to respond.
================================
*/
int	ConnectionlessPacket( const struct netadr_s *net_from, const char *args, char *response_buffer, int *response_buffer_size )
{
	// Parse stuff from args
	int max_buffer_size = *response_buffer_size;

	// Zero it out since we aren't going to respond.
	// If we wanted to response, we'd write data into response_buffer
	*response_buffer_size = 0;

	// Since we don't listen for anything here, just respond that it's a bogus message
	// If we didn't reject the message, we'd return 1 for success instead.
	return 0;
}

/*
================================
GetHullBounds

  Engine calls this to enumerate player collision hulls, for prediction.  Return 0 if the hullnumber doesn't exist.
================================
*/
int GetHullBounds( int hullnumber, float *mins, float *maxs )
{
	int iret = 0;

	switch ( hullnumber )
	{
	case 0:				// Normal player
		mins = VEC_HULL_MIN;
		maxs = VEC_HULL_MAX;
		iret = 1;
		break;
	case 1:				// Crouched player
		mins = VEC_DUCK_HULL_MIN;
		maxs = VEC_DUCK_HULL_MAX;
		iret = 1;
		break;
	case 2:				// Point based hull
		mins = Vector( 0, 0, 0 );
		maxs = Vector( 0, 0, 0 );
		iret = 1;
		break;
	}

	return iret;
}

/*
================================
CreateInstancedBaselines

Create pseudo-baselines for items that aren't placed in the map at spawn time, but which are likely
to be created during play ( e.g., grenades, ammo packs, projectiles, corpses, etc. )
================================
*/
void CreateInstancedBaselines ( void )
{
	int iret = 0;
	entity_state_t state;

	memset( &state, 0, sizeof( state ) );

	// Create any additional baselines here for things like grendates, etc.
	// iret = ENGINE_INSTANCE_BASELINE( pc->pev->classname, &state );

	// Destroy objects.
	//UTIL_Remove( pc );
}

/*
================================
InconsistentFile

One of the ENGINE_FORCE_UNMODIFIED files failed the consistency check for the specified player
 Return 0 to allow the client to continue, 1 to force immediate disconnection ( with an optional disconnect message of up to 256 characters )
================================
*/
int	InconsistentFile( const edict_t *player, const char *filename, char *disconnect_message )
{
	// Server doesn't care?
	if ( CVAR_GET_FLOAT( ""mp_consistency"" ) != 1 )
		return 0;

	// Default behavior is to kick the player
	sprintf( disconnect_message, ""Server is enforcing file consistency for %s\\n"", filename );

	// Kick now with specified disconnect message.
	return 1;
}

/*
================================
AllowLagCompensation

 The game .dll should return 1 if lag compensation should be allowed ( could also just set
  the sv_unlag cvar.
 Most games right now should return 0, until client-side weapon prediction code is written
  and tested for them ( note you can predict weapons, but not do lag compensation, too, 
  if you want.
================================
*/
int AllowLagCompensation( void )
{
	return 1;
}
",16294,True,2732.906993705007,median
"// license:BSD-3-Clause
// copyright-holders:Ernesto Corvi, Aaron Giles, Mariusz Wojcieszek
/***************************************************************************

    Amiga Computer / Arcadia Game System

    Driver by:

    Aaron Giles, Ernesto Corvi & Mariusz Wojcieszek

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

#include ""emu.h""
#include ""includes/amiga.h""
#include ""cpu/m68000/m68000.h""


/*************************************
 *
 *  Debugging
 *
 *************************************/

#define LOG_CUSTOM  0
#define LOG_CIA     0
#define LOG_BLITS   0
#define LOG_SERIAL  1



/*************************************
 *
 *  Constants
 *
 *************************************/

/* How many CPU cycles we delay until we fire a pending interrupt */
#define AMIGA_IRQ_DELAY_CYCLES      24

/* How many CPU cycles we wait until we process a blit when the blitter-nasty bit is set */
#define BLITTER_NASTY_DELAY         16



/*************************************
 *
 *  Globals
 *
 *************************************/

const char *const amiga_state::s_custom_reg_names[0x100] =
{
	/* 0x000 */
	""BLTDDAT"",      ""DMACONR"",      ""VPOSR"",        ""VHPOSR"",
	""DSKDATR"",      ""JOY0DAT"",      ""JOY1DAT"",      ""CLXDAT"",
	""ADKCONR"",      ""POT0DAT"",      ""POT1DAT"",      ""POTGOR"",
	""SERDATR"",      ""DSKBYTR"",      ""INTENAR"",      ""INTREQR"",
	/* 0x020 */
	""DSKPTH"",       ""DSKPTL"",       ""DSKLEN"",       ""DSKDAT"",
	""REFPTR"",       ""VPOSW"",        ""VHPOSW"",       ""COPCON"",
	""SERDAT"",       ""SERPER"",       ""POTGO"",        ""JOYTEST"",
	""STREQU"",       ""STRVBL"",       ""STRHOR"",       ""STRLONG"",
	/* 0x040 */
	""BLTCON0"",      ""BLTCON1"",      ""BLTAFWM"",      ""BLTALWM"",
	""BLTCPTH"",      ""BLTCPTL"",      ""BLTBPTH"",      ""BLTBPTL"",
	""BLTAPTH"",      ""BLTAPTL"",      ""BLTDPTH"",      ""BLTDPTL"",
	""BLTSIZE"",      ""BLTCON0L"",     ""BLTSIZV"",      ""BLTSIZH"",
	/* 0x060 */
	""BLTCMOD"",      ""BLTBMOD"",      ""BLTAMOD"",      ""BLTDMOD"",
	""UNK068"",       ""UNK06A"",       ""UNK06C"",       ""UNK06E"",
	""BLTCDAT"",      ""BLTBDAT"",      ""BLTADAT"",      ""UNK076"",
	""SPRHDAT"",      ""BPLHDAT"",      ""LISAID"",       ""DSRSYNC"",
	/* 0x080 */
	""COP1LCH"",      ""COP1LCL"",      ""COP2LCH"",      ""COP2LCL"",
	""COPJMP1"",      ""COPJMP2"",      ""COPINS"",       ""DIWSTRT"",
	""DIWSTOP"",      ""DDFSTRT"",      ""DDFSTOP"",      ""DMACON"",
	""CLXCON"",       ""INTENA"",       ""INTREQ"",       ""ADKCON"",
	/* 0x0A0 */
	""AUD0LCH"",      ""AUD0LCL"",      ""AUD0LEN"",      ""AUD0PER"",
	""AUD0VOL"",      ""AUD0DAT"",      ""UNK0AC"",       ""UNK0AE"",
	""AUD1LCH"",      ""AUD1LCL"",      ""AUD1LEN"",      ""AUD1PER"",
	""AUD1VOL"",      ""AUD1DAT"",      ""UNK0BC"",       ""UNK0BE"",
	/* 0x0C0 */
	""AUD2LCH"",      ""AUD2LCL"",      ""AUD2LEN"",      ""AUD2PER"",
	""AUD2VOL"",      ""AUD2DAT"",      ""UNK0CC"",       ""UNK0CE"",
	""AUD3LCH"",      ""AUD3LCL"",      ""AUD3LEN"",      ""AUD3PER"",
	""AUD3VOL"",      ""AUD3DAT"",      ""UNK0DC"",       ""UNK0DE"",
	/* 0x0E0 */
	""BPL1PTH"",      ""BPL1PTL"",      ""BPL2PTH"",      ""BPL2PTL"",
	""BPL3PTH"",      ""BPL3PTL"",      ""BPL4PTH"",      ""BPL4PTL"",
	""BPL5PTH"",      ""BPL5PTL"",      ""BPL6PTH"",      ""BPL6PTL"",
	""BPL7PTH"",      ""BPL7PTL"",      ""BPL8PTH"",      ""BPL8PTL"",
	/* 0x100 */
	""BPLCON0"",      ""BPLCON1"",      ""BPLCON2"",      ""BPLCON3"",
	""BPL1MOD"",      ""BPL2MOD"",      ""BPLCON4"",      ""CLXCON2"",
	""BPL1DAT"",      ""BPL2DAT"",      ""BPL3DAT"",      ""BPL4DAT"",
	""BPL5DAT"",      ""BPL6DAT"",      ""BPL7DAT"",      ""BPL8DAT"",
	/* 0x120 */
	""SPR0PTH"",      ""SPR0PTL"",      ""SPR1PTH"",      ""SPR1PTL"",
	""SPR2PTH"",      ""SPR2PTL"",      ""SPR3PTH"",      ""SPR3PTL"",
	""SPR4PTH"",      ""SPR4PTL"",      ""SPR5PTH"",      ""SPR5PTL"",
	""SPR6PTH"",      ""SPR6PTL"",      ""SPR7PTH"",      ""SPR7PTL"",
	/* 0x140 */
	""SPR0POS"",      ""SPR0CTL"",      ""SPR0DATA"",     ""SPR0DATB"",
	""SPR1POS"",      ""SPR1CTL"",      ""SPR1DATA"",     ""SPR1DATB"",
	""SPR2POS"",      ""SPR2CTL"",      ""SPR2DATA"",     ""SPR2DATB"",
	""SPR3POS"",      ""SPR3CTL"",      ""SPR3DATA"",     ""SPR3DATB"",
	/* 0x160 */
	""SPR4POS"",      ""SPR4CTL"",      ""SPR4DATA"",     ""SPR4DATB"",
	""SPR5POS"",      ""SPR5CTL"",      ""SPR5DATA"",     ""SPR5DATB"",
	""SPR6POS"",      ""SPR6CTL"",      ""SPR6DATA"",     ""SPR6DATB"",
	""SPR7POS"",      ""SPR7CTL"",      ""SPR7DATA"",     ""SPR7DATB"",
	/* 0x180 */
	""COLOR00"",      ""COLOR01"",      ""COLOR02"",      ""COLOR03"",
	""COLOR04"",      ""COLOR05"",      ""COLOR06"",      ""COLOR07"",
	""COLOR08"",      ""COLOR09"",      ""COLOR10"",      ""COLOR11"",
	""COLOR12"",      ""COLOR13"",      ""COLOR14"",      ""COLOR15"",
	/* 0x1A0 */
	""COLOR16"",      ""COLOR17"",      ""COLOR18"",      ""COLOR19"",
	""COLOR20"",      ""COLOR21"",      ""COLOR22"",      ""COLOR23"",
	""COLOR24"",      ""COLOR25"",      ""COLOR26"",      ""COLOR27"",
	""COLOR28"",      ""COLOR29"",      ""COLOR30"",      ""COLOR31"",
	/* 0x1C0 */
	""HTOTAL"",       ""HSSTOP"",       ""HBSTRT"",       ""HBSTOP"",
	""VTOTAL"",       ""VSSTOP"",       ""VBSTRT"",       ""VBSTOP"",
	""SPRHSTRT"",     ""SPRHSTOP"",     ""BPLHSTRT"",     ""BPLHSTOP"",
	""HHPOSW"",       ""HHPOSR"",       ""BEAMCON0"",     ""HSSTRT"",
	/* 0x1E0 */
	""VSSTRT"",       ""HCENTER"",      ""DIWHIGH"",      ""BPLHMOD"",
	""SPRHPTH"",      ""SPRHPTL"",      ""BPLHPTH"",      ""BPLHPTL"",
	""UNK1F0"",       ""UNK1F2"",       ""UNK1F4"",       ""UNK1F6"",
	""UNK1F8"",       ""UNK1FA"",       ""FMODE"",        ""UNK1FE""
};

constexpr XTAL amiga_state::CLK_28M_PAL;
constexpr XTAL amiga_state::CLK_7M_PAL;
constexpr XTAL amiga_state::CLK_C1_PAL;
constexpr XTAL amiga_state::CLK_E_PAL;

constexpr XTAL amiga_state::CLK_28M_NTSC;
constexpr XTAL amiga_state::CLK_7M_NTSC;
constexpr XTAL amiga_state::CLK_C1_NTSC;
constexpr XTAL amiga_state::CLK_E_NTSC;


/*************************************
 *
 *  Machine reset
 *
 *************************************/

void amiga_state::machine_start()
{
	m_power_led.resolve();

	// add callback for RESET instruction
	m_maincpu->set_reset_callback(*this, FUNC(amiga_state::m68k_reset));

	// set up chip RAM access
	memory_share *share = memshare(""chip_ram"");
	if (share == nullptr)
		fatalerror(""Unable to find Amiga chip RAM\\n"");
	m_chip_ram.set(*share, 2);
	m_chip_ram_mask = (m_chip_ram.bytes() - 1) & ~1;

	// set up the timers
	m_irq_timer = timer_alloc(TIMER_AMIGA_IRQ);
	m_blitter_timer = timer_alloc(TIMER_AMIGA_BLITTER);
	m_serial_timer = timer_alloc(TIMER_SERIAL);
	m_scanline_timer = timer_alloc(TIMER_SCANLINE);

	// start the scanline timer
	m_scanline_timer->adjust(m_screen->time_until_pos(0));
}

WRITE_LINE_MEMBER( amiga_state::m68k_reset )
{
	logerror(""%s: Executed RESET\\n"", machine().describe_context());
	machine_reset();
}

void amiga_state::machine_reset()
{
	// reset cia chips
	m_cia_0->reset();
	m_cia_1->reset();

	// reset custom chip registers
	custom_chip_reset();

	// map kickstart rom to location 0
	// this either done by reseting the cia chips
	// or directly by gayle where available
	m_gayle_reset = true;
	m_overlay->set_bank(1);
}

WRITE_LINE_MEMBER(amiga_state::fdc_dskblk_w)
{
	set_interrupt(INTENA_SETCLR | INTENA_DSKBLK);
}

WRITE_LINE_MEMBER(amiga_state::fdc_dsksyn_w)
{
	set_interrupt((state ? INTENA_SETCLR : 0) | INTENA_DSKSYN);
}

WRITE_LINE_MEMBER( amiga_state::kbreset_w )
{
	// this is connected to the gary chip, gary then resets the 68k, agnus, paula and the cias
	if (!state)
	{
		m_paula->reset();
		machine_reset();
		m_maincpu->reset();
	}
}

// simple mirror of region 0xf80000 to 0xfbffff
uint16_t amiga_state::rom_mirror_r(offs_t offset, uint16_t mem_mask)
{
	return m_maincpu->space(AS_PROGRAM).read_word(offset + 0xf80000, mem_mask);
}

uint32_t amiga_state::rom_mirror32_r(offs_t offset, uint32_t mem_mask)
{
	return m_maincpu->space(AS_PROGRAM).read_dword(offset + 0xf80000, mem_mask);
}

void amiga_state::device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr)
{
	switch (id)
	{
	case TIMER_SCANLINE:
		scanline_callback(ptr, param);
		break;
	case TIMER_AMIGA_IRQ:
		amiga_irq_proc(ptr, param);
		break;
	case TIMER_AMIGA_BLITTER:
		amiga_blitter_proc(ptr, param);
		break;
	case TIMER_SERIAL:
		serial_shift();
		break;
	default:
		fatalerror(""Invalid timer: %d\\n"", id);
	}
}


/*************************************
 *
 *  Per scanline callback
 *
 *************************************/

void amiga_state::vblank()
{
}

// todo: cia a clock can be connected to either a fixed 50/60hz signal from the power supply, or the vblank
TIMER_CALLBACK_MEMBER( amiga_state::scanline_callback )
{
	int scanline = param;

	// vblank start
	if (scanline == 0)
	{
		// signal vblank irq
		set_interrupt(INTENA_SETCLR | INTENA_VERTB);

		// clock tod
		m_cia_0->tod_w(1);

		// additional bookkeeping by drivers
		vblank();
	}

	// vblank end
	if (scanline == m_screen->visible_area().top())
	{
		m_cia_0->tod_w(0);
	}

	if (m_potgo_port.found())
	{
		// pot counters (start counting at 7 (ntsc) or 8 (pal))
		if (BIT(CUSTOM_REG(REG_POTGO), 0) && (scanline /2 ) > 7)
		{
			m_pot0x += !(m_potgo_port->read() & 0x0100);
			m_pot0y += !(m_potgo_port->read() & 0x0400);
			m_pot1x += !(m_potgo_port->read() & 0x1000);
			m_pot1y += !(m_potgo_port->read() & 0x4000);
		}
	}

	// render up to this scanline
	if (!m_screen->update_partial(scanline))
	{
		bitmap_rgb32 dummy_bitmap;
		if (IS_AGA())
			aga_render_scanline(dummy_bitmap, scanline);
		else
			render_scanline(dummy_bitmap, scanline);
	}

	// clock tod (if we actually render this scanline)
	m_cia_1->tod_w((scanline & 1) ^ BIT(CUSTOM_REG(REG_VPOSR), 15));

	// force a sound update
	m_paula->update();

	// set timer for next line
	scanline = (scanline + 1) % m_screen->height();
	m_scanline_timer->adjust(m_screen->time_until_pos(scanline), scanline);
}



/*************************************
 *
 *  Interrupt management
 *
 *************************************/

void amiga_state::set_interrupt(int interrupt)
{
	custom_chip_w(REG_INTREQ, interrupt);
}

bool amiga_state::int2_pending()
{
	return m_cia_0_irq;
}

bool amiga_state::int6_pending()
{
	return m_cia_1_irq;
}

void amiga_state::update_int2()
{
	set_interrupt((int2_pending() ? INTENA_SETCLR : 0x0000) | INTENA_PORTS);
}

void amiga_state::update_int6()
{
	set_interrupt((int6_pending() ? INTENA_SETCLR : 0x0000) | INTENA_EXTER);
}

void amiga_state::update_irqs()
{
	// if the external interrupt line is still active, set the interrupt request bit
	if (int2_pending())
		CUSTOM_REG(REG_INTREQ) |= INTENA_PORTS;

	if (int6_pending())
		CUSTOM_REG(REG_INTREQ) |= INTENA_EXTER;

	int ints = CUSTOM_REG(REG_INTENA) & CUSTOM_REG(REG_INTREQ);

	// master interrupt switch
	if (CUSTOM_REG(REG_INTENA) & INTENA_INTEN)
	{
		m_maincpu->set_input_line(1, ints & (INTENA_TBE | INTENA_DSKBLK | INTENA_SOFT) ? ASSERT_LINE : CLEAR_LINE);
		m_maincpu->set_input_line(2, ints & (INTENA_PORTS) ? ASSERT_LINE : CLEAR_LINE);
		m_maincpu->set_input_line(3, ints & (INTENA_COPER | INTENA_VERTB | INTENA_BLIT) ? ASSERT_LINE : CLEAR_LINE);
		m_maincpu->set_input_line(4, ints & (INTENA_AUD0 | INTENA_AUD1 | INTENA_AUD2 | INTENA_AUD3) ? ASSERT_LINE : CLEAR_LINE);
		m_maincpu->set_input_line(5, ints & (INTENA_RBF | INTENA_DSKSYN) ? ASSERT_LINE : CLEAR_LINE);
		m_maincpu->set_input_line(6, ints & (INTENA_EXTER) ? ASSERT_LINE : CLEAR_LINE);
	}
	else
	{
		m_maincpu->set_input_line(1, CLEAR_LINE);
		m_maincpu->set_input_line(2, CLEAR_LINE);
		m_maincpu->set_input_line(3, CLEAR_LINE);
		m_maincpu->set_input_line(4, CLEAR_LINE);
		m_maincpu->set_input_line(5, CLEAR_LINE);
		m_maincpu->set_input_line(6, CLEAR_LINE);
	}
}

TIMER_CALLBACK_MEMBER( amiga_state::amiga_irq_proc )
{
	update_irqs();
	m_irq_timer->reset();
}

void amiga_state::paula_int_w (offs_t channel, u8 state)
{
	set_interrupt(INTENA_SETCLR | (0x80 << channel));
}


//**************************************************************************
//  INPUTS
//**************************************************************************

uint16_t amiga_state::joy0dat_r()
{
	if (!m_input_device.found() || (m_input_device->read() & 0x10))
		return m_joy0dat_port.read_safe(0xffff);
	else
		return (m_p1_mouse_y.read_safe(0xff) << 8) | m_p1_mouse_x.read_safe(0xff);
}

uint16_t amiga_state::joy1dat_r()
{
	if (!m_input_device.found() || m_input_device->read() & 0x20)
		return m_joy1dat_port.read_safe(0xffff);
	else
		return (m_p2_mouse_y.read_safe(0xff) << 8) | m_p2_mouse_x.read_safe(0xff);
}



/*************************************
 *
 *  Ascending blitter variant
 *
 *************************************/

uint32_t amiga_state::blit_ascending()
{
	uint32_t shifta = (CUSTOM_REG(REG_BLTCON0) >> 12) & 0xf;
	uint32_t shiftb = (CUSTOM_REG(REG_BLTCON1) >> 12) & 0xf;
	uint32_t height = CUSTOM_REG(REG_BLTSIZV);
	uint32_t width = CUSTOM_REG(REG_BLTSIZH);
	uint32_t acca = 0, accb = 0;
	uint32_t blitsum = 0;
	uint32_t x, y;

	/* iterate over the height */
	for (y = 0; y < height; y++)
	{
		/* iterate over the width */
		for (x = 0; x < width; x++)
		{
			uint16_t abc0, abc1, abc2, abc3;
			uint32_t tempa, tempd = 0;
			uint32_t b;

			/* fetch data for A */
			if (CUSTOM_REG(REG_BLTCON0) & 0x0800)
			{
				//CUSTOM_REG(REG_BLTADAT) = m_maincpu->space(AS_PROGRAM).read_word(CUSTOM_REG_LONG(REG_BLTAPTH));
				CUSTOM_REG(REG_BLTADAT) = read_chip_ram(CUSTOM_REG_LONG(REG_BLTAPTH));
				CUSTOM_REG_LONG(REG_BLTAPTH) += 2;
			}

			/* fetch data for B */
			if (CUSTOM_REG(REG_BLTCON0) & 0x0400)
			{
				CUSTOM_REG(REG_BLTBDAT) = read_chip_ram(CUSTOM_REG_LONG(REG_BLTBPTH));
				CUSTOM_REG_LONG(REG_BLTBPTH) += 2;
			}

			/* fetch data for C */
			if (CUSTOM_REG(REG_BLTCON0) & 0x0200)
			{
				CUSTOM_REG(REG_BLTCDAT) = read_chip_ram(CUSTOM_REG_LONG(REG_BLTCPTH));
				CUSTOM_REG_LONG(REG_BLTCPTH) += 2;
			}

			/* apply start/end masks to the A data */
			tempa = CUSTOM_REG(REG_BLTADAT);
			if (x == 0)
				tempa &= CUSTOM_REG(REG_BLTAFWM);
			if (x == width - 1)
				tempa &= CUSTOM_REG(REG_BLTALWM);

			/* update the B accumulator applying shifts */
			acca = (acca << 16) | (tempa << (16 - shifta));
			accb = (accb << 16) | (CUSTOM_REG(REG_BLTBDAT) << (16 - shiftb));

			/* build up 4 16-bit words containing 4 pixels each in 0ABC bit order */
			abc0 = ((acca >> 17) & 0x4444) | ((accb >> 18) & 0x2222) | ((CUSTOM_REG(REG_BLTCDAT) >> 3) & 0x1111);
			abc1 = ((acca >> 16) & 0x4444) | ((accb >> 17) & 0x2222) | ((CUSTOM_REG(REG_BLTCDAT) >> 2) & 0x1111);
			abc2 = ((acca >> 15) & 0x4444) | ((accb >> 16) & 0x2222) | ((CUSTOM_REG(REG_BLTCDAT) >> 1) & 0x1111);
			abc3 = ((acca >> 14) & 0x4444) | ((accb >> 15) & 0x2222) | ((CUSTOM_REG(REG_BLTCDAT) >> 0) & 0x1111);

			/* now loop over bits and compute the destination value */
			for (b = 0; b < 4; b++)
			{
				uint32_t bit;

				/* shift previous data up 4 bits */
				tempd <<= 4;

				/* lookup first bit in series */
				bit = (CUSTOM_REG(REG_BLTCON0) >> (abc0 >> 12)) & 1;
				abc0 <<= 4;
				tempd |= bit << 3;

				/* lookup second bit in series */
				bit = (CUSTOM_REG(REG_BLTCON0) >> (abc1 >> 12)) & 1;
				abc1 <<= 4;
				tempd |= bit << 2;

				/* lookup third bit in series */
				bit = (CUSTOM_REG(REG_BLTCON0) >> (abc2 >> 12)) & 1;
				abc2 <<= 4;
				tempd |= bit << 1;

				/* lookup fourth bit in series */
				bit = (CUSTOM_REG(REG_BLTCON0) >> (abc3 >> 12)) & 1;
				abc3 <<= 4;
				tempd |= bit << 0;
			}

			/* accumulate the sum */
			blitsum |= tempd;

			/* write to the destination */
			if (CUSTOM_REG(REG_BLTCON0) & 0x0100)
			{
				write_chip_ram(CUSTOM_REG_LONG(REG_BLTDPTH), tempd);
				CUSTOM_REG_LONG(REG_BLTDPTH) += 2;
			}
		}

		/* apply end of line modulos */
		if (CUSTOM_REG(REG_BLTCON0) & 0x0800)
			CUSTOM_REG_LONG(REG_BLTAPTH) += CUSTOM_REG_SIGNED(REG_BLTAMOD) & ~1;
		if (CUSTOM_REG(REG_BLTCON0) & 0x0400)
			CUSTOM_REG_LONG(REG_BLTBPTH) += CUSTOM_REG_SIGNED(REG_BLTBMOD) & ~1;
		if (CUSTOM_REG(REG_BLTCON0) & 0x0200)
			CUSTOM_REG_LONG(REG_BLTCPTH) += CUSTOM_REG_SIGNED(REG_BLTCMOD) & ~1;
		if (CUSTOM_REG(REG_BLTCON0) & 0x0100)
			CUSTOM_REG_LONG(REG_BLTDPTH) += CUSTOM_REG_SIGNED(REG_BLTDMOD) & ~1;
	}

	/* return the blit sum */
	return blitsum;
}



/*************************************
 *
 *  Descending blitter variant
 *
 *************************************/

uint32_t amiga_state::blit_descending()
{
	uint32_t fill_exclusive = (CUSTOM_REG(REG_BLTCON1) >> 4);
	uint32_t fill_inclusive = (CUSTOM_REG(REG_BLTCON1) >> 3);
	uint32_t shifta = (CUSTOM_REG(REG_BLTCON0) >> 12) & 0xf;
	uint32_t shiftb = (CUSTOM_REG(REG_BLTCON1) >> 12) & 0xf;
	uint32_t height = CUSTOM_REG(REG_BLTSIZV);
	uint32_t width = CUSTOM_REG(REG_BLTSIZH);
	uint32_t acca = 0, accb = 0;
	uint32_t blitsum = 0;
	uint32_t x, y;

	/* iterate over the height */
	for (y = 0; y < height; y++)
	{
		uint32_t fill_state = (CUSTOM_REG(REG_BLTCON1) >> 2) & 1;

		/* iterate over the width */
		for (x = 0; x < width; x++)
		{
			uint16_t abc0, abc1, abc2, abc3;
			uint32_t tempa, tempd = 0;
			uint32_t b;

			/* fetch data for A */
			if (CUSTOM_REG(REG_BLTCON0) & 0x0800)
			{
				CUSTOM_REG(REG_BLTADAT) = read_chip_ram(CUSTOM_REG_LONG(REG_BLTAPTH));
				CUSTOM_REG_LONG(REG_BLTAPTH) -= 2;
			}

			/* fetch data for B */
			if (CUSTOM_REG(REG_BLTCON0) & 0x0400)
			{
				CUSTOM_REG(REG_BLTBDAT) = read_chip_ram(CUSTOM_REG_LONG(REG_BLTBPTH));
				CUSTOM_REG_LONG(REG_BLTBPTH) -= 2;
			}

			/* fetch data for C */
			if (CUSTOM_REG(REG_BLTCON0) & 0x0200)
			{
				CUSTOM_REG(REG_BLTCDAT) = read_chip_ram(CUSTOM_REG_LONG(REG_BLTCPTH));
				CUSTOM_REG_LONG(REG_BLTCPTH) -= 2;
			}

			/* apply start/end masks to the A data */
			tempa = CUSTOM_REG(REG_BLTADAT);
			if (x == 0)
				tempa &= CUSTOM_REG(REG_BLTAFWM);
			if (x == width - 1)
				tempa &= CUSTOM_REG(REG_BLTALWM);

			/* update the B accumulator applying shifts */
			acca = (acca >> 16) | (tempa << shifta);
			accb = (accb >> 16) | (CUSTOM_REG(REG_BLTBDAT) << shiftb);

			/* build up 4 16-bit words containing 4 pixels each in 0ABC bit order */
			abc0 = ((acca >> 1) & 0x4444) | ((accb >> 2) & 0x2222) | ((CUSTOM_REG(REG_BLTCDAT) >> 3) & 0x1111);
			abc1 = ((acca >> 0) & 0x4444) | ((accb >> 1) & 0x2222) | ((CUSTOM_REG(REG_BLTCDAT) >> 2) & 0x1111);
			abc2 = ((acca << 1) & 0x4444) | ((accb >> 0) & 0x2222) | ((CUSTOM_REG(REG_BLTCDAT) >> 1) & 0x1111);
			abc3 = ((acca << 2) & 0x4444) | ((accb << 1) & 0x2222) | ((CUSTOM_REG(REG_BLTCDAT) >> 0) & 0x1111);

			/* now loop over bits and compute the destination value */
			for (b = 0; b < 4; b++)
			{
				uint32_t prev_fill_state;
				uint32_t bit;

				/* shift previous data up 4 bits */
				tempd >>= 4;

				/* lookup fourth bit in series */
				bit = (CUSTOM_REG(REG_BLTCON0) >> (abc3 & 0xf)) & 1;
				abc3 >>= 4;
				prev_fill_state = fill_state;
				fill_state ^= bit;
				bit ^= prev_fill_state & fill_exclusive;
				bit |= prev_fill_state & fill_inclusive;
				tempd |= bit << 12;

				/* lookup third bit in series */
				bit = (CUSTOM_REG(REG_BLTCON0) >> (abc2 & 0xf)) & 1;
				abc2 >>= 4;
				prev_fill_state = fill_state;
				fill_state ^= bit;
				bit ^= prev_fill_state & fill_exclusive;
				bit |= prev_fill_state & fill_inclusive;
				tempd |= bit << 13;

				/* lookup second bit in series */
				bit = (CUSTOM_REG(REG_BLTCON0) >> (abc1 & 0xf)) & 1;
				abc1 >>= 4;
				prev_fill_state = fill_state;
				fill_state ^= bit;
				bit ^= prev_fill_state & fill_exclusive;
				bit |= prev_fill_state & fill_inclusive;
				tempd |= bit << 14;

				/* lookup first bit in series */
				bit = (CUSTOM_REG(REG_BLTCON0) >> (abc0 & 0xf)) & 1;
				abc0 >>= 4;
				prev_fill_state = fill_state;
				fill_state ^= bit;
				bit ^= prev_fill_state & fill_exclusive;
				bit |= prev_fill_state & fill_inclusive;
				tempd |= bit << 15;
			}

			/* accumulate the sum */
			blitsum |= tempd;

			/* write to the destination */
			if (CUSTOM_REG(REG_BLTCON0) & 0x0100)
			{
				write_chip_ram(CUSTOM_REG_LONG(REG_BLTDPTH), tempd);
				CUSTOM_REG_LONG(REG_BLTDPTH) -= 2;
			}
		}

		/* apply end of line modulos */
		if (CUSTOM_REG(REG_BLTCON0) & 0x0800)
			CUSTOM_REG_LONG(REG_BLTAPTH) -= CUSTOM_REG_SIGNED(REG_BLTAMOD) & ~1;
		if (CUSTOM_REG(REG_BLTCON0) & 0x0400)
			CUSTOM_REG_LONG(REG_BLTBPTH) -= CUSTOM_REG_SIGNED(REG_BLTBMOD) & ~1;
		if (CUSTOM_REG(REG_BLTCON0) & 0x0200)
			CUSTOM_REG_LONG(REG_BLTCPTH) -= CUSTOM_REG_SIGNED(REG_BLTCMOD) & ~1;
		if (CUSTOM_REG(REG_BLTCON0) & 0x0100)
			CUSTOM_REG_LONG(REG_BLTDPTH) -= CUSTOM_REG_SIGNED(REG_BLTDMOD) & ~1;
	}

	/* return the blit sum */
	return blitsum;
}



/*************************************
 *
 *  Line drawing blitter variant
 *
 *************************************/

/*
    The exact line drawing algorithm is not known, but based on the cryptic
    setup instructions, it is clear that it is a basic Bresenham line
    algorithm. A standard Bresenham algorithm looks like this:

    epsilon = 0;
    while (length--)
    {
        plot(x, y);
        x++;
        epsilon += dy;
        if ((2 * epsilon) >= dx)
        {
            y++;
            epsilon -= dx;
        }
    }

    If you multiply the epsilon term by 4 and shuffle the logic a bit, the
    equivalent logic is:

    epsilon = 4 * dy - 2 * dx;
    while (length--)
    {
        plot(x, y);
        x++;
        if (epsilon >= 0)
        {
            y++;
            epsilon += 4 * (dy - dx);
        }
        else
            epsilon += 4 * dy;
    }

    With this refactoring, you can see that BLTAPT = epsilon,
    BLTAMOD = 4 * (dy - dx) and BLTBMOD = 4 * dy.
*/

uint32_t amiga_state::blit_line()
{
	uint32_t singlemode = (CUSTOM_REG(REG_BLTCON1) & 0x0002) ? 0x0000 : 0xffff;
	uint32_t singlemask = 0xffff;
	uint32_t blitsum = 0;
	uint32_t height;

	/* see if folks are breaking the rules */
	if (CUSTOM_REG(REG_BLTSIZH) != 0x0002)
		logerror(""Blitter: Blit width != 2 in line mode!\\n"");
	if ((CUSTOM_REG(REG_BLTCON0) & 0x0a00) != 0x0a00)
		logerror(""Blitter: Channel selection incorrect in line mode!\\n"" );

	/* extract the length of the line */
	height = CUSTOM_REG(REG_BLTSIZV);

	/* iterate over the line height */
	while (height--)
	{
		uint16_t abc0, abc1, abc2, abc3;
		uint32_t tempa, tempb, tempd = 0;
		int b, dx, dy;

		/* fetch data for C */
		if (CUSTOM_REG(REG_BLTCON0) & 0x0200)
			CUSTOM_REG(REG_BLTCDAT) = read_chip_ram(CUSTOM_REG_LONG(REG_BLTCPTH));

		/* rotate the A data according to the shift */
		tempa = CUSTOM_REG(REG_BLTADAT) >> (CUSTOM_REG(REG_BLTCON0) >> 12);

		/* apply single bit mask */
		tempa &= singlemask;
		singlemask &= singlemode;

		/* rotate the B data according to the shift and expand to 16 bits */
		tempb = -((CUSTOM_REG(REG_BLTBDAT) >> (CUSTOM_REG(REG_BLTCON1) >> 12)) & 1);

		/* build up 4 16-bit words containing 4 pixels each in 0ABC bit order */
		abc0 = ((tempa >> 1) & 0x4444) | (tempb & 0x2222) | ((CUSTOM_REG(REG_BLTCDAT) >> 3) & 0x1111);
		abc1 = ((tempa >> 0) & 0x4444) | (tempb & 0x2222) | ((CUSTOM_REG(REG_BLTCDAT) >> 2) & 0x1111);
		abc2 = ((tempa << 1) & 0x4444) | (tempb & 0x2222) | ((CUSTOM_REG(REG_BLTCDAT) >> 1) & 0x1111);
		abc3 = ((tempa << 2) & 0x4444) | (tempb & 0x2222) | ((CUSTOM_REG(REG_BLTCDAT) >> 0) & 0x1111);

		/* now loop over bits and compute the destination value */
		for (b = 0; b < 4; b++)
		{
			uint32_t bit;

			/* shift previous data up 4 bits */
			tempd <<= 4;

			/* lookup first bit in series */
			bit = (CUSTOM_REG(REG_BLTCON0) >> (abc0 >> 12)) & 1;
			abc0 <<= 4;
			tempd |= bit << 3;

			/* lookup second bit in series */
			bit = (CUSTOM_REG(REG_BLTCON0) >> (abc1 >> 12)) & 1;
			abc1 <<= 4;
			tempd |= bit << 2;

			/* lookup third bit in series */
			bit = (CUSTOM_REG(REG_BLTCON0) >> (abc2 >> 12)) & 1;
			abc2 <<= 4;
			tempd |= bit << 1;

			/* lookup fourth bit in series */
			bit = (CUSTOM_REG(REG_BLTCON0) >> (abc3 >> 12)) & 1;
			abc3 <<= 4;
			tempd |= bit << 0;
		}

		/* accumulate the sum */
		blitsum |= tempd;

		/* write to the destination */
		write_chip_ram(CUSTOM_REG_LONG(REG_BLTDPTH), tempd);

		/* always increment along the major axis */
		if (CUSTOM_REG(REG_BLTCON1) & 0x0010)
		{
			dx = (CUSTOM_REG(REG_BLTCON1) & 0x0004) ? -1 : 1;
			dy = 0;
		}
		else
		{
			dx = 0;
			dy = (CUSTOM_REG(REG_BLTCON1) & 0x0004) ? -1 : 1;
		}

		/* is the sign bit clear? */
		if (!(CUSTOM_REG(REG_BLTCON1) & 0x0040))
		{
			/* add 4 * (dy-dx) */
			CUSTOM_REG_LONG(REG_BLTAPTH) += CUSTOM_REG_SIGNED(REG_BLTAMOD) & ~1;

			/* increment along the minor axis */
			if (CUSTOM_REG(REG_BLTCON1) & 0x0010)
				dy = (CUSTOM_REG(REG_BLTCON1) & 0x0008) ? -1 : 1;
			else
				dx = (CUSTOM_REG(REG_BLTCON1) & 0x0008) ? -1 : 1;
		}

		/* else add 4 * dy and don't increment along the minor axis */
		else
			CUSTOM_REG_LONG(REG_BLTAPTH) += CUSTOM_REG_SIGNED(REG_BLTBMOD) & ~1;

		/* adjust X if necessary */
		if (dx)
		{
			/* adjust the A shift value */
			uint32_t temp = CUSTOM_REG(REG_BLTCON0) + (int32_t)(dx << 12);
			CUSTOM_REG(REG_BLTCON0) = temp;

			/* if we went from 0xf to 0x0 or vice-versa, adjust the actual pointers */
			if (temp & 0x10000)
			{
				CUSTOM_REG_LONG(REG_BLTCPTH) += 2 * dx;
				CUSTOM_REG_LONG(REG_BLTDPTH) += 2 * dx;
			}
		}

		/* adjust Y if necessary */
		if (dy)
		{
			/* BLTCMOD seems to be used for both C and D pointers */
			CUSTOM_REG_LONG(REG_BLTCPTH) += dy * (int16_t)(CUSTOM_REG_SIGNED(REG_BLTCMOD) & ~1);
			CUSTOM_REG_LONG(REG_BLTDPTH) += dy * (int16_t)(CUSTOM_REG_SIGNED(REG_BLTCMOD) & ~1);

			/* reset the single mask since we're on a new line */
			singlemask = 0xffff;
		}

		/* set the new sign bit value */
		CUSTOM_REG(REG_BLTCON1) = (CUSTOM_REG(REG_BLTCON1) & ~0x0040) | ((CUSTOM_REG(REG_BLTAPTL) >> 9) & 0x0040);

		/* increment texture shift on every pixel */
		CUSTOM_REG(REG_BLTCON1) += 0x1000;
	}

	return blitsum;
}



/*************************************
 *
 *  Blitter deferred callback
 *
 *************************************/

TIMER_CALLBACK_MEMBER( amiga_state::amiga_blitter_proc )
{
	uint32_t blitsum = 0;

	/* logging */
	if (LOG_BLITS)
	{
		static const char *const type[] = { ""ASCENDING"", ""LINE"", ""DESCENDING"", ""LINE"" };
		logerror(""BLIT %s: %dx%d  %04x %04x\\n"", type[CUSTOM_REG(REG_BLTCON1) & 0x0003], CUSTOM_REG(REG_BLTSIZH), CUSTOM_REG(REG_BLTSIZV), CUSTOM_REG(REG_BLTCON0), CUSTOM_REG(REG_BLTCON1));
		if (CUSTOM_REG(REG_BLTCON0) & 0x0800)
			logerror(""  A: addr=%06X mod=%3d shift=%2d maskl=%04x maskr=%04x\\n"", CUSTOM_REG_LONG(REG_BLTAPTH), CUSTOM_REG_SIGNED(REG_BLTAMOD), CUSTOM_REG(REG_BLTCON0) >> 12, CUSTOM_REG(REG_BLTAFWM), CUSTOM_REG(REG_BLTALWM));
		if (CUSTOM_REG(REG_BLTCON0) & 0x0400)
			logerror(""  B: addr=%06X mod=%3d shift=%2d\\n"", CUSTOM_REG_LONG(REG_BLTBPTH), CUSTOM_REG_SIGNED(REG_BLTBMOD), CUSTOM_REG(REG_BLTCON1) >> 12);
		if (CUSTOM_REG(REG_BLTCON0) & 0x0200)
			logerror(""  C: addr=%06X mod=%3d\\n"", CUSTOM_REG_LONG(REG_BLTCPTH), CUSTOM_REG_SIGNED(REG_BLTCMOD));
		if (CUSTOM_REG(REG_BLTCON0) & 0x0100)
			logerror(""  D: addr=%06X mod=%3d\\n"", CUSTOM_REG_LONG(REG_BLTDPTH), CUSTOM_REG_SIGNED(REG_BLTDMOD));
	}

	/* set the zero flag */
	CUSTOM_REG(REG_DMACON) |= 0x2000;

	/* switch off the type of blit */
	switch (CUSTOM_REG(REG_BLTCON1) & 0x0003)
	{
		case 0: /* ascending */
			blitsum = blit_ascending();
			break;

		case 2: /* descending */
			blitsum = blit_descending();
			break;

		case 1: /* line */
		case 3:
			blitsum = blit_line();
			break;
	}

	/* clear the zero flag if we actually wrote data */
	if (blitsum)
		CUSTOM_REG(REG_DMACON) &= ~0x2000;

	/* no longer busy */
	CUSTOM_REG(REG_DMACON) &= ~0x4000;

	// signal an interrupt
	set_interrupt(INTENA_SETCLR | INTENA_BLIT);

	/* reset the blitter timer */
	m_blitter_timer->reset();
}



/*************************************
 *
 *  Blitter setup
 *
 *************************************/

void amiga_state::blitter_setup()
{
	int ticks, width, height, blittime;

	/* is there another blitting in progress? */
	if (CUSTOM_REG(REG_DMACON) & 0x4000)
	{
		logerror(""%s - This program is playing tricks with the blitter\\n"", machine().describe_context() );
		return;
	}

	/* line mode is 8 ticks/pixel */
	if (CUSTOM_REG(REG_BLTCON1) & 1)
		ticks = 8;

	/* standard mode is 4 ticks base */
	else
	{
		ticks = 4;

		/* plus 2 ticks if channel B is involved */
		if (CUSTOM_REG(REG_BLTCON0) & 0x0400)
			ticks += 2;

		/* plus 2 ticks if both channel C and D are involved */
		if ((CUSTOM_REG(REG_BLTCON0) & 0x0300) == 0x0300)
			ticks += 2;
	}

	/* extract height/width */
	width = CUSTOM_REG(REG_BLTSIZH);
	height = CUSTOM_REG(REG_BLTSIZV);

	/* compute the blit time */
	blittime = ticks * height * width;

	/* if 'blitter-nasty' is set, then the blitter takes over the bus. Make the blit semi-immediate */
	if ( CUSTOM_REG(REG_DMACON) & 0x0400 )
	{
		/* simulate the 68k not running while the blit is going */
		m_maincpu->adjust_icount(-(blittime/2) );

		blittime = BLITTER_NASTY_DELAY;
	}

	/* AGA has twice the bus bandwidth, so blits take half the time */
	if (IS_AGA())
		blittime /= 2;

	/* signal blitter busy */
	CUSTOM_REG(REG_DMACON) |= 0x4000;

	/* set a timer */
	m_blitter_timer->adjust( m_maincpu->cycles_to_attotime( blittime ));
}


//**************************************************************************
//  CENTRONICS
//**************************************************************************

WRITE_LINE_MEMBER( amiga_state::centronics_ack_w )
{
	m_cia_0->flag_w(state);
}

WRITE_LINE_MEMBER( amiga_state::centronics_busy_w )
{
	m_centronics_busy = state;
	m_cia_1->sp_w(state);
}

WRITE_LINE_MEMBER( amiga_state::centronics_perror_w )
{
	m_centronics_perror = state;
	m_cia_1->cnt_w(state);
}

WRITE_LINE_MEMBER( amiga_state::centronics_select_w )
{
	m_centronics_select = state;
}


//**************************************************************************
//  8520 CIA
//**************************************************************************

// CIA-A access: 101x xxxx xxx0 oooo xxxx xxx1
// CIA-B access: 101x xxxx xx0x oooo xxxx xxx0

uint16_t amiga_state::cia_r(offs_t offset, uint16_t mem_mask)
{
	uint16_t data = 0;

	if ((offset & 0x1000/2) == 0 && ACCESSING_BITS_0_7)
		data |= m_cia_0->read(offset >> 7);

	if ((offset & 0x2000/2) == 0 && ACCESSING_BITS_8_15)
		data |= m_cia_1->read(offset >> 7) << 8;

	if (LOG_CIA)
		logerror(""%s: cia_r(%06x) = %04x & %04x\\n"", machine().describe_context(), offset, data, mem_mask);

	return data;
}

void amiga_state::cia_w(offs_t offset, uint16_t data, uint16_t mem_mask)
{
	if (LOG_CIA)
		logerror(""%s: cia_w(%06x) = %04x & %04x\\n"", machine().describe_context(), offset, data, mem_mask);

	if ((offset & 0x1000/2) == 0 && ACCESSING_BITS_0_7)
		m_cia_0->write(offset >> 7, data & 0xff);

	if ((offset & 0x2000/2) == 0 && ACCESSING_BITS_8_15)
		m_cia_1->write(offset >> 7, data >> 8);
}

void amiga_state::gayle_cia_w(offs_t offset, uint16_t data, uint16_t mem_mask)
{
	// the first write to cia 0 after a reset switches in chip ram
	if (m_gayle_reset && (offset & 0x1000/2) == 0 && ACCESSING_BITS_0_7)
	{
		m_gayle_reset = false;
		m_overlay->set_bank(0);
	}

	// hand down to the standard cia handler
	cia_w(offset, data, mem_mask);
}

CUSTOM_INPUT_MEMBER( amiga_state::floppy_drive_status )
{
	return m_fdc->ciaapra_r();
}

void amiga_state::cia_0_port_a_write(uint8_t data)
{
	// bit 0, kickstart overlay
	m_overlay->set_bank(BIT(data, 0));

	// bit 1, power led
	m_power_led = BIT(~data, 1);
}

WRITE_LINE_MEMBER( amiga_state::cia_0_irq )
{
	if (LOG_CIA)
		logerror(""%s: cia_0_irq: %d\\n"", machine().describe_context(), state);

	m_cia_0_irq = state;
	update_int2();
}

uint8_t amiga_state::cia_1_port_a_read()
{
	uint8_t data = 0;

	// bit 0 to 2, centronics
	data |= m_centronics_busy << 0;
	data |= m_centronics_perror << 1;
	data |= m_centronics_select << 2;

	// bit 2 to 7, serial line
	data |= m_rs232_ri << 2;
	data |= m_rs232_dsr << 3;
	data |= m_rs232_cts << 4;
	data |= m_rs232_dcd << 5;

	return data;
}

void amiga_state::cia_1_port_a_write(uint8_t data)
{
	if (m_rs232)
	{
		m_rs232->write_rts(BIT(data, 6));
		m_rs232->write_dtr(BIT(data, 7));
	}
}

WRITE_LINE_MEMBER( amiga_state::cia_1_irq )
{
	if (LOG_CIA)
		logerror(""%s: cia_1_irq: %d\\n"", machine().describe_context(), state);

	m_cia_1_irq = state;
	update_int6();
}


//**************************************************************************
//  CUSTOM CHIPS
//**************************************************************************

void amiga_state::custom_chip_reset()
{
	CUSTOM_REG(REG_DENISEID) = m_denise_id;
	CUSTOM_REG(REG_VPOSR) = m_agnus_id << 8;
	CUSTOM_REG(REG_DDFSTRT) = 0x18;
	CUSTOM_REG(REG_DDFSTOP) = 0xd8;
	CUSTOM_REG(REG_INTENA) = 0x0000;
	CUSTOM_REG(REG_SERDATR) = SERDATR_RXD | SERDATR_TSRE | SERDATR_TBE;
	CUSTOM_REG(REG_BEAMCON0) = (m_agnus_id & 0x10) ? 0x0000 : 0x0020;
}

uint16_t amiga_state::custom_chip_r(offs_t offset)
{
	uint16_t temp;

	if (LOG_CUSTOM)
		logerror(""%06X:read from custom %s\\n"", m_maincpu->pc(), s_custom_reg_names[offset & 0xff]);

	switch (offset & 0xff)
	{
		case REG_BLTDDAT:
			return CUSTOM_REG(REG_BLTDDAT);

		case REG_DMACONR:
			return CUSTOM_REG(REG_DMACON);

		case REG_VPOSR:
			CUSTOM_REG(REG_VPOSR) &= 0xff00;
			CUSTOM_REG(REG_VPOSR) |= amiga_gethvpos() >> 16;

			return CUSTOM_REG(REG_VPOSR);

		case REG_VHPOSR:
			return amiga_gethvpos() & 0xffff;

		case REG_SERDATR:
			if (LOG_SERIAL)
				logerror(""r SERDATR: %04x\\n"", CUSTOM_REG(REG_SERDATR));

			return CUSTOM_REG(REG_SERDATR);

		case REG_JOY0DAT:
			if (m_joy0dat_port.found())
				return joy0dat_r();
			[[fallthrough]]; // FIXME: Really?  Fall through to potentially reading the other joystick?
		case REG_JOY1DAT:
			if (m_joy1dat_port.found())
				return joy1dat_r();
			[[fallthrough]]; // TODO: check that this is correct
		case REG_POTGOR:
			return m_potgo_port.read_safe(0x5500);

		case REG_POT0DAT:
			if (m_pot0dat_port.found())
			{
				return m_pot0dat_port->read();
			}
			else
			{
				int scale = m_agnus_id & 0x10 ? 525 : 625;

				m_pot0dat  = (int) ((double) m_pot0x / scale) * 0xff;
				m_pot0dat |= (int)(((double) m_pot0y / scale) * 0xff) << 8;

				return m_pot0dat;
			}

		case REG_POT1DAT:
			if (m_pot1dat_port.found())
			{
				return m_pot1dat_port->read();
			}
			else
			{
				int scale = m_agnus_id & 0x10 ? 525 : 625;

				m_pot1dat  = (int) ((double) m_pot1x / scale) * 0xff;
				m_pot1dat |= (int)(((double) m_pot1y / scale) * 0xff) << 8;

				return m_pot1dat;
			}

		case REG_DSKBYTR:
			return m_fdc->dskbytr_r();

		case REG_INTENAR:
			return CUSTOM_REG(REG_INTENA);

		case REG_INTREQR:
			return CUSTOM_REG(REG_INTREQ);

		case REG_COPJMP1:
			copper_setpc(CUSTOM_REG_LONG(REG_COP1LCH));
			break;

		case REG_COPJMP2:
			copper_setpc(CUSTOM_REG_LONG(REG_COP2LCH));
			break;

		case REG_CLXDAT:
			temp = CUSTOM_REG(REG_CLXDAT);
			CUSTOM_REG(REG_CLXDAT) = 0;
			return temp;

		case REG_DENISEID:
			return CUSTOM_REG(REG_DENISEID);

		case REG_DSKPTH:
			return m_fdc->dskpth_r();

		case REG_DSKPTL:
			return m_fdc->dskptl_r();

		case REG_ADKCONR:
			return m_fdc->adkcon_r();

		case REG_DSKDATR:
			popmessage(""DSKDAT R, contact MESSdev"");
			break;
	}

	return 0xffff;
}

void amiga_state::custom_chip_w(offs_t offset, uint16_t data)
{
	uint16_t temp;
	offset &= 0xff;

	if (LOG_CUSTOM)
		logerror(""%06X:write to custom %s = %04X\\n"", m_maincpu->pc(), s_custom_reg_names[offset & 0xff], data);

	// paula will handle some of those registers
	m_paula->reg_w(offset, data);

	switch (offset)
	{
		case REG_BLTDDAT:   case REG_DMACONR:   case REG_VPOSR:     case REG_VHPOSR:
		case REG_DSKDATR:   case REG_JOY0DAT:   case REG_JOY1DAT:   case REG_CLXDAT:
		case REG_ADKCONR:   case REG_POT0DAT:   case REG_POT1DAT:   case REG_POTGOR:
		case REG_SERDATR:   case REG_DSKBYTR:   case REG_INTENAR:   case REG_INTREQR:
			// read-only registers
			return;

		case REG_DSKDAT:
			popmessage(""DSKDAT W %04x, contact MESSdev"",data);
			break;

		case REG_DSKSYNC:
			m_fdc->dsksync_w(data);
			break;

		case REG_DSKPTH:
			m_fdc->dskpth_w(data);
			break;

		case REG_DSKPTL:
			m_fdc->dskptl_w(data);
			break;

		case REG_DSKLEN:
			m_fdc->dsklen_w(data);
			break;

		case REG_POTGO:
			if (BIT(data, 0))
			{
				// start counters
				m_pot0x = 0;
				m_pot0y = 0;
				m_pot1x = 0;
				m_pot1y = 0;
			}
			potgo_w(data);
			break;

		case REG_SERDAT:
			if (LOG_SERIAL)
				logerror(""w SERDAT: %04x\\n"", data);

			CUSTOM_REG(REG_SERDAT) = data;

			// transmit shift register currently empty?
			if (CUSTOM_REG(REG_SERDATR) & SERDATR_TSRE)
			{
				// transfer new data to shift register
				m_tx_shift = CUSTOM_REG(REG_SERDAT);
				CUSTOM_REG(REG_SERDAT) = 0;

				// and signal transmit buffer empty
				CUSTOM_REG(REG_SERDATR) &= ~SERDATR_TSRE;
				CUSTOM_REG(REG_SERDATR) |= SERDATR_TBE;
				set_interrupt(INTENA_SETCLR | INTENA_TBE);
			}
			else
			{
				// transmit buffer now full
				CUSTOM_REG(REG_SERDATR) &= ~SERDATR_TBE;
			}

			return;

		case REG_SERPER:
			if (LOG_SERIAL)
				logerror(""w SERPER: %04x\\n"", data);

			CUSTOM_REG(REG_SERPER) = data;
			serial_adjust();

			return;

		case REG_BLTSIZE:
			CUSTOM_REG(REG_BLTSIZE) = data;
			CUSTOM_REG(REG_BLTSIZV) = (data >> 6) & 0x3ff;
			CUSTOM_REG(REG_BLTSIZH) = data & 0x3f;
			if ( CUSTOM_REG(REG_BLTSIZV) == 0 ) CUSTOM_REG(REG_BLTSIZV) = 0x400;
			if ( CUSTOM_REG(REG_BLTSIZH) == 0 ) CUSTOM_REG(REG_BLTSIZH) = 0x40;
			blitter_setup();
			break;

		case REG_BLTSIZV:
			if (IS_ECS() || IS_AGA())
			{
				CUSTOM_REG(REG_BLTSIZV) = data & 0x7fff;
				if ( CUSTOM_REG(REG_BLTSIZV) == 0 ) CUSTOM_REG(REG_BLTSIZV) = 0x8000;
			}
			break;

		case REG_BLTSIZH:
			if (IS_ECS() || IS_AGA())
			{
				CUSTOM_REG(REG_BLTSIZH) = data & 0x7ff;
				if ( CUSTOM_REG(REG_BLTSIZH) == 0 ) CUSTOM_REG(REG_BLTSIZH) = 0x800;
				blitter_setup();
			}
			break;

		case REG_BLTCON0L:
			if (IS_ECS() || IS_AGA())
			{
				CUSTOM_REG(REG_BLTCON0) &= 0xff00;
				CUSTOM_REG(REG_BLTCON0) |= data & 0xff;
			}
			break;

		case REG_SPR0PTH:   case REG_SPR1PTH:   case REG_SPR2PTH:   case REG_SPR3PTH:
		case REG_SPR4PTH:   case REG_SPR5PTH:   case REG_SPR6PTH:   case REG_SPR7PTH:
			data &= ( m_chip_ram_mask >> 16 );
			break;

		case REG_SPR0PTL:   case REG_SPR1PTL:   case REG_SPR2PTL:   case REG_SPR3PTL:
		case REG_SPR4PTL:   case REG_SPR5PTL:   case REG_SPR6PTL:   case REG_SPR7PTL:
			sprite_dma_reset((offset - REG_SPR0PTL) / 2);
			break;

		case REG_SPR0CTL:   case REG_SPR1CTL:   case REG_SPR2CTL:   case REG_SPR3CTL:
		case REG_SPR4CTL:   case REG_SPR5CTL:   case REG_SPR6CTL:   case REG_SPR7CTL:
			/* disable comparitor on writes here */
			sprite_enable_comparitor((offset - REG_SPR0CTL) / 4, false);
			break;

		case REG_SPR0DATA:  case REG_SPR1DATA:  case REG_SPR2DATA:  case REG_SPR3DATA:
		case REG_SPR4DATA:  case REG_SPR5DATA:  case REG_SPR6DATA:  case REG_SPR7DATA:
			/* enable comparitor on writes here */
			sprite_enable_comparitor((offset - REG_SPR0DATA) / 4, true);
			break;

		case REG_COP1LCH:
		case REG_COP2LCH:
			data &= ( m_chip_ram_mask >> 16 );
			break;

		case REG_COPJMP1:
			copper_setpc(CUSTOM_REG_LONG(REG_COP1LCH));
			break;

		case REG_COPJMP2:
			copper_setpc(CUSTOM_REG_LONG(REG_COP2LCH));
			break;

		case REG_DDFSTRT:
			/* impose hardware limits ( HRM, page 75 ) */
			data &= 0xfe;
			if (data < 0x18)
				data = 0x18;
			break;

		case REG_DDFSTOP:
			/* impose hardware limits ( HRM, page 75 ) */
			data &= 0xfe;
			if (data > 0xd8)
				data = 0xd8;
			break;

		case REG_DMACON:
			/* bits BBUSY (14) and BZERO (13) are read-only */
			data &= 0x9fff;
			data = (data & 0x8000) ? (CUSTOM_REG(offset) | (data & 0x7fff)) : (CUSTOM_REG(offset) & ~(data & 0x7fff));
			m_fdc->dmacon_set(data);

			/* if 'blitter-nasty' has been turned on and we have a blit pending, reschedule it */
			if ( ( data & 0x400 ) && ( CUSTOM_REG(REG_DMACON) & 0x4000 ) )
				m_blitter_timer->adjust(m_maincpu->cycles_to_attotime(BLITTER_NASTY_DELAY));

			break;

		case REG_INTENA:
			temp = data;

			data = (data & INTENA_SETCLR) ? (CUSTOM_REG(offset) | (data & 0x7fff)) : (CUSTOM_REG(offset) & ~(data & 0x7fff));
			CUSTOM_REG(offset) = data;
			if (temp & INTENA_SETCLR)
				// if we're enabling irq's, delay a bit
				m_irq_timer->adjust(m_maincpu->cycles_to_attotime(AMIGA_IRQ_DELAY_CYCLES));
			else
				// if we're disabling irq's, process right away
				update_irqs();
			break;

		case REG_INTREQ:
			temp = data;

			// clear receive buffer full?
			if (!(data & INTENA_SETCLR) && (data & INTENA_RBF))
			{
				CUSTOM_REG(REG_SERDATR) &= ~SERDATR_OVRUN;
				CUSTOM_REG(REG_SERDATR) &= ~SERDATR_RBF;
			}

			// clear transmit buffer empty?
			if (!(data & INTENA_SETCLR) && (data & INTENA_TBE))
				CUSTOM_REG(REG_SERDATR) |= SERDATR_TBE;

			data = (data & INTENA_SETCLR) ? (CUSTOM_REG(offset) | (data & 0x7fff)) : (CUSTOM_REG(offset) & ~(data & 0x7fff));
			CUSTOM_REG(offset) = data;

			if (temp & INTENA_SETCLR)
				// if we're generating irq's, delay a bit
				m_irq_timer->adjust(m_maincpu->cycles_to_attotime(AMIGA_IRQ_DELAY_CYCLES));
			else
				// if we're clearing irq's, process right away
				update_irqs();
			break;

		case REG_ADKCON:
			data = (data & 0x8000) ? (CUSTOM_REG(offset) | (data & 0x7fff)) : (CUSTOM_REG(offset) & ~(data & 0x7fff));
			m_fdc->adkcon_set(data);
			break;

		case REG_BPL1PTH:   case REG_BPL2PTH:   case REG_BPL3PTH:   case REG_BPL4PTH:
		case REG_BPL5PTH:   case REG_BPL6PTH:
			data &= ( m_chip_ram_mask >> 16 );
			break;

		case REG_BPLCON0:
			if ((data & (BPLCON0_BPU0 | BPLCON0_BPU1 | BPLCON0_BPU2)) == (BPLCON0_BPU0 | BPLCON0_BPU1 | BPLCON0_BPU2))
			{
				/* planes go from 0 to 6, inclusive */
				logerror( ""This game is doing funky planes stuff. (planes > 6)\\n"" );
				data &= ~BPLCON0_BPU0;
			}
			CUSTOM_REG(offset) = data;
			break;

		case REG_BPL1MOD:   case REG_BPL2MOD:
			// bit 0 is implicitly ignored on writes,
			// and wouldn't otherwise make sense with 68k inability of word reading with odd addresses.
			// hpoker/hpokera would otherwise draw misaligned bottom GFX area without this (writes 0x27)
			data &= ~1;
			break;

		case REG_COLOR00:   case REG_COLOR01:   case REG_COLOR02:   case REG_COLOR03:
		case REG_COLOR04:   case REG_COLOR05:   case REG_COLOR06:   case REG_COLOR07:
		case REG_COLOR08:   case REG_COLOR09:   case REG_COLOR10:   case REG_COLOR11:
		case REG_COLOR12:   case REG_COLOR13:   case REG_COLOR14:   case REG_COLOR15:
		case REG_COLOR16:   case REG_COLOR17:   case REG_COLOR18:   case REG_COLOR19:
		case REG_COLOR20:   case REG_COLOR21:   case REG_COLOR22:   case REG_COLOR23:
		case REG_COLOR24:   case REG_COLOR25:   case REG_COLOR26:   case REG_COLOR27:
		case REG_COLOR28:   case REG_COLOR29:   case REG_COLOR30:   case REG_COLOR31:
			if (IS_AGA())
			{
				aga_palette_write(offset - REG_COLOR00, data);
			}
			else
			{
				data &= 0xfff;
				CUSTOM_REG(offset + 32) = (data >> 1) & 0x777;
			}
			break;

		// display window start/stop
		case REG_DIWSTRT:
		case REG_DIWSTOP:
			m_diwhigh_valid = false;
			break;

		// display window high
		case REG_DIWHIGH:
			if (IS_ECS() || IS_AGA())
			{
				m_diwhigh_valid = true;
				CUSTOM_REG(REG_DIWHIGH) = data;
			}
			break;

		case REG_BEAMCON0:
			// only available on ecs agnus
			if (m_agnus_id >= AGNUS_HR_PAL)
			{
				CUSTOM_REG(REG_BEAMCON0) = data;
				update_screenmode();
			}
			break;

		default:
			break;
	}

	if (IS_AGA())
		CUSTOM_REG(offset) = data;
	else
		if (offset <= REG_COLOR31)
			CUSTOM_REG(offset) = data;
}


//**************************************************************************
//  SERIAL
//**************************************************************************

void amiga_state::serial_adjust()
{
	uint32_t divisor = (CUSTOM_REG(REG_SERPER) & 0x7fff) + 1;
	uint32_t baud = m_paula->clock() / divisor;

	m_serial_timer->adjust(attotime::from_hz(baud) / 2, 0, attotime::from_hz(baud));
}

void amiga_state::serial_shift()
{
	if (CUSTOM_REG(REG_ADKCON) & ADKCON_UARTBRK)
	{
		// break active, force low
		rs232_tx(0);
	}
	else
	{
		// transmit shift register not empty?
		if ((CUSTOM_REG(REG_SERDATR) & SERDATR_TSRE) == 0)
		{
			if (m_tx_state == 0)
			{
				// transmit start bit
				rs232_tx(0);
				m_tx_state++;
			}
			else if (m_tx_state <= 8 + BIT(CUSTOM_REG(REG_SERPER), 15))
			{
				// send data bits
				rs232_tx(m_tx_shift & 1);
				m_tx_shift >>= 1;
				m_tx_state++;
			}
			else
			{
				// send stop bits until we run out
				if (m_tx_shift & 1)
				{
					rs232_tx(m_tx_shift & 1);
					m_tx_shift >>= 1;
				}
				else
				{
					// more data?
					if (CUSTOM_REG(REG_SERDAT))
					{
						// transfer to shift register
						m_tx_shift = CUSTOM_REG(REG_SERDAT);
						CUSTOM_REG(REG_SERDAT) = 0;

						// signal buffer empty
						CUSTOM_REG(REG_SERDATR) |= SERDATR_TBE;
						set_interrupt(INTENA_SETCLR | INTENA_TBE);
					}
					else
					{
						// we're done
						CUSTOM_REG(REG_SERDATR) |= SERDATR_TSRE;
					}

					m_tx_state = 0;
				}
			}
		}
		else
		{
			// transmit register empty
			rs232_tx(1);
		}
	}

	// waiting for start bit?
	if (m_rx_state == 0)
	{
		// start bit seen (high to low transition)
		if (m_rx_previous && (CUSTOM_REG(REG_SERDATR) & SERDATR_RXD) == 0)
		{
			m_rx_state++;
		}
	}
	else if (m_rx_state <= 8 + BIT(CUSTOM_REG(REG_SERPER), 15))
	{
		// receive data
		m_rx_shift >>= 1;
		m_rx_shift = (m_rx_shift & 0x7fff) | (BIT(CUSTOM_REG(REG_SERDATR), 11) << 15);
		m_rx_state++;
	}
	else
	{
		// stop bit
		m_rx_shift >>= 1;
		m_rx_shift = (m_rx_shift & 0x7fff) | (BIT(CUSTOM_REG(REG_SERDATR), 11) << 15);

		// shift to start
		m_rx_shift >>= (15 - (8 + BIT(CUSTOM_REG(REG_SERPER), 15)));

		// save data
		CUSTOM_REG(REG_SERDATR) &= ~0x3ff;
		CUSTOM_REG(REG_SERDATR) |= m_rx_shift & 0x3ff;

		// overrun?
		if (CUSTOM_REG(REG_SERDATR) & SERDATR_RBF)
			CUSTOM_REG(REG_SERDATR) |= SERDATR_OVRUN;

		// set ready and signal interrupt
		CUSTOM_REG(REG_SERDATR) |= SERDATR_RBF;
		set_interrupt(INTENA_SETCLR | INTENA_RBF);

		m_rx_shift = 0;
		m_rx_state = 0;
	}
}

void amiga_state::rs232_tx(int state)
{
	if (m_rs232)
		m_rs232->write_txd(state);
}

void amiga_state::rx_write(int level)
{
	m_rx_previous = BIT(CUSTOM_REG(REG_SERDATR), 11);
	CUSTOM_REG(REG_SERDATR) &= ~SERDATR_RXD;
	CUSTOM_REG(REG_SERDATR) |= level << 11;
}

WRITE_LINE_MEMBER( amiga_state::rs232_rx_w )
{
	rx_write(state);

	// start bit received?
	if (m_rx_state == 1)
		serial_adjust();
}

WRITE_LINE_MEMBER( amiga_state::rs232_dcd_w )
{
	m_rs232_dcd = state;
}

WRITE_LINE_MEMBER( amiga_state::rs232_dsr_w )
{
	m_rs232_dsr = state;
}

WRITE_LINE_MEMBER( amiga_state::rs232_ri_w )
{
	m_rs232_ri = state;
}

WRITE_LINE_MEMBER( amiga_state::rs232_cts_w )
{
	m_rs232_cts = state;
}
",16367,True,2865.656869330875,median
"// Copyright 2017 the original author or 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
//
// 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.

[[java_plugin]]
== The Java Plugin

The Java plugin adds Java compilation along with testing and bundling capabilities to a project. It serves as the basis for many of the other Gradle plugins.


[[sec:java_usage]]
=== Usage

To use the Java plugin, include the following in your build script:

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""useJavaPlugin"" dir=""java/quickstart"" title=""Using the Java plugin"">
            <sourcefile file=""build.gradle"" snippet=""use-plugin""/>
        </sample>
++++


[[sec:java_source_sets]]
=== Source sets

The Java plugin introduces the concept of a _source set_. A source set is simply a group of source files which are compiled and executed together. These source files may include Java source files and resource files. Other plugins add the ability to include Groovy and Scala source files in a source set. A source set has an associated compile classpath, and runtime classpath.

One use for source sets is to group source files into logical groups which describe their purpose. For example, you might use a source set to define an integration test suite, or you might use separate source sets to define the API and implementation classes of your project.

The Java plugin defines two standard source sets, called `main` and `test`. The `main` source set contains your production source code, which is compiled and assembled into a JAR file. The `test` source set contains your test source code, which is compiled and executed using JUnit or TestNG. These can be unit tests, integration tests, acceptance tests, or any combination that is useful to you.

[[sec:java_tasks]]
=== Tasks

The Java plugin adds a number of tasks to your project, as shown below.

`compileJava(type: api:org.gradle.api.tasks.compile.JavaCompile[])`::
_Compiles production Java source files using javac._ Depends on all tasks which produce the compile classpath. This includes the `jar` task for project dependencies included in the `compile` configuration.

`processResources(type: api:org.gradle.api.tasks.Copy[])`::
_Copies production resources into the production resources directory._

`classes(type: api:org.gradle.api.Task[])`::
_Assembles the production classes and resources directories._

`compileTestJava(type: api:org.gradle.api.tasks.compile.JavaCompile[])`::
_Compiles test Java source files using javac._ Depends on `compile`, plus all tasks which produce the test compile classpath.

`processTestResources(type: api:org.gradle.api.tasks.Copy[])`::
_Copies test resources into the test resources directory._

`testClasses(type: api:org.gradle.api.Task[])`::
_Assembles the test classes and resources directories._ Depends on `compileTestJava` task and `processTestResources` task. Some plugins add additional test compilation tasks.

`jar(type: api:org.gradle.api.tasks.bundling.Jar[])`::
_Assembles the JAR file._ Depends on `compile`.

`javadoc(type: api:org.gradle.api.tasks.javadoc.Javadoc[])`::
_Generates API documentation for the production Java source, using Javadoc_. Depends on `compile`.

`test(type: api:org.gradle.api.tasks.testing.Test[])`::
_Runs the unit tests using JUnit or TestNG._ Depends on `compile`, `compileTest`, plus all tasks which produce the test runtime classpath.

`uploadArchives(type: api:org.gradle.api.tasks.Upload[])`::
_Uploads artifacts in the `archives` configuration, including the JAR file._ Depends on the tasks which produce the artifacts in the `archives` configuration, including `jar`.

`clean(type: api:org.gradle.api.tasks.Delete[])`::
_Deletes the project build directory._

`clean__TaskName__(type: api:org.gradle.api.tasks.Delete[])`::
_Deletes files created by specified task. `cleanJar` will delete the JAR file created by the `jar` task, and `cleanTest` will delete the test results created by the `test` task._

For each source set you add to the project, the Java plugin adds the following compilation tasks:

[[java_source_set_tasks]]
==== SourceSet Tasks

`compile__SourceSet__Java(type: api:org.gradle.api.tasks.compile.JavaCompile[])`::
_Compiles the given source set's Java source files using javac._ Depends on all tasks which produce the source set's compile classpath.

`process__SourceSet__Resources(type: api:org.gradle.api.tasks.Copy[])`::
_Copies the given source set's resources into the resources directory._

`__sourceSet__Classes(type: api:org.gradle.api.Task[])`::
_Assembles the given source set's classes and resources directories._ Depends on the `compile__SourceSet__Java` task and the `process__SourceSet__Resources` task. Some plugins add additional compilation tasks for the source set.

==== Lifecycle Tasks
The Java plugin also adds a number of tasks which form a lifecycle for the project:

`assemble(type: api:org.gradle.api.Task[])`::
_Assembles all the archives in the project._ Depends on all archive tasks in the project, including `jar`. Some plugins add additional archive tasks to the project.

`check(type: api:org.gradle.api.Task[])`::
_Performs all verification tasks in the project._ Depends on all verification tasks in the project, including `test`. Some plugins add additional verification tasks to the project.

`build(type: api:org.gradle.api.Task[])`::
_Performs a full build of the project._ Depends on `check` and `assemble`.

`buildNeeded(type: api:org.gradle.api.Task[])`::
_Performs a full build of the project and all projects it depends on._ Depends on `build` and `buildNeeded` tasks in all project lib dependencies of the `testRuntime` configuration.

`buildDependents(type: api:org.gradle.api.Task[])`::
_Performs a full build of the project and all projects which depend on it._ Depends on `build` and `buildDependents` tasks in all projects with a project lib dependency on this project in a `testRuntime` configuration.

`build__ConfigName__(type: api:org.gradle.api.Task[])`::
_Assembles the artifacts in the specified configuration. The task is added by the Base plugin which is implicitly applied by the Java plugin._ Depends on the tasks which produce the artifacts in configuration __ConfigName__.

`upload__ConfigName__(type: api:org.gradle.api.tasks.Upload[])`::
_Assembles and uploads the artifacts in the specified configuration. The task is added by the Base plugin which is implicitly applied by the Java plugin._ Depends on the tasks which uploads the artifacts in configuration __ConfigName__.

The following diagram shows the relationships between these tasks.

++++
<figure xmlns:xi=""http://www.w3.org/2001/XInclude"">
            <title>Java plugin - tasks</title>
            <imageobject>
                <imagedata fileref=""img/javaPluginTasks.png""/>
            </imageobject>
        </figure>
++++


[[sec:java_project_layout]]
=== Project layout

The Java plugin assumes the project layout shown below. None of these directories need to exist or have anything in them. The Java plugin will compile whatever it finds, and handles anything which is missing.

[[javalayout]]
.Java plugin - default project layout
[cols=""a,a,a"", options=""header""]
|===
| Directory
|
| Meaning

include::javaProjectMainLayout.adoc[]
include::javaProjectTestLayout.adoc[]
include::javaProjectGenericLayout.adoc[]
|===


[[sec:changing_java_project_layout]]
==== Changing the project layout

You configure the project layout by configuring the appropriate source set. This is discussed in more detail in the following sections. Here is a brief example which changes the main Java and resource source directories.

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""customJavaSourceLayout"" dir=""java/customizedLayout"" title=""Custom Java source layout"">
                <sourcefile file=""build.gradle"" snippet=""define-main""/>
            </sample>
++++


[[sec:java_plugin_and_dependency_management]]
=== Dependency management

The Java plugin adds a number of <<managing_dependency_configurations,dependency configurations>> to your project, as shown below. It assigns those configurations to tasks such as `compileJava` and `test`.

[[tab:configurations]]
==== Dependency configurations

[NOTE]
====

For `api` configuration introduced by `java-library` plugin, please consult <<java_library_separation, Java Library Plugin>> and <<dependency_management_for_java_projects, Dependency Management Tutorial>>.

====

[.line-through]#`compile`#(Deprecated)::
_Compile time dependencies._ Superseded by `implementation`.

`implementation` extends `compile`::
_Implementation only dependencies._

`compileOnly`::
_Compile time only dependencies, not used at runtime._

`compileClasspath` extends `compile, compileOnly, implementation`::
_Compile classpath, used when compiling source._ Used by task `compileJava`.

`annotationProcessor`::
_Annotation processors used during compilation._

[.line-through]#`runtime`#(Deprecated) extends `compile`::
_Runtime dependencies._ Superseded by `runtimeOnly`.

`runtimeOnly`::
_Runtime only dependencies._

`runtimeClasspath` extends `runtimeOnly, runtime, implementation`::
_Runtime classpath contains elements of the implementation, as well as runtime only elements._

[.line-through]#`testCompile`#(Deprecated) extends `compile`::
_Additional dependencies for compiling tests._ Superseded by `testImplementation`.

`testImplementation` extends `testCompile, implementation`::
_Implementation only dependencies for tests._

`testCompileOnly`::
_Additional dependencies only for compiling tests, not used at runtime._

`testCompileClasspath` extends `testCompile, testCompileOnly, testImplementation`::
_Test compile classpath, used when compiling test sources._ Used by task `compileTestJava`.

[.line-through]#`testRuntime`#(Deprecated) extends `runtime, testCompile`::
_Additional dependencies for running tests only._ Used by task `test`. Superseded by `testRuntimeOnly`.

`testRuntimeOnly` extends `runtimeOnly`::
_Runtime only dependencies for running tests._ Used by task `test`.

`testRuntimeClasspath` extends `testRuntimeOnly, testRuntime, testImplementation`::
_Runtime classpath for running tests._

`archives`::
Artifacts (e.g. jars) produced by this project. Used by tasks `uploadArchives`.

`default` extends `runtime`::
_The default configuration used by a project dependency on this project._ Contains the artifacts and dependencies required by this project at runtime.

++++
<figure xmlns:xi=""http://www.w3.org/2001/XInclude"">
            <title>Java plugin - dependency configurations</title>
            <imageobject>
                <imagedata fileref=""img/javaPluginConfigurations.png""/>
            </imageobject>
        </figure>
++++

For each source set you add to the project, the Java plugins adds the following dependency configurations:

[[java_source_set_configurations]]
==== SourceSet dependency configurations

[.line-through]#`__sourceSet__Compile`#(Deprecated)::
_Compile time dependencies for the given source set._ Superseded by `__sourceSet__Implementation`.

`__sourceSet__Implementation` extends `__sourceSet__Compile`::
_Compile time dependencies for the given source set._ Used by `__sourceSet__CompileClasspath, __sourceSet__RuntimeClasspath`.

`__sourceSet__CompileOnly`::
_Compile time only dependencies for the given source set, not used at runtime._

`__sourceSet__CompileClasspath` extends `compile__SourceSet__Java`::
_Compile classpath, used when compiling source._ Used by `__sourceSet__Compile, __sourceSet__CompileOnly, __sourceSet__Implementation`.

`__sourceSet__AnnotationProcessor`::
_Annotation processors used during compilation of this source set._

[.line-through]#`__sourceSet__Runtime`#(Deprecated)::
_Runtime dependencies for the given source set._ Used by `__sourceSet__Compile`. Superseded by `__sourceSet__RuntimeOnly`.

`__sourceSet__RuntimeOnly`::
_Runtime only dependencies for the given source set._

`__sourceSet__RuntimeClasspath` extends `__sourceSet__RuntimeOnly, __sourceSet__Runtime, __sourceSet__Implementation`::
_Runtime classpath contains elements of the implementation, as well as runtime only elements._

[[sec:java_convention_properties]]
=== Convention properties

The Java plugin adds a number of convention properties to the project, shown below. You can use these properties in your build script as though they were properties of the project object.

==== Directory properties

`String reportsDirName`::
_The name of the directory to generate reports into, relative to the build directory._ Default value: `reports`

`(read-only) File reportsDir`::
_The directory to generate reports into._ Default value: `__buildDir__/__reportsDirName__`

`String testResultsDirName`::
_The name of the directory to generate test result .xml files into, relative to the build directory._ Default value: `test-results`

`(read-only) File testResultsDir`::
_The directory to generate test result .xml files into._ Default value: `__buildDir__/__testResultsDirName__`

`String testReportDirName`::
_The name of the directory to generate the test report into, relative to the reports directory._ Default value: `tests`

`(read-only) File testReportDir`::
_The directory to generate the test report into._ Default value: `__reportsDir__/testReportDirName`

`String libsDirName`::
_The name of the directory to generate libraries into, relative to the build directory._ Default value: `libs`

`(read-only) File libsDir`::
_The directory to generate libraries into._ Default value: `__buildDir__/__libsDirName__`

`String distsDirName`::
_The name of the directory to generate distributions into, relative to the build directory._ Default value: `distributions`

`(read-only) File distsDir`::
_The directory to generate distributions into._ Default value: `__buildDir__/__distsDirName__`

`String docsDirName`:
:_The name of the directory to generate documentation into, relative to the build directory._ Default value: `docs`

`(read-only) File docsDir`::
_The directory to generate documentation into._ Default value: `__buildDir__/__docsDirName__`

`String dependencyCacheDirName`::
_The name of the directory to use to cache source dependency information, relative to the build directory._ Default value: `dependency-cache`

==== Other convention properties

`(read-only) api:org.gradle.api.tasks.SourceSetContainer[] sourceSets`::
_Contains the project's source sets._ Default value: Not null api:org.gradle.api.tasks.SourceSetContainer[]

`api:org.gradle.api.JavaVersion[] sourceCompatibility`::
_Java version compatibility to use when compiling Java source._ Default value: version of the current JVM in use api:org.gradle.api.JavaVersion[]. Can also set using a String or a Number, e.g. `'1.5'` or `1.5`.

`api:org.gradle.api.JavaVersion[] targetCompatibility`::
_Java version to generate classes for._ Default value: `__sourceCompatibility__`. Can also set using a String or Number, e.g. `'1.5'` or `1.5`.

`String archivesBaseName`::
_The basename to use for archives, such as JAR or ZIP files._ Default value: `__projectName__`

`api:org.gradle.api.java.archives.Manifest[] manifest`::
_The manifest to include in all JAR files._ Default value: an empty manifest.

These properties are provided by convention objects of type api:org.gradle.api.plugins.JavaPluginConvention[], and api:org.gradle.api.plugins.BasePluginConvention[].

[[sec:working_with_java_source_sets]]
=== Working with source sets

You can access the source sets of a project using the `sourceSets` property. This is a container for the project's source sets, of type api:org.gradle.api.tasks.SourceSetContainer[]. There is also a `sourceSets { }` script block, which you can pass a closure to configure the source set container. The source set container works pretty much the same way as other containers, such as `tasks`.

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""defineSourceSet"" dir=""userguide/java/sourceSets"" title=""Accessing a source set"">
            <sourcefile file=""build.gradle"" snippet=""access-source-set""/>
        </sample>
++++

To configure an existing source set, you simply use one of the above access methods to set the properties of the source set. The properties are described below. Here is an example which configures the main Java and resources directories:

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""configureSourceSet"" dir=""java/customizedLayout"" title=""Configuring the source directories of a source set"">
            <sourcefile file=""build.gradle"" snippet=""define-main""/>
        </sample>
++++


[[sec:source_set_properties]]
==== Source set properties

The following table lists some of the important properties of a source set. You can find more details in the API documentation for api:org.gradle.api.tasks.SourceSet[].

`(read-only) String name`::
_The name of the source set, used to identify it._ Default value: Not null

`(read-only) api:org.gradle.api.tasks.SourceSetOutput[] output`::
_The output files of the source set, containing its compiled classes and resources._ Default value: Not null

`api:org.gradle.api.file.FileCollection[] output.classesDirs`::
_The directories to generate the classes of this source set into._ Default value: Not null

`File output.resourcesDir`::
_The directory to generate the resources of this source set into._ Default value: `__buildDir__/resources/__name__`

`api:org.gradle.api.file.FileCollection[] compileClasspath`::
_The classpath to use when compiling the source files of this source set._ Default value: `__sourceSet__CompileClasspath` configuration.

`api:org.gradle.api.file.FileCollection[] annotationProcessorPath`::
_The processor path to use when compiling the source files of this source set._ Default value: `__sourceSet__AnnotationProcessor` configuration.

`api:org.gradle.api.file.FileCollection[] runtimeClasspath`::
_The classpath to use when executing the classes of this source set._ Default value: `output` + `__sourceSet__RuntimeClasspath` configuration.

`(read-only) api:org.gradle.api.file.SourceDirectorySet[] java`::
_The Java source files of this source set. Contains only `.java` files found in the Java source directories, and excludes all other files._ Default value: Not null

`Set&lt;File&gt; java.srcDirs`::
_The source directories containing the Java source files of this source set._ Default value: `[__projectDir__/src/__name__/java]`. Can set using anything described in <<sec:specifying_multiple_files>>.

`File java.outputDir`::
_The directory to generate compiled Java sources into._ Default value: `__buildDir__/classes/java/__sourceSetName__`. Can set using anything described in <<sec:locating_files>>.

`(read-only) api:org.gradle.api.file.SourceDirectorySet[] resources`::
_The resources of this source set. Contains only resources, and excludes any `.java` files found in the resource source directories. Other plugins, such as the Groovy plugin, exclude additional types of files from this collection._ Default value: Not null

`Set&lt;File&gt; resources.srcDirs`::
_The source directories containing the resources of this source set._ Default value: `[__projectDir__/src/__name__/resources]`. Can set using anything described in <<sec:specifying_multiple_files>>.

`(read-only) api:org.gradle.api.file.SourceDirectorySet[] allJava`::
_All `.java` files of this source set. Some plugins, such as the Groovy plugin, add additional Java source files to this collection._ Default value: `java`

`(read-only) api:org.gradle.api.file.SourceDirectorySet[] allSource`::
_All source files of this source set. This include all resource files and all Java source files. Some plugins, such as the Groovy plugin, add additional source files to this collection._ Default value: `resources + java`


[[sec:defining_new_source_sets]]
==== Defining new source sets

To define a new source set, you simply reference it in the `sourceSets { }` block. Here's an example:

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""defineSourceSet"" dir=""userguide/java/sourceSets"" title=""Defining a source set"">
                <sourcefile file=""build.gradle"" snippet=""define-source-set""/>
            </sample>
++++

When you define a new source set, the Java plugin adds some dependency configurations for the source set, as shown in <<java_source_set_configurations>>. You can use these configurations to define the compile and runtime dependencies of the source set.

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""sourceSetDependencies"" dir=""userguide/java/sourceSets"" title=""Defining source set dependencies"">
                <sourcefile file=""build.gradle"" snippet=""source-set-dependencies""/>
            </sample>
++++

The Java plugin also adds a number of tasks which assemble the classes for the source set, as shown in <<java_source_set_tasks>>. For example, for a source set called `intTest`, compiling the classes for this source set is done by running `gradle intTestClasses`.

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""compileSourceSet"" dir=""userguide/java/sourceSets"" title=""Compiling a source set"">
                <output args=""intTestClasses""/>
            </sample>
++++


[[sec:some_source_set_examples]]
==== Some source set examples

Adding a JAR containing the classes of a source set:

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""configureSourceSet"" dir=""userguide/java/sourceSets"" title=""Assembling a JAR for a source set"">
                <sourcefile file=""build.gradle"" snippet=""jar""/>
            </sample>
++++

Generating Javadoc for a source set:

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""configureSourceSet"" dir=""userguide/java/sourceSets"" title=""Generating the Javadoc for a source set"">
                <sourcefile file=""build.gradle"" snippet=""javadoc""/>
            </sample>
++++

Adding a test suite to run the tests in a source set:

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""configureSourceSet"" dir=""userguide/java/sourceSets"" title=""Running tests in a source set"">
                <sourcefile file=""build.gradle"" snippet=""test""/>
            </sample>
++++


[[sec:javadoc]]
=== Javadoc

The `javadoc` task is an instance of api:org.gradle.api.tasks.javadoc.Javadoc[]. It supports the core Javadoc options and the options of the standard doclet described in the http://docs.oracle.com/javase/7/docs/technotes/tools/windows/javadoc.html[reference documentation] of the Javadoc executable. For a complete list of supported Javadoc options consult the API documentation of the following classes: api:org.gradle.external.javadoc.CoreJavadocOptions[] and api:org.gradle.external.javadoc.StandardJavadocDocletOptions[].

==== Javadoc properties

`api:org.gradle.api.file.FileCollection[] classpath`::
Default value: `sourceSets.main.output` + `sourceSets.main.compileClasspath`

`api:org.gradle.api.file.FileTree[] source`::
Default value: `sourceSets.main.allJava`. Can set using anything described in <<sec:specifying_multiple_files>>.

`File destinationDir`::
Default value: `__docsDir__/javadoc`

`String title`::
Default value: The name and version of the project

[[sec:clean]]
=== Clean

The `clean` task is an instance of api:org.gradle.api.tasks.Delete[]. It simply removes the directory denoted by its `dir` property.

==== Clean properties

`File dir`::
Default value: `__buildDir__`


[[sec:java_resources]]
=== Resources

The Java plugin uses the api:org.gradle.api.tasks.Copy[] task for resource handling. It adds an instance for each source set in the project. You can find out more about the copy task in <<sec:copying_files>>.

==== ProcessResources properties

`Object srcDirs`::
Default value: `__sourceSet__.resources`. Can set using anything described in <<sec:specifying_multiple_files>>.

`File destinationDir`::
Default value: `__sourceSet__.output.resourcesDir`. Can set using anything described in <<sec:locating_files>>.


[[sec:compile]]
=== CompileJava

The Java plugin adds a api:org.gradle.api.tasks.compile.JavaCompile[] instance for each source set in the project. Some of the most common configuration options are shown below.

==== Compile properties

`api:org.gradle.api.file.FileCollection[] classpath`::
Default value: `__sourceSet__.compileClasspath`

`api:org.gradle.api.file.FileTree[] source`::
Default value: `__sourceSet__.java`. Can set using anything described in <<sec:specifying_multiple_files>>.

`File destinationDir`::
Default value: `__sourceSet__.java.outputDir`

By default, the Java compiler runs in the Gradle process. Setting `options.fork` to `true` causes compilation to occur in a separate process. In the case of the Ant javac task, this means that a new process will be forked for each compile task, which can slow down compilation. Conversely, Gradle's direct compiler integration (see above) will reuse the same compiler process as much as possible. In both cases, all fork options specified with `options.forkOptions` will be honored.

[[sec:incremental_compile]]
=== Incremental Java compilation

Starting with Gradle 2.1, it is possible to compile Java incrementally. See the api:org.gradle.api.tasks.compile.JavaCompile[] task for information on how to enable it.

Main goals for incremental compilations are:

* Avoid wasting time compiling source classes that don't have to be compiled. This means faster builds, especially when a change to a source class or a jar does not incur recompilation of many source classes that depend on the changed input.
* Change as few output classes as possible. Classes that don't need to be recompiled remain unchanged in the output directory. An example scenario when this is really useful is using JRebel - the fewer output classes are changed the quicker the JVM can use refreshed classes.

The incremental compilation at a high level:

* The detection of the correct set of stale classes is reliable at some expense of speed. The algorithm uses bytecode analysis and deals gracefully with compiler optimizations (inlining of non-private constants), transitive class dependencies, etc. Example: When a class with a public constant changes, we eagerly compile classes that use the same constants to avoid problems with constants inlined by the compiler.
* To make incremental compilation fast, we cache class analysis results and jar snapshots. The initial incremental compilation can be slower due to the cold caches.

[[sec:incremental_compilation_known_issues]]
==== Known issues


* If a compile task fails due to a compile error, it will do a full compilation again the next time it is invoked.
* Because of type erasure, the incremental compiler is not able to recognize when a type is only used in a type parameter, and never actually used in the code. For example, imagine that you have the following code: `List&lt;? extends A&gt; list = Lists.newArrayList();` but that no member of `A` is in practice used in the code, then changes to `A` will not trigger recompilation of the class. In practice, this should very rarely be an issue.



[[sec:java_compile_avoidance]]
=== Compile avoidance

If a dependent project has changed in an https://en.wikipedia.org/wiki/Application_binary_interface[ABI]-compatible way (only its private API has changed), then Java compilation tasks will be up-to-date. This means that if project `A` depends on project `B` and a class in `B` is changed in an ABI-compatible way (typically, changing only the body of a method), then Gradle won't recompile `A`.

Some of the types of changes that do not affect the public API and are ignored:

* Changing a method body
* Changing a comment
* Adding, removing or changing private methods, fields, or inner classes
* Adding, removing or changing a resource
* Changing the name of jars or directories in the classpath
* Renaming a parameter


Compile-avoidance is deactivated if annotation processors are found on the compile classpath, because for annotation processors the implementation details matter. Annotation processors should be declared on the annotation processor path instead. Gradle 5.0 will ignore processors on the compile classpath.
++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""annotationProcessing"" dir=""java/apt"" title=""Declaring annotation processors"">
                <sourcefile file=""build.gradle"" snippet=""annotation-processing""/>
            </sample>
++++


[[sec:java_test]]
=== Test

The `test` task is an instance of api:org.gradle.api.tasks.testing.Test[]. It automatically detects and executes all unit tests in the `test` source set. It also generates a report once test execution is complete. JUnit and TestNG are both supported. Have a look at api:org.gradle.api.tasks.testing.Test[] for the complete API.


[[sec:test_execution]]
==== Test execution

Tests are executed in a separate JVM, isolated from the main build process. The api:org.gradle.api.tasks.testing.Test[] task's API allows you some control over how this happens.

There are a number of properties which control how the test process is launched. This includes things such as system properties, JVM arguments, and the Java executable to use.

[NOTE]
====

The test process can exit unexpectedly if configured incorrectly. For instance, if the Java executable does not exist or an invalid JVM argument is provided, the test process will fail to start.
Similarly, if a test makes programmatic changes to the test process, this can also cause unexpected failures.  For example, issues may occur if a https://docs.oracle.com/javase/8/docs/api/java/lang/SecurityManager.html[SecurityManager] is modified in a test because
Gradle's internal messaging depends on reflection and socket communication, which may be disrupted if the permissions on the security manager change. (In this case, you should restore the original `SecurityManager` after the test so that the
gradle test worker process can continue to function.)

====

You can specify whether or not to execute your tests in parallel. Gradle provides parallel test execution by running multiple test processes concurrently. Each test process executes only a single test at a time, so you generally don't need to do anything special to your tests to take advantage of this. The `maxParallelForks` property specifies the maximum number of test processes to run at any given time. The default is 1, that is, do not execute the tests in parallel.

The test process sets the `org.gradle.test.worker` system property to a unique identifier for that test process, which you can use, for example, in files names or other resource identifiers.

You can specify that test processes should be restarted after it has executed a certain number of test classes. This can be a useful alternative to giving your test process a very large heap. The `forkEvery` property specifies the maximum number of test classes to execute in a test process. The default is to execute an unlimited number of tests in each test process.

The task has an `ignoreFailures` property to control the behavior when tests fail. The `Test` task always executes every test that it detects. It stops the build afterwards if `ignoreFailures` is false and there are failing tests. The default value of `ignoreFailures` is false.

The `testLogging` property allows you to configure which test events are going to be logged and at which detail level. By default, a concise message will be logged for every failed test. See api:org.gradle.api.tasks.testing.logging.TestLoggingContainer[] for how to tune test logging to your preferences.

Projects with large test suites can take a long time to execute even though a failure occurred early on leading to unnecessary wait times (especially on CI). To short circuit this behavior, the api:org.gradle.api.tasks.testing.Test#getFailFast()[`failFast`] property allows you to cause the `test` task to fail after the first test failure instead of running all tests. When this property is true, the resulting output will only show the results of tests that have completed up to and including the failure. To enable this fail fast behavior in your build file, set the `failFast` property to `true`:

    test {
        failFast = true
    }

The `--fail-fast` command line option enables the behavior from the command line. An invocation looks like:

    gradle integTest --fail-fast

The default value for the `failFast` property is false.

[[sec:debugging]]
==== Debugging

The test task provides a api:org.gradle.api.tasks.testing.Test#getDebug()[] property that can be set to launch to make the JVM wait for a debugger to attach to port 5005 before proceeding with test execution.

This can also be enabled at invocation time via the `--debug-jvm` task option (since Gradle 1.12).

[[test_filtering]]
==== Test filtering

Starting with Gradle 1.10, it is possible to include only specific tests, based on the test name pattern. Filtering is a different mechanism than test class inclusion / exclusion that will be described in the next few paragraphs (`-Dtest.single`, `test.include` and friends). The latter is based on files, e.g. the physical location of the test implementation class. File-level test selection does not support many interesting scenarios that are possible with test-level filtering. Some of them Gradle handles now and some will be satisfied in future releases:

* Filtering at the level of specific test methods; executing a single test method
* Filtering based on custom annotations (future)
* Filtering based on test hierarchy; executing all tests that extend a certain base class (future)
* Filtering based on some custom runtime rule, e.g. particular value of a system property or some static state (future)


Test filtering feature has following characteristic:

* Fully qualified class name or fully qualified method name is supported, e.g. `org.gradle.SomeTest`, `org.gradle.SomeTest.someMethod`
* Wildcard '*' is supported for matching any characters
* Command line option `--tests` is provided to conveniently extend the test filter for an individual Gradle execution. This is especially useful for the classic 'single test method execution' use case. When the command line option is used, the inclusions declared in the build script are still honored. That is, the command line filters are always applied on top of the filter definition in the build script. It is possible to supply multiple `--tests` options and tests matching any of those patterns will be included.
* Gradle tries to filter the tests given the limitations of the test framework API. Some advanced, synthetic tests may not be fully compatible with filtering. However, the vast majority of tests and use cases should be handled neatly.
* Test filtering supersedes the file-based test selection. The latter may be completely replaced in future. We will grow the test filtering API and add more kinds of filters.



++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""testfiltering"" dir=""testing/filtering"" title=""Filtering tests in the build script"">
                    <sourcefile file=""build.gradle"" snippet=""test-filtering""/>
                </sample>
++++

For more details and examples please see the api:org.gradle.api.tasks.testing.TestFilter[] reference.

Some examples of using the command line option:

* `gradle test --tests org.gradle.SomeTest.someSpecificFeature`
* `gradle test --tests \\*SomeTest.someSpecificFeature`
* `gradle test --tests \\*SomeSpecificTest`
* `gradle test --tests \\*SomeSpecificTestSuite`
* `gradle test --tests all.in.specific.package\\*`
* `gradle test --tests \\*IntegTest`
* `gradle test --tests \\\\*IntegTest\\*ui\\*`
* `gradle test --tests ""com.example.MyTestSuite""`
* `gradle test --tests ""com.example.ParameterizedTest""`
* `gradle test --tests ""\\*ParameterizedTest.foo*""`
* `gradle test --tests ""\\*ParameterizedTest.*[2]""`
* `gradle someTestTask --tests \\*UiTest someOtherTestTask --tests \\*WebTest\\*ui`

This is something you can combine with <<continuous_build, continuous build>> using `--continuous` (or `-t`, for short) to re-execute a subset of tests immediately after every change.

----
gradle test --continuous --tests ""com.mypackage.foo.*""
----

[[sec:single_test_execution_via_system_properties]]
==== Single test execution via System Properties


[NOTE]
====
This mechanism has been superseded by 'Test Filtering', described above.
====

Setting a system property of __taskName.single__ = __testNamePattern__ will only execute tests that match the specified __testNamePattern__. The __taskName__ can be a full multi-project path like `:sub1:sub2:test` or just the task name. The __testNamePattern__ will be used to form an include pattern of `\\**/testNamePattern*.class`. If no tests with this pattern can be found, an exception is thrown. This is to shield you from false security. If tests of more than one subproject are executed, the pattern is applied to each subproject. An exception is thrown if no tests can be found for a particular subproject. In such a case you can use the path notation of the pattern, so that the pattern is applied only to the test task of a specific subproject. Alternatively you can specify the fully qualified task name to be executed. You can also specify multiple patterns. Examples:

* `gradle -Dtest.single=ThisUniquelyNamedTest test`
* `gradle -Dtest.single=a/b/ test`
* `gradle -DintegTest.single=\\*IntegrationTest integTest`
* `gradle -D:proj1:test.single=Customer build`
* `gradle -D:proj1:integTest.single=c/d/`


[[sec:test_detection]]
==== Test detection

The `Test` task detects which classes are test classes by inspecting the compiled test classes. By default it scans all `.class` files. You can set custom includes / excludes, only those classes will be scanned. Depending on the test framework used (JUnit / TestNG) the test class detection uses different criteria.

When using JUnit, we scan for both JUnit 3 and 4 test classes. If any of the following criteria match, the class is considered to be a JUnit test class:

* Class or a super class extends `TestCase` or `GroovyTestCase`
* Class or a super class is annotated with `@RunWith`
* Class or a super class contain a method annotated with `@Test`


When using TestNG, we scan for methods annotated with `@Test`.

Note that abstract classes are not executed. Gradle also scans up the inheritance tree into jar files on the test classpath.

If you don't want to use test class detection, you can disable it by setting `scanForTestClasses` to false. This will make the test task only use includes / excludes to find test classes. If `scanForTestClasses` is false and no include / exclude patterns are specified, the defaults are `\\**/*Tests.class`, `*\\*/*Test.class` and `*\\*/Abstract*.class` for include and exclude, respectively.

[NOTE]
====
With http://junit.org/junit5/docs/current/user-guide[JUnit Platform], only `includes`/`excludes` is used to filter test classes, `scanForTestClasses` has no effect.
====

[[test_grouping]]
==== Test grouping

JUnit/JUnit Platform and TestNG allow sophisticated groupings of test methods.

For grouping JUnit 4 test classes and methods JUnit 4.8 introduces the concept of categories.footnote:[The JUnit wiki contains a detailed description on how to work with JUnit categories: https://github.com/junit-team/junit/wiki/Categories[].] The `test` task allows the specification of the JUnit categories you want to include and exclude.

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""junitcategories"" dir=""testing/junit/categories"" title=""JUnit Categories"">
                <sourcefile file=""build.gradle"" snippet=""test-categories""/>
            </sample>
++++

In http://junit.org/junit5/docs/current/user-guide[JUnit Platform], http://junit.org/junit5/docs/current/user-guide/#writing-tests-tagging-and-filtering[tagging] is introduced instead of categories.
You can specify the included/excluded tags as follows:

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""junitplatformtags"" dir=""testing/junitplatform/tagging"" title=""JUnit Platform Tags"">
                <sourcefile file=""build.gradle"" snippet=""test-tags""/>
            </sample>
++++

The TestNG framework has a quite similar concept. In TestNG you can specify different test groups.footnote:[The TestNG documentation contains more details about test groups: http://testng.org/doc/documentation-main.html#test-groups[].] The test groups that should be included or excluded from the test execution can be configured in the test task.

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""testnggrouping"" dir=""testing/testng/groups"" title=""Grouping TestNG tests"">
                <sourcefile file=""build.gradle"" snippet=""test-config""/>
            </sample>
++++

[[using_junit5]]
==== Using JUnit 5

http://junit.org/junit5[JUnit 5] is the latest version of the well-known JUnit test framework.
Unlike its predecessor, JUnit 5 is modularized and composed of several modules:

    JUnit 5 = JUnit Platform + JUnit Jupiter + JUnit Vintage

The JUnit Platform serves as a foundation for launching testing frameworks on the JVM. JUnit Jupiter is the combination of the new http://junit.org/junit5/docs/current/user-guide/#writing-tests[programming model]
 and http://junit.org/junit5/docs/current/user-guide/#extensions[extension model] for writing tests and extensions in JUnit 5. JUnit Vintage provides a `TestEngine` for running JUnit 3 and JUnit 4 based tests on the platform.

The following code enables JUnit Platform support in `build.gradle`:

    test {
        useJUnitPlatform()
    }

See api:org.gradle.api.tasks.testing.Test#useJUnitPlatform()[] for more details.

[[compiling_and_executing_junit_jupiter_tests]]
===== Compiling and executing JUnit Jupiter tests

To enable JUnit Jupiter support, add the following dependencies:

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""jupiterdependencies"" dir=""testing/junitplatform/jupiter"" title=""JUnit Jupiter dependencies"">
    <sourcefile file=""build.gradle"" snippet=""jupiter-dependencies""/>
</sample>
++++

Put the following code into `src/test/java`:

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""jupiterexample"" dir=""testing/junitplatform/mix"" title=""Jupiter test example"">
    <sourcefile file=""src/test/java/org/gradle/junitplatform/JupiterTest.java"" snippet=""jupiter-example""/>
</sample>
++++

Now you can run `gradle test` to see the results.

A Jupiter sample can be found at `samples/testing/junitplatform/jupiter` in the '-all' distribution of Gradle.

[[executing_legacy_tests_with_junit_vintage]]
===== Executing legacy tests with JUnit Vintage

If you want to run JUnit 3/4 tests on JUnit Platform, or even mix them with Jupiter tests, you should add extra JUnit Vintage Engine dependencies:

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""vintagedependencies"" dir=""testing/junitplatform/mix/"" title=""JUnit Vintage dependencies"">
    <sourcefile file=""build.gradle"" snippet=""vintage-dependencies""/>
</sample>
++++

In this way, you can use `gradle test` to test JUnit 3/4 tests on JUnit Platform, without the need to rewrite them.

A sample of mixed tests can be found at `samples/testing/junitplatform/mix` in the '-all' distribution of Gradle.

[[filtering_test_engine]]
===== Filtering test engine

JUnit Platform allows you to use different test engines. JUnit currently provides two `TestEngine` implementations out of the box:
https://junit.org/junit5/docs/current/api/org/junit/jupiter/engine/package-summary.html[junit-jupiter-engine] and https://junit.org/junit5/docs/current/api/org/junit/vintage/engine/package-summary.html[junit-vintage-engine].
You can also write and plug in your own `TestEngine` implementation as documented https://junit.org/junit5/docs/current/user-guide/#launcher-api-engines-custom[here].

By default, all test engines on the test runtime classpath will be used.
To control specific test engine implementations explicitly, you can do as follows:

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""filterengine"" dir=""testing/junitplatform/engine/"" title=""Filter specific engines"">
    <sourcefile file=""build.gradle"" snippet=""filter-engine""/>
</sample>
++++

A test engine filtering sample can be found at `samples/testing/junitplatform/engine` in the '-all' distribution of Gradle.

[[test_execution_order]]
==== Test execution order in TestNG

TestNG allows explicit control of the execution order of tests.

The `preserveOrder` property controls whether tests are executed in deterministic order. Preserving the order guarantees that the complete test (including `@BeforeXXX` and `@AfterXXX`) is run in a test thread before the next test is run. While preserving the order of tests is the default behavior when directly working with `testng.xml` files, the https://jitpack.io/com/github/cbeust/testng/master/javadoc/org/testng/TestNG.html[TestNG API], that is used for running tests programmatically, as well as Gradle's TestNG integration execute tests in unpredictable order by default.footnote:[The TestNG documentation contains more details about test ordering when working with `testng.xml` files: http://testng.org/doc/documentation-main.html#testng-xml[].] Preserving the order of tests was introduced with TestNG version 5.14.5. Setting the `preserveOrder` property to `true` for an older TestNG version will cause the build to fail.

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""testngpreserveorder"" dir=""testing/testng/preserveorder"" title=""Preserving order of TestNG tests"">
                <sourcefile file=""build.gradle"" snippet=""test-config""/>
            </sample>
++++

The `groupByInstance` property controls whether tests should be grouped by instances. Grouping by instances will result in resolving test method dependencies for each instance instead of running the dependees of all instances before running the dependants. The default behavior is not to group tests by instances.footnote:[The TestNG documentation contains more details about grouping tests by instances: http://testng.org/doc/documentation-main.html#dependencies-with-annotations[].] Grouping tests by instances was introduced with TestNG version 6.1. Setting the `groupByInstances` property to `true` for an older TestNG version will cause the build to fail.

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""testnggroupbyinstances"" dir=""testing/testng/groupbyinstances"" title=""Grouping TestNG tests by instances"">
                <sourcefile file=""build.gradle"" snippet=""test-config""/>
            </sample>
++++


[[test_reporting]]
==== Test reporting

The `Test` task generates the following results by default.

* An HTML test report.
* The results in an XML format that is compatible with the Ant JUnit report task. This format is supported by many other tools, such as CI servers.
* Results in an efficient binary format. The task generates the other results from these binary results.

There is also a stand-alone api:org.gradle.api.tasks.testing.TestReport[] task type which can generate the HTML test report from the binary results generated by one or more `Test` task instances. To use this task type, you need to define a `destinationDir` and the test results to include in the report. Here is a sample which generates a combined report for the unit tests from subprojects:

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""subProjectsTestReport"" dir=""testing/testReport"" title=""Creating a unit test report for subprojects"">
                <sourcefile file=""build.gradle"" snippet=""test-report""/>
            </sample>
++++

You should note that the `TestReport` type combines the results from multiple test tasks and needs to aggregate the results of individual test classes. This means that if a given test class is executed by multiple test tasks, then the test report will include executions of that class, but it can be hard to distinguish individual executions of that class and their output.


[[testNgParameterizedReporting]]
===== TestNG parameterized methods and reporting

TestNG supports http://testng.org/doc/documentation-main.html#parameters[parameterizing test methods], allowing a particular test method to be executed multiple times with different inputs. Gradle includes the parameter values in its reporting of the test method execution.

Given a parameterized test method named `aTestMethod` that takes two parameters, it will be reported with the name: `aTestMethod(toStringValueOfParam1, toStringValueOfParam2)`. This makes identifying the parameter values for a particular iteration easy.

[[sec:convention_values]]
==== Test convention values

`File testClassesDirs`::
Default value: `sourceSets.test.output.classesDirs`
`api:org.gradle.api.file.FileCollection[] classpath`::
Default value: `sourceSets.test.runtimeClasspath`
`File testResultsDir`::
Default value: `testResultsDir`
`File testReportDir`::
Default value: `testReportDir`

[[sec:jar]]
=== Jar

The `jar` task creates a JAR file containing the class files and resources of the project. The JAR file is declared as an artifact in the `archives` dependency configuration. This means that the JAR is available in the classpath of a dependent project. If you upload your project into a repository, this JAR is declared as part of the dependency descriptor. You can learn more about how to work with archives in <<sec:archives>> and artifact configurations in <<artifact_management>>.


[[sub:manifest]]
==== Manifest

Each jar or war object has a `manifest` property with a separate instance of api:org.gradle.api.java.archives.Manifest[]. When the archive is generated, a corresponding `MANIFEST.MF` file is written into the archive.

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""manifest"" dir=""userguide/tutorial/manifest"" title=""Customization of MANIFEST.MF"">
                <sourcefile file=""build.gradle"" snippet=""add-to-manifest""/>
            </sample>
++++

You can create stand-alone instances of a `Manifest`. You can use that for example, to share manifest information between jars.

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""manifest"" dir=""userguide/tutorial/manifest"" title=""Creating a manifest object."">
                <sourcefile file=""build.gradle"" snippet=""custom-manifest""/>
            </sample>
++++

You can merge other manifests into any `Manifest` object. The other manifests might be either described by a file path or, like in the example above, by a reference to another `Manifest` object.

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""manifest"" dir=""userguide/tutorial/manifest"" title=""Separate MANIFEST.MF for a particular archive"">
                <sourcefile file=""build.gradle"" snippet=""merge""/>
            </sample>
++++

Manifests are merged in the order they are declared by the `from` statement. If the base manifest and the merged manifest both define values for the same key, the merged manifest wins by default. You can fully customize the merge behavior by adding `eachEntry` actions in which you have access to a api:org.gradle.api.java.archives.ManifestMergeDetails[] instance for each entry of the resulting manifest. The merge is not immediately triggered by the from statement. It is done lazily, either when generating the jar, or by calling `writeTo` or `effectiveManifest`

You can easily write a manifest to disk.

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""manifest"" dir=""userguide/tutorial/manifest"" title=""Saving a MANIFEST.MF to disk"">
                <sourcefile file=""build.gradle"" snippet=""write""/>
            </sample>
++++


[[sec:upload]]
=== Uploading

How to upload your archives is described in <<artifact_management>>.

[[sec:java_cross_compilation]]
=== Compiling and testing Java 6/7

Gradle can only run on Java version 7 or higher. However, support for running Gradle on Java 7 has been deprecated and is scheduled to be removed in Gradle 5.0. There are two reasons for deprecating support for Java 7:

* Java 7 reached link:http://www.oracle.com/technetwork/java/javase/eol-135779.html[end of life]. Therefore, Oracle ceased public availability of security fixes and upgrades for Java 7 as of April 2015.
* Once support for Java 7 has ceased (likely with Gradle 5.0), Gradle's implementation can start to use Java 8 APIs optimized for performance and usability.

Gradle still supports compiling, testing, generating Javadoc and executing applications for Java 6 and Java 7. Java 5 is not supported.

To use Java 6 or Java 7, the following tasks need to be configured:

* `JavaCompile` task to fork and use the correct Java home
* `Javadoc` task to use the correct `javadoc` executable
* `Test` and the `JavaExec` task to use the correct `java` executable.

The following sample shows how the `build.gradle` needs to be adjusted. In order to be able to make the build machine-independent, the location of the old Java home and target version should be configured in `GRADLE_USER_HOME/gradle.properties` footnote:[For more details on `gradle.properties` see <<sec:gradle_configuration_properties>> ] in the user's home directory on each developer machine, as shown in the example.

++++
<sample xmlns:xi=""http://www.w3.org/2001/XInclude"" id=""javaCrossCompilation"" dir=""java/crossCompilation"" title=""Configure Java 6 build"">
                <sourcefile file=""gradle.properties""/>
                <sourcefile file=""build.gradle"" snippet=""java-cross-compilation""/>
            </sample>
++++

[[sec:properties_files]]
=== Java properties files

Properties files are used in many places during Java development and so Gradle makes it easy to create them as a normal part of the build. Just use the api:org.gradle.api.tasks.WriteProperties[] task.

The `WriteProperties` task also fixes a well-known problem with `Properties.store()` that can reduce the usefulness of incremental builds (see <<sec:up_to_date_checks>>). The standard Java way to write a properties file produces a unique file every time, even when the same properties and values are used, because it includes a timestamp in the comments. Gradle's `WriteProperties` task generates exactly the same output byte-for-byte if none of the properties have changed. This is achieved by a few tweaks to how a properties file is generated:

* no timestamp comment is added to the output
* the line separator is system independent, but can be configured explicitly (it defaults to `'\\n'`)
* the properties are sorted alphabetically
",12277,False,1994.9188725604542,median
"#include ""ScriptController.h""
#include ""lua_Global.h""

namespace gameplay
{

void luaRegister_lua_Global()
{
    gameplay::ScriptUtil::registerFunction(""strcmpnocase"", lua__strcmpnocase);
    gameplay::ScriptUtil::setGlobalHierarchyPair(""AnimationTarget"", ""Button"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""AnimationTarget"", ""CheckBox"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""AnimationTarget"", ""Container"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""AnimationTarget"", ""Control"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""AnimationTarget"", ""Form"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""AnimationTarget"", ""ImageControl"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""AnimationTarget"", ""Joint"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""AnimationTarget"", ""JoystickControl"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""AnimationTarget"", ""Label"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""AnimationTarget"", ""MaterialParameter"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""AnimationTarget"", ""Node"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""AnimationTarget"", ""RadioButton"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""AnimationTarget"", ""Slider"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""AnimationTarget"", ""TextBox"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""AnimationTarget"", ""Transform"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Button"", ""CheckBox"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Button"", ""RadioButton"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Camera::Listener"", ""AudioListener"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Camera::Listener"", ""TerrainPatch"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Container"", ""Form"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Control"", ""Button"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Control"", ""CheckBox"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Control"", ""Container"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Control"", ""Form"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Control"", ""ImageControl"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Control"", ""JoystickControl"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Control"", ""Label"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Control"", ""RadioButton"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Control"", ""Slider"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Control"", ""TextBox"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Label"", ""Button"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Label"", ""CheckBox"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Label"", ""RadioButton"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Label"", ""Slider"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Label"", ""TextBox"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Layout"", ""AbsoluteLayout"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Layout"", ""FlowLayout"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Layout"", ""VerticalLayout"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Node"", ""Joint"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""PhysicsCollisionObject"", ""PhysicsCharacter"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""PhysicsCollisionObject"", ""PhysicsGhostObject"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""PhysicsCollisionObject"", ""PhysicsRigidBody"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""PhysicsCollisionObject"", ""PhysicsVehicle"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""PhysicsCollisionObject"", ""PhysicsVehicleWheel"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""PhysicsConstraint"", ""PhysicsFixedConstraint"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""PhysicsConstraint"", ""PhysicsGenericConstraint"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""PhysicsConstraint"", ""PhysicsHingeConstraint"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""PhysicsConstraint"", ""PhysicsSocketConstraint"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""PhysicsConstraint"", ""PhysicsSpringConstraint"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""PhysicsGenericConstraint"", ""PhysicsFixedConstraint"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""PhysicsGenericConstraint"", ""PhysicsSpringConstraint"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""PhysicsGhostObject"", ""PhysicsCharacter"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""AIAgent"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""AIState"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""AbsoluteLayout"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Animation"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""AnimationClip"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""AudioBuffer"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""AudioSource"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Bundle"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Button"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Camera"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""CheckBox"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Container"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Control"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Curve"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""DepthStencilTarget"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Effect"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""FlowLayout"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Font"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Form"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""FrameBuffer"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""HeightField"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Image"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""ImageControl"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Joint"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""JoystickControl"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Label"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Layout"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Light"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Material"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""MaterialParameter"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Mesh"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Model"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Node"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""ParticleEmitter"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Pass"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""PhysicsCollisionShape"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""RadioButton"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""RenderState"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""RenderState::StateBlock"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""RenderTarget"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Scene"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Slider"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Technique"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Terrain"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""TextBox"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Texture"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Texture::Sampler"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Theme"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""Theme::ThemeImage"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""VertexAttributeBinding"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Ref"", ""VerticalLayout"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""RenderState"", ""Material"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""RenderState"", ""Pass"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""RenderState"", ""Technique"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""ScriptTarget"", ""AIAgent"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""ScriptTarget"", ""AIState"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""ScriptTarget"", ""Button"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""ScriptTarget"", ""CheckBox"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""ScriptTarget"", ""Container"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""ScriptTarget"", ""Control"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""ScriptTarget"", ""Form"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""ScriptTarget"", ""ImageControl"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""ScriptTarget"", ""Joint"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""ScriptTarget"", ""JoystickControl"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""ScriptTarget"", ""Label"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""ScriptTarget"", ""Node"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""ScriptTarget"", ""PhysicsController"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""ScriptTarget"", ""RadioButton"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""ScriptTarget"", ""Slider"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""ScriptTarget"", ""TextBox"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""ScriptTarget"", ""Transform"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Transform"", ""Joint"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Transform"", ""Node"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Transform::Listener"", ""AudioSource"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Transform::Listener"", ""Camera"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Transform::Listener"", ""MeshSkin"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Transform::Listener"", ""PhysicsCharacter"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Transform::Listener"", ""PhysicsGhostObject"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Transform::Listener"", ""PhysicsRigidBody"");
    gameplay::ScriptUtil::setGlobalHierarchyPair(""Transform::Listener"", ""Terrain"");
    gameplay::ScriptUtil::addStringFromEnumConversionFunction(&gameplay::lua_stringFromEnumGlobal);

    // Register enumeration AIMessage::ParameterType.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""AIMessage"");
        gameplay::ScriptUtil::registerConstantString(""UNDEFINED"", ""UNDEFINED"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""INTEGER"", ""INTEGER"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""LONG"", ""LONG"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""FLOAT"", ""FLOAT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""DOUBLE"", ""DOUBLE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BOOLEAN"", ""BOOLEAN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""STRING"", ""STRING"", scopePath);
    }

    // Register enumeration AnimationClip::Listener::EventType.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""AnimationClip"");
        scopePath.push_back(""Listener"");
        gameplay::ScriptUtil::registerConstantString(""BEGIN"", ""BEGIN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""END"", ""END"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""TIME"", ""TIME"", scopePath);
    }

    // Register enumeration AudioSource::State.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""AudioSource"");
        gameplay::ScriptUtil::registerConstantString(""INITIAL"", ""INITIAL"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""PLAYING"", ""PLAYING"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""PAUSED"", ""PAUSED"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""STOPPED"", ""STOPPED"", scopePath);
    }

    // Register enumeration Camera::Type.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Camera"");
        gameplay::ScriptUtil::registerConstantString(""PERSPECTIVE"", ""PERSPECTIVE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ORTHOGRAPHIC"", ""ORTHOGRAPHIC"", scopePath);
    }

    // Register enumeration Container::Scroll.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Container"");
        gameplay::ScriptUtil::registerConstantString(""SCROLL_NONE"", ""SCROLL_NONE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""SCROLL_HORIZONTAL"", ""SCROLL_HORIZONTAL"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""SCROLL_VERTICAL"", ""SCROLL_VERTICAL"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""SCROLL_BOTH"", ""SCROLL_BOTH"", scopePath);
    }

    // Register enumeration Control::Alignment.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Control"");
        gameplay::ScriptUtil::registerConstantString(""ALIGN_LEFT"", ""ALIGN_LEFT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_HCENTER"", ""ALIGN_HCENTER"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_RIGHT"", ""ALIGN_RIGHT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_TOP"", ""ALIGN_TOP"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_VCENTER"", ""ALIGN_VCENTER"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_BOTTOM"", ""ALIGN_BOTTOM"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_TOP_LEFT"", ""ALIGN_TOP_LEFT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_VCENTER_LEFT"", ""ALIGN_VCENTER_LEFT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_BOTTOM_LEFT"", ""ALIGN_BOTTOM_LEFT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_TOP_HCENTER"", ""ALIGN_TOP_HCENTER"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_VCENTER_HCENTER"", ""ALIGN_VCENTER_HCENTER"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_BOTTOM_HCENTER"", ""ALIGN_BOTTOM_HCENTER"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_TOP_RIGHT"", ""ALIGN_TOP_RIGHT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_VCENTER_RIGHT"", ""ALIGN_VCENTER_RIGHT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_BOTTOM_RIGHT"", ""ALIGN_BOTTOM_RIGHT"", scopePath);
    }

    // Register enumeration Control::AutoSize.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Control"");
        gameplay::ScriptUtil::registerConstantString(""AUTO_SIZE_NONE"", ""AUTO_SIZE_NONE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""AUTO_SIZE_WIDTH"", ""AUTO_SIZE_WIDTH"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""AUTO_SIZE_HEIGHT"", ""AUTO_SIZE_HEIGHT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""AUTO_SIZE_BOTH"", ""AUTO_SIZE_BOTH"", scopePath);
    }

    // Register enumeration Control::Listener::EventType.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Control"");
        scopePath.push_back(""Listener"");
        gameplay::ScriptUtil::registerConstantString(""PRESS"", ""PRESS"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""RELEASE"", ""RELEASE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""CLICK"", ""CLICK"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""VALUE_CHANGED"", ""VALUE_CHANGED"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""TEXT_CHANGED"", ""TEXT_CHANGED"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""MIDDLE_CLICK"", ""MIDDLE_CLICK"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""RIGHT_CLICK"", ""RIGHT_CLICK"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""FOCUS_GAINED"", ""FOCUS_GAINED"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""FOCUS_LOST"", ""FOCUS_LOST"", scopePath);
    }

    // Register enumeration Control::State.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Control"");
        gameplay::ScriptUtil::registerConstantString(""NORMAL"", ""NORMAL"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""FOCUS"", ""FOCUS"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ACTIVE"", ""ACTIVE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""DISABLED"", ""DISABLED"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""HOVER"", ""HOVER"", scopePath);
    }

    // Register enumeration Curve::InterpolationType.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Curve"");
        gameplay::ScriptUtil::registerConstantString(""BEZIER"", ""BEZIER"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BSPLINE"", ""BSPLINE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""FLAT"", ""FLAT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""HERMITE"", ""HERMITE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""LINEAR"", ""LINEAR"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""SMOOTH"", ""SMOOTH"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""STEP"", ""STEP"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""QUADRATIC_IN"", ""QUADRATIC_IN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""QUADRATIC_OUT"", ""QUADRATIC_OUT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""QUADRATIC_IN_OUT"", ""QUADRATIC_IN_OUT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""QUADRATIC_OUT_IN"", ""QUADRATIC_OUT_IN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""CUBIC_IN"", ""CUBIC_IN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""CUBIC_OUT"", ""CUBIC_OUT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""CUBIC_IN_OUT"", ""CUBIC_IN_OUT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""CUBIC_OUT_IN"", ""CUBIC_OUT_IN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""QUARTIC_IN"", ""QUARTIC_IN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""QUARTIC_OUT"", ""QUARTIC_OUT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""QUARTIC_IN_OUT"", ""QUARTIC_IN_OUT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""QUARTIC_OUT_IN"", ""QUARTIC_OUT_IN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""QUINTIC_IN"", ""QUINTIC_IN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""QUINTIC_OUT"", ""QUINTIC_OUT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""QUINTIC_IN_OUT"", ""QUINTIC_IN_OUT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""QUINTIC_OUT_IN"", ""QUINTIC_OUT_IN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""SINE_IN"", ""SINE_IN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""SINE_OUT"", ""SINE_OUT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""SINE_IN_OUT"", ""SINE_IN_OUT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""SINE_OUT_IN"", ""SINE_OUT_IN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""EXPONENTIAL_IN"", ""EXPONENTIAL_IN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""EXPONENTIAL_OUT"", ""EXPONENTIAL_OUT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""EXPONENTIAL_IN_OUT"", ""EXPONENTIAL_IN_OUT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""EXPONENTIAL_OUT_IN"", ""EXPONENTIAL_OUT_IN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""CIRCULAR_IN"", ""CIRCULAR_IN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""CIRCULAR_OUT"", ""CIRCULAR_OUT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""CIRCULAR_IN_OUT"", ""CIRCULAR_IN_OUT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""CIRCULAR_OUT_IN"", ""CIRCULAR_OUT_IN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ELASTIC_IN"", ""ELASTIC_IN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ELASTIC_OUT"", ""ELASTIC_OUT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ELASTIC_IN_OUT"", ""ELASTIC_IN_OUT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ELASTIC_OUT_IN"", ""ELASTIC_OUT_IN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""OVERSHOOT_IN"", ""OVERSHOOT_IN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""OVERSHOOT_OUT"", ""OVERSHOOT_OUT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""OVERSHOOT_IN_OUT"", ""OVERSHOOT_IN_OUT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""OVERSHOOT_OUT_IN"", ""OVERSHOOT_OUT_IN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BOUNCE_IN"", ""BOUNCE_IN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BOUNCE_OUT"", ""BOUNCE_OUT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BOUNCE_IN_OUT"", ""BOUNCE_IN_OUT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BOUNCE_OUT_IN"", ""BOUNCE_OUT_IN"", scopePath);
    }

    // Register enumeration DepthStencilTarget::Format.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""DepthStencilTarget"");
        gameplay::ScriptUtil::registerConstantString(""DEPTH"", ""DEPTH"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""DEPTH_STENCIL"", ""DEPTH_STENCIL"", scopePath);
    }

    // Register enumeration Font::Format.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Font"");
        gameplay::ScriptUtil::registerConstantString(""BITMAP"", ""BITMAP"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""DISTANCE_FIELD"", ""DISTANCE_FIELD"", scopePath);
    }

    // Register enumeration Font::Justify.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Font"");
        gameplay::ScriptUtil::registerConstantString(""ALIGN_LEFT"", ""ALIGN_LEFT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_HCENTER"", ""ALIGN_HCENTER"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_RIGHT"", ""ALIGN_RIGHT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_TOP"", ""ALIGN_TOP"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_VCENTER"", ""ALIGN_VCENTER"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_BOTTOM"", ""ALIGN_BOTTOM"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_TOP_LEFT"", ""ALIGN_TOP_LEFT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_VCENTER_LEFT"", ""ALIGN_VCENTER_LEFT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_BOTTOM_LEFT"", ""ALIGN_BOTTOM_LEFT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_TOP_HCENTER"", ""ALIGN_TOP_HCENTER"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_VCENTER_HCENTER"", ""ALIGN_VCENTER_HCENTER"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_BOTTOM_HCENTER"", ""ALIGN_BOTTOM_HCENTER"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_TOP_RIGHT"", ""ALIGN_TOP_RIGHT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_VCENTER_RIGHT"", ""ALIGN_VCENTER_RIGHT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALIGN_BOTTOM_RIGHT"", ""ALIGN_BOTTOM_RIGHT"", scopePath);
    }

    // Register enumeration Font::Style.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Font"");
        gameplay::ScriptUtil::registerConstantString(""PLAIN"", ""PLAIN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BOLD"", ""BOLD"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ITALIC"", ""ITALIC"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BOLD_ITALIC"", ""BOLD_ITALIC"", scopePath);
    }

    // Register enumeration Game::ClearFlags.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Game"");
        gameplay::ScriptUtil::registerConstantString(""CLEAR_COLOR"", ""CLEAR_COLOR"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""CLEAR_DEPTH"", ""CLEAR_DEPTH"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""CLEAR_STENCIL"", ""CLEAR_STENCIL"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""CLEAR_COLOR_DEPTH"", ""CLEAR_COLOR_DEPTH"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""CLEAR_COLOR_STENCIL"", ""CLEAR_COLOR_STENCIL"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""CLEAR_DEPTH_STENCIL"", ""CLEAR_DEPTH_STENCIL"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""CLEAR_COLOR_DEPTH_STENCIL"", ""CLEAR_COLOR_DEPTH_STENCIL"", scopePath);
    }

    // Register enumeration Game::State.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Game"");
        gameplay::ScriptUtil::registerConstantString(""UNINITIALIZED"", ""UNINITIALIZED"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""RUNNING"", ""RUNNING"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""PAUSED"", ""PAUSED"", scopePath);
    }

    // Register enumeration Gamepad::ButtonMapping.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Gamepad"");
        gameplay::ScriptUtil::registerConstantString(""BUTTON_A"", ""BUTTON_A"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BUTTON_B"", ""BUTTON_B"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BUTTON_C"", ""BUTTON_C"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BUTTON_X"", ""BUTTON_X"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BUTTON_Y"", ""BUTTON_Y"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BUTTON_Z"", ""BUTTON_Z"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BUTTON_MENU1"", ""BUTTON_MENU1"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BUTTON_MENU2"", ""BUTTON_MENU2"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BUTTON_MENU3"", ""BUTTON_MENU3"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BUTTON_MENU4"", ""BUTTON_MENU4"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BUTTON_L1"", ""BUTTON_L1"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BUTTON_L2"", ""BUTTON_L2"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BUTTON_L3"", ""BUTTON_L3"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BUTTON_R1"", ""BUTTON_R1"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BUTTON_R2"", ""BUTTON_R2"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BUTTON_R3"", ""BUTTON_R3"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BUTTON_UP"", ""BUTTON_UP"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BUTTON_DOWN"", ""BUTTON_DOWN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BUTTON_LEFT"", ""BUTTON_LEFT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BUTTON_RIGHT"", ""BUTTON_RIGHT"", scopePath);
    }

    // Register enumeration Gamepad::GamepadEvent.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Gamepad"");
        gameplay::ScriptUtil::registerConstantString(""CONNECTED_EVENT"", ""CONNECTED_EVENT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""DISCONNECTED_EVENT"", ""DISCONNECTED_EVENT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BUTTON_EVENT"", ""BUTTON_EVENT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""JOYSTICK_EVENT"", ""JOYSTICK_EVENT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""TRIGGER_EVENT"", ""TRIGGER_EVENT"", scopePath);
    }

    // Register enumeration Gesture::GestureEvent.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Gesture"");
        gameplay::ScriptUtil::registerConstantString(""GESTURE_TAP"", ""GESTURE_TAP"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""GESTURE_SWIPE"", ""GESTURE_SWIPE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""GESTURE_PINCH"", ""GESTURE_PINCH"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""GESTURE_LONG_TAP"", ""GESTURE_LONG_TAP"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""GESTURE_DRAG"", ""GESTURE_DRAG"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""GESTURE_DROP"", ""GESTURE_DROP"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""GESTURE_ANY_SUPPORTED"", ""GESTURE_ANY_SUPPORTED"", scopePath);
    }

    // Register enumeration Image::Format.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Image"");
        gameplay::ScriptUtil::registerConstantString(""RGB"", ""RGB"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""RGBA"", ""RGBA"", scopePath);
    }

    // Register enumeration Keyboard::Key.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Keyboard"");
        gameplay::ScriptUtil::registerConstantString(""KEY_NONE"", ""KEY_NONE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_PAUSE"", ""KEY_PAUSE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_SCROLL_LOCK"", ""KEY_SCROLL_LOCK"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_PRINT"", ""KEY_PRINT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_SYSREQ"", ""KEY_SYSREQ"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_BREAK"", ""KEY_BREAK"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_ESCAPE"", ""KEY_ESCAPE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_BACKSPACE"", ""KEY_BACKSPACE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_TAB"", ""KEY_TAB"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_BACK_TAB"", ""KEY_BACK_TAB"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_RETURN"", ""KEY_RETURN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPS_LOCK"", ""KEY_CAPS_LOCK"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_SHIFT"", ""KEY_SHIFT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CTRL"", ""KEY_CTRL"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_ALT"", ""KEY_ALT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_MENU"", ""KEY_MENU"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_HYPER"", ""KEY_HYPER"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_INSERT"", ""KEY_INSERT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_HOME"", ""KEY_HOME"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_PG_UP"", ""KEY_PG_UP"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_DELETE"", ""KEY_DELETE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_END"", ""KEY_END"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_PG_DOWN"", ""KEY_PG_DOWN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_LEFT_ARROW"", ""KEY_LEFT_ARROW"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_RIGHT_ARROW"", ""KEY_RIGHT_ARROW"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_UP_ARROW"", ""KEY_UP_ARROW"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_DOWN_ARROW"", ""KEY_DOWN_ARROW"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_NUM_LOCK"", ""KEY_NUM_LOCK"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_KP_PLUS"", ""KEY_KP_PLUS"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_KP_MINUS"", ""KEY_KP_MINUS"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_KP_MULTIPLY"", ""KEY_KP_MULTIPLY"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_KP_DIVIDE"", ""KEY_KP_DIVIDE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_KP_ENTER"", ""KEY_KP_ENTER"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_KP_HOME"", ""KEY_KP_HOME"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_KP_UP"", ""KEY_KP_UP"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_KP_PG_UP"", ""KEY_KP_PG_UP"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_KP_LEFT"", ""KEY_KP_LEFT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_KP_FIVE"", ""KEY_KP_FIVE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_KP_RIGHT"", ""KEY_KP_RIGHT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_KP_END"", ""KEY_KP_END"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_KP_DOWN"", ""KEY_KP_DOWN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_KP_PG_DOWN"", ""KEY_KP_PG_DOWN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_KP_INSERT"", ""KEY_KP_INSERT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_KP_DELETE"", ""KEY_KP_DELETE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_F1"", ""KEY_F1"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_F2"", ""KEY_F2"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_F3"", ""KEY_F3"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_F4"", ""KEY_F4"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_F5"", ""KEY_F5"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_F6"", ""KEY_F6"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_F7"", ""KEY_F7"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_F8"", ""KEY_F8"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_F9"", ""KEY_F9"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_F10"", ""KEY_F10"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_F11"", ""KEY_F11"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_F12"", ""KEY_F12"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_SPACE"", ""KEY_SPACE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_EXCLAM"", ""KEY_EXCLAM"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_QUOTE"", ""KEY_QUOTE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_NUMBER"", ""KEY_NUMBER"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_DOLLAR"", ""KEY_DOLLAR"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_PERCENT"", ""KEY_PERCENT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CIRCUMFLEX"", ""KEY_CIRCUMFLEX"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_AMPERSAND"", ""KEY_AMPERSAND"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_APOSTROPHE"", ""KEY_APOSTROPHE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_LEFT_PARENTHESIS"", ""KEY_LEFT_PARENTHESIS"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_RIGHT_PARENTHESIS"", ""KEY_RIGHT_PARENTHESIS"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_ASTERISK"", ""KEY_ASTERISK"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_PLUS"", ""KEY_PLUS"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_COMMA"", ""KEY_COMMA"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_MINUS"", ""KEY_MINUS"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_PERIOD"", ""KEY_PERIOD"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_SLASH"", ""KEY_SLASH"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_ZERO"", ""KEY_ZERO"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_ONE"", ""KEY_ONE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_TWO"", ""KEY_TWO"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_THREE"", ""KEY_THREE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_FOUR"", ""KEY_FOUR"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_FIVE"", ""KEY_FIVE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_SIX"", ""KEY_SIX"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_SEVEN"", ""KEY_SEVEN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_EIGHT"", ""KEY_EIGHT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_NINE"", ""KEY_NINE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_COLON"", ""KEY_COLON"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_SEMICOLON"", ""KEY_SEMICOLON"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_LESS_THAN"", ""KEY_LESS_THAN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_EQUAL"", ""KEY_EQUAL"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_GREATER_THAN"", ""KEY_GREATER_THAN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_QUESTION"", ""KEY_QUESTION"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_AT"", ""KEY_AT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_A"", ""KEY_CAPITAL_A"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_B"", ""KEY_CAPITAL_B"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_C"", ""KEY_CAPITAL_C"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_D"", ""KEY_CAPITAL_D"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_E"", ""KEY_CAPITAL_E"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_F"", ""KEY_CAPITAL_F"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_G"", ""KEY_CAPITAL_G"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_H"", ""KEY_CAPITAL_H"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_I"", ""KEY_CAPITAL_I"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_J"", ""KEY_CAPITAL_J"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_K"", ""KEY_CAPITAL_K"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_L"", ""KEY_CAPITAL_L"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_M"", ""KEY_CAPITAL_M"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_N"", ""KEY_CAPITAL_N"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_O"", ""KEY_CAPITAL_O"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_P"", ""KEY_CAPITAL_P"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_Q"", ""KEY_CAPITAL_Q"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_R"", ""KEY_CAPITAL_R"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_S"", ""KEY_CAPITAL_S"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_T"", ""KEY_CAPITAL_T"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_U"", ""KEY_CAPITAL_U"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_V"", ""KEY_CAPITAL_V"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_W"", ""KEY_CAPITAL_W"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_X"", ""KEY_CAPITAL_X"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_Y"", ""KEY_CAPITAL_Y"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CAPITAL_Z"", ""KEY_CAPITAL_Z"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_LEFT_BRACKET"", ""KEY_LEFT_BRACKET"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_BACK_SLASH"", ""KEY_BACK_SLASH"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_RIGHT_BRACKET"", ""KEY_RIGHT_BRACKET"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_UNDERSCORE"", ""KEY_UNDERSCORE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_GRAVE"", ""KEY_GRAVE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_A"", ""KEY_A"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_B"", ""KEY_B"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_C"", ""KEY_C"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_D"", ""KEY_D"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_E"", ""KEY_E"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_F"", ""KEY_F"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_G"", ""KEY_G"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_H"", ""KEY_H"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_I"", ""KEY_I"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_J"", ""KEY_J"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_K"", ""KEY_K"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_L"", ""KEY_L"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_M"", ""KEY_M"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_N"", ""KEY_N"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_O"", ""KEY_O"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_P"", ""KEY_P"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_Q"", ""KEY_Q"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_R"", ""KEY_R"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_S"", ""KEY_S"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_T"", ""KEY_T"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_U"", ""KEY_U"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_V"", ""KEY_V"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_W"", ""KEY_W"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_X"", ""KEY_X"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_Y"", ""KEY_Y"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_Z"", ""KEY_Z"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_LEFT_BRACE"", ""KEY_LEFT_BRACE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_BAR"", ""KEY_BAR"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_RIGHT_BRACE"", ""KEY_RIGHT_BRACE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_TILDE"", ""KEY_TILDE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_EURO"", ""KEY_EURO"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_POUND"", ""KEY_POUND"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_YEN"", ""KEY_YEN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_MIDDLE_DOT"", ""KEY_MIDDLE_DOT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_SEARCH"", ""KEY_SEARCH"", scopePath);
    }

    // Register enumeration Keyboard::KeyEvent.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Keyboard"");
        gameplay::ScriptUtil::registerConstantString(""KEY_PRESS"", ""KEY_PRESS"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_RELEASE"", ""KEY_RELEASE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""KEY_CHAR"", ""KEY_CHAR"", scopePath);
    }

    // Register enumeration Layout::Type.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Layout"");
        gameplay::ScriptUtil::registerConstantString(""LAYOUT_FLOW"", ""LAYOUT_FLOW"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""LAYOUT_VERTICAL"", ""LAYOUT_VERTICAL"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""LAYOUT_ABSOLUTE"", ""LAYOUT_ABSOLUTE"", scopePath);
    }

    // Register enumeration Light::Type.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Light"");
        gameplay::ScriptUtil::registerConstantString(""DIRECTIONAL"", ""DIRECTIONAL"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""POINT"", ""POINT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""SPOT"", ""SPOT"", scopePath);
    }

    // Register enumeration Logger::Level.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Logger"");
        gameplay::ScriptUtil::registerConstantString(""LEVEL_INFO"", ""LEVEL_INFO"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""LEVEL_WARN"", ""LEVEL_WARN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""LEVEL_ERROR"", ""LEVEL_ERROR"", scopePath);
    }

    // Register enumeration Mesh::IndexFormat.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Mesh"");
        gameplay::ScriptUtil::registerConstantString(""INDEX8"", ""INDEX8"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""INDEX16"", ""INDEX16"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""INDEX32"", ""INDEX32"", scopePath);
    }

    // Register enumeration Mesh::PrimitiveType.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Mesh"");
        gameplay::ScriptUtil::registerConstantString(""TRIANGLES"", ""TRIANGLES"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""TRIANGLE_STRIP"", ""TRIANGLE_STRIP"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""LINES"", ""LINES"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""LINE_STRIP"", ""LINE_STRIP"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""POINTS"", ""POINTS"", scopePath);
    }

    // Register enumeration Mouse::MouseEvent.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Mouse"");
        gameplay::ScriptUtil::registerConstantString(""MOUSE_PRESS_LEFT_BUTTON"", ""MOUSE_PRESS_LEFT_BUTTON"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""MOUSE_RELEASE_LEFT_BUTTON"", ""MOUSE_RELEASE_LEFT_BUTTON"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""MOUSE_PRESS_MIDDLE_BUTTON"", ""MOUSE_PRESS_MIDDLE_BUTTON"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""MOUSE_RELEASE_MIDDLE_BUTTON"", ""MOUSE_RELEASE_MIDDLE_BUTTON"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""MOUSE_PRESS_RIGHT_BUTTON"", ""MOUSE_PRESS_RIGHT_BUTTON"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""MOUSE_RELEASE_RIGHT_BUTTON"", ""MOUSE_RELEASE_RIGHT_BUTTON"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""MOUSE_MOVE"", ""MOUSE_MOVE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""MOUSE_WHEEL"", ""MOUSE_WHEEL"", scopePath);
    }

    // Register enumeration Node::Type.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Node"");
        gameplay::ScriptUtil::registerConstantString(""NODE"", ""NODE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""JOINT"", ""JOINT"", scopePath);
    }

    // Register enumeration ParticleEmitter::TextureBlending.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""ParticleEmitter"");
        gameplay::ScriptUtil::registerConstantString(""BLEND_OPAQUE"", ""BLEND_OPAQUE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BLEND_TRANSPARENT"", ""BLEND_TRANSPARENT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BLEND_ADDITIVE"", ""BLEND_ADDITIVE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BLEND_MULTIPLIED"", ""BLEND_MULTIPLIED"", scopePath);
    }

    // Register enumeration PhysicsCollisionObject::CollisionListener::EventType.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""PhysicsCollisionObject"");
        scopePath.push_back(""CollisionListener"");
        gameplay::ScriptUtil::registerConstantString(""COLLIDING"", ""COLLIDING"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""NOT_COLLIDING"", ""NOT_COLLIDING"", scopePath);
    }

    // Register enumeration PhysicsCollisionObject::Type.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""PhysicsCollisionObject"");
        gameplay::ScriptUtil::registerConstantString(""RIGID_BODY"", ""RIGID_BODY"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""CHARACTER"", ""CHARACTER"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""GHOST_OBJECT"", ""GHOST_OBJECT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""VEHICLE"", ""VEHICLE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""VEHICLE_WHEEL"", ""VEHICLE_WHEEL"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""NONE"", ""NONE"", scopePath);
    }

    // Register enumeration PhysicsCollisionShape::Type.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""PhysicsCollisionShape"");
        gameplay::ScriptUtil::registerConstantString(""SHAPE_NONE"", ""SHAPE_NONE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""SHAPE_BOX"", ""SHAPE_BOX"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""SHAPE_SPHERE"", ""SHAPE_SPHERE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""SHAPE_CAPSULE"", ""SHAPE_CAPSULE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""SHAPE_MESH"", ""SHAPE_MESH"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""SHAPE_HEIGHTFIELD"", ""SHAPE_HEIGHTFIELD"", scopePath);
    }

    // Register enumeration PhysicsController::Listener::EventType.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""PhysicsController"");
        scopePath.push_back(""Listener"");
        gameplay::ScriptUtil::registerConstantString(""ACTIVATED"", ""ACTIVATED"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""DEACTIVATED"", ""DEACTIVATED"", scopePath);
    }

    // Register enumeration Properties::Type.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Properties"");
        gameplay::ScriptUtil::registerConstantString(""NONE"", ""NONE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""STRING"", ""STRING"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""NUMBER"", ""NUMBER"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""VECTOR2"", ""VECTOR2"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""VECTOR3"", ""VECTOR3"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""VECTOR4"", ""VECTOR4"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""MATRIX"", ""MATRIX"", scopePath);
    }

    // Register enumeration RenderState::AutoBinding.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""RenderState"");
        gameplay::ScriptUtil::registerConstantString(""NONE"", ""NONE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""WORLD_MATRIX"", ""WORLD_MATRIX"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""VIEW_MATRIX"", ""VIEW_MATRIX"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""PROJECTION_MATRIX"", ""PROJECTION_MATRIX"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""WORLD_VIEW_MATRIX"", ""WORLD_VIEW_MATRIX"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""VIEW_PROJECTION_MATRIX"", ""VIEW_PROJECTION_MATRIX"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""WORLD_VIEW_PROJECTION_MATRIX"", ""WORLD_VIEW_PROJECTION_MATRIX"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""INVERSE_TRANSPOSE_WORLD_MATRIX"", ""INVERSE_TRANSPOSE_WORLD_MATRIX"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""INVERSE_TRANSPOSE_WORLD_VIEW_MATRIX"", ""INVERSE_TRANSPOSE_WORLD_VIEW_MATRIX"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""CAMERA_WORLD_POSITION"", ""CAMERA_WORLD_POSITION"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""CAMERA_VIEW_POSITION"", ""CAMERA_VIEW_POSITION"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""MATRIX_PALETTE"", ""MATRIX_PALETTE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""SCENE_AMBIENT_COLOR"", ""SCENE_AMBIENT_COLOR"", scopePath);
    }

    // Register enumeration RenderState::Blend.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""RenderState"");
        gameplay::ScriptUtil::registerConstantString(""BLEND_ZERO"", ""BLEND_ZERO"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BLEND_ONE"", ""BLEND_ONE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BLEND_SRC_COLOR"", ""BLEND_SRC_COLOR"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BLEND_ONE_MINUS_SRC_COLOR"", ""BLEND_ONE_MINUS_SRC_COLOR"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BLEND_DST_COLOR"", ""BLEND_DST_COLOR"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BLEND_ONE_MINUS_DST_COLOR"", ""BLEND_ONE_MINUS_DST_COLOR"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BLEND_SRC_ALPHA"", ""BLEND_SRC_ALPHA"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BLEND_ONE_MINUS_SRC_ALPHA"", ""BLEND_ONE_MINUS_SRC_ALPHA"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BLEND_DST_ALPHA"", ""BLEND_DST_ALPHA"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BLEND_ONE_MINUS_DST_ALPHA"", ""BLEND_ONE_MINUS_DST_ALPHA"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BLEND_CONSTANT_ALPHA"", ""BLEND_CONSTANT_ALPHA"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BLEND_ONE_MINUS_CONSTANT_ALPHA"", ""BLEND_ONE_MINUS_CONSTANT_ALPHA"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BLEND_SRC_ALPHA_SATURATE"", ""BLEND_SRC_ALPHA_SATURATE"", scopePath);
    }

    // Register enumeration RenderState::CullFaceSide.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""RenderState"");
        gameplay::ScriptUtil::registerConstantString(""CULL_FACE_SIDE_BACK"", ""CULL_FACE_SIDE_BACK"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""CULL_FACE_SIDE_FRONT"", ""CULL_FACE_SIDE_FRONT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""CULL_FACE_SIDE_FRONT_AND_BACK"", ""CULL_FACE_SIDE_FRONT_AND_BACK"", scopePath);
    }

    // Register enumeration RenderState::DepthFunction.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""RenderState"");
        gameplay::ScriptUtil::registerConstantString(""DEPTH_NEVER"", ""DEPTH_NEVER"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""DEPTH_LESS"", ""DEPTH_LESS"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""DEPTH_EQUAL"", ""DEPTH_EQUAL"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""DEPTH_LEQUAL"", ""DEPTH_LEQUAL"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""DEPTH_GREATER"", ""DEPTH_GREATER"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""DEPTH_NOTEQUAL"", ""DEPTH_NOTEQUAL"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""DEPTH_GEQUAL"", ""DEPTH_GEQUAL"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""DEPTH_ALWAYS"", ""DEPTH_ALWAYS"", scopePath);
    }

    // Register enumeration RenderState::FrontFace.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""RenderState"");
        gameplay::ScriptUtil::registerConstantString(""FRONT_FACE_CW"", ""FRONT_FACE_CW"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""FRONT_FACE_CCW"", ""FRONT_FACE_CCW"", scopePath);
    }

    // Register enumeration RenderState::StencilFunction.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""RenderState"");
        gameplay::ScriptUtil::registerConstantString(""STENCIL_NEVER"", ""STENCIL_NEVER"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""STENCIL_ALWAYS"", ""STENCIL_ALWAYS"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""STENCIL_LESS"", ""STENCIL_LESS"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""STENCIL_LEQUAL"", ""STENCIL_LEQUAL"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""STENCIL_EQUAL"", ""STENCIL_EQUAL"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""STENCIL_GREATER"", ""STENCIL_GREATER"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""STENCIL_GEQUAL"", ""STENCIL_GEQUAL"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""STENCIL_NOTEQUAL"", ""STENCIL_NOTEQUAL"", scopePath);
    }

    // Register enumeration RenderState::StencilOperation.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""RenderState"");
        gameplay::ScriptUtil::registerConstantString(""STENCIL_OP_KEEP"", ""STENCIL_OP_KEEP"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""STENCIL_OP_ZERO"", ""STENCIL_OP_ZERO"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""STENCIL_OP_REPLACE"", ""STENCIL_OP_REPLACE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""STENCIL_OP_INCR"", ""STENCIL_OP_INCR"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""STENCIL_OP_DECR"", ""STENCIL_OP_DECR"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""STENCIL_OP_INVERT"", ""STENCIL_OP_INVERT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""STENCIL_OP_INCR_WRAP"", ""STENCIL_OP_INCR_WRAP"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""STENCIL_OP_DECR_WRAP"", ""STENCIL_OP_DECR_WRAP"", scopePath);
    }

    // Register enumeration Terrain::Flags.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Terrain"");
        gameplay::ScriptUtil::registerConstantString(""DEBUG_PATCHES"", ""DEBUG_PATCHES"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""FRUSTUM_CULLING"", ""FRUSTUM_CULLING"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""LEVEL_OF_DETAIL"", ""LEVEL_OF_DETAIL"", scopePath);
    }

    // Register enumeration TextBox::InputMode.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""TextBox"");
        gameplay::ScriptUtil::registerConstantString(""TEXT"", ""TEXT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""PASSWORD"", ""PASSWORD"", scopePath);
    }

    // Register enumeration Texture::Filter.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Texture"");
        gameplay::ScriptUtil::registerConstantString(""NEAREST"", ""NEAREST"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""LINEAR"", ""LINEAR"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""NEAREST_MIPMAP_NEAREST"", ""NEAREST_MIPMAP_NEAREST"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""LINEAR_MIPMAP_NEAREST"", ""LINEAR_MIPMAP_NEAREST"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""NEAREST_MIPMAP_LINEAR"", ""NEAREST_MIPMAP_LINEAR"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""LINEAR_MIPMAP_LINEAR"", ""LINEAR_MIPMAP_LINEAR"", scopePath);
    }

    // Register enumeration Texture::Format.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Texture"");
        gameplay::ScriptUtil::registerConstantString(""UNKNOWN"", ""UNKNOWN"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""RGB"", ""RGB"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""RGBA"", ""RGBA"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""ALPHA"", ""ALPHA"", scopePath);
    }

    // Register enumeration Texture::Wrap.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Texture"");
        gameplay::ScriptUtil::registerConstantString(""REPEAT"", ""REPEAT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""CLAMP"", ""CLAMP"", scopePath);
    }

    // Register enumeration Touch::TouchEvent.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""Touch"");
        gameplay::ScriptUtil::registerConstantString(""TOUCH_PRESS"", ""TOUCH_PRESS"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""TOUCH_RELEASE"", ""TOUCH_RELEASE"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""TOUCH_MOVE"", ""TOUCH_MOVE"", scopePath);
    }

    // Register enumeration VertexFormat::Usage.
    {
        std::vector<std::string> scopePath;
        scopePath.push_back(""VertexFormat"");
        gameplay::ScriptUtil::registerConstantString(""POSITION"", ""POSITION"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""NORMAL"", ""NORMAL"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""COLOR"", ""COLOR"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""TANGENT"", ""TANGENT"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BINORMAL"", ""BINORMAL"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BLENDWEIGHTS"", ""BLENDWEIGHTS"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""BLENDINDICES"", ""BLENDINDICES"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""TEXCOORD0"", ""TEXCOORD0"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""TEXCOORD1"", ""TEXCOORD1"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""TEXCOORD2"", ""TEXCOORD2"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""TEXCOORD3"", ""TEXCOORD3"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""TEXCOORD4"", ""TEXCOORD4"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""TEXCOORD5"", ""TEXCOORD5"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""TEXCOORD6"", ""TEXCOORD6"", scopePath);
        gameplay::ScriptUtil::registerConstantString(""TEXCOORD7"", ""TEXCOORD7"", scopePath);
    }
}

int lua__strcmpnocase(lua_State* state)
{
    // Get the number of parameters.
    int paramCount = lua_gettop(state);

    // Attempt to match the parameters to a valid binding.
    switch (paramCount)
    {
        case 2:
        {
            if ((lua_type(state, 1) == LUA_TSTRING || lua_type(state, 1) == LUA_TNIL) &&
                (lua_type(state, 2) == LUA_TSTRING || lua_type(state, 2) == LUA_TNIL))
            {
                // Get parameter 1 off the stack.
                const char* param1 = gameplay::ScriptUtil::getString(1, false);

                // Get parameter 2 off the stack.
                const char* param2 = gameplay::ScriptUtil::getString(2, false);

                int result = strcmpnocase(param1, param2);

                // Push the return value onto the stack.
                lua_pushinteger(state, result);

                return 1;
            }

            lua_pushstring(state, ""lua__strcmpnocase - Failed to match the given parameters to a valid function signature."");
            lua_error(state);
            break;
        }
        default:
        {
            lua_pushstring(state, ""Invalid number of parameters (expected 2)."");
            lua_error(state);
            break;
        }
    }
    return 0;
}

static const char* enumStringEmpty = """";

const char* lua_stringFromEnumGlobal(std::string& enumname, unsigned int value)
{
    if (enumname == ""AIMessage::ParameterType"")
        return lua_stringFromEnum_AIMessageParameterType((AIMessage::ParameterType)value);
    if (enumname == ""AnimationClip::Listener::EventType"")
        return lua_stringFromEnum_AnimationClipListenerEventType((AnimationClip::Listener::EventType)value);
    if (enumname == ""AudioSource::State"")
        return lua_stringFromEnum_AudioSourceState((AudioSource::State)value);
    if (enumname == ""Camera::Type"")
        return lua_stringFromEnum_CameraType((Camera::Type)value);
    if (enumname == ""Container::Scroll"")
        return lua_stringFromEnum_ContainerScroll((Container::Scroll)value);
    if (enumname == ""Control::Alignment"")
        return lua_stringFromEnum_ControlAlignment((Control::Alignment)value);
    if (enumname == ""Control::AutoSize"")
        return lua_stringFromEnum_ControlAutoSize((Control::AutoSize)value);
    if (enumname == ""Control::Listener::EventType"")
        return lua_stringFromEnum_ControlListenerEventType((Control::Listener::EventType)value);
    if (enumname == ""Control::State"")
        return lua_stringFromEnum_ControlState((Control::State)value);
    if (enumname == ""Curve::InterpolationType"")
        return lua_stringFromEnum_CurveInterpolationType((Curve::InterpolationType)value);
    if (enumname == ""DepthStencilTarget::Format"")
        return lua_stringFromEnum_DepthStencilTargetFormat((DepthStencilTarget::Format)value);
    if (enumname == ""Font::Format"")
        return lua_stringFromEnum_FontFormat((Font::Format)value);
    if (enumname == ""Font::Justify"")
        return lua_stringFromEnum_FontJustify((Font::Justify)value);
    if (enumname == ""Font::Style"")
        return lua_stringFromEnum_FontStyle((Font::Style)value);
    if (enumname == ""Game::ClearFlags"")
        return lua_stringFromEnum_GameClearFlags((Game::ClearFlags)value);
    if (enumname == ""Game::State"")
        return lua_stringFromEnum_GameState((Game::State)value);
    if (enumname == ""Gamepad::ButtonMapping"")
        return lua_stringFromEnum_GamepadButtonMapping((Gamepad::ButtonMapping)value);
    if (enumname == ""Gamepad::GamepadEvent"")
        return lua_stringFromEnum_GamepadGamepadEvent((Gamepad::GamepadEvent)value);
    if (enumname == ""Gesture::GestureEvent"")
        return lua_stringFromEnum_GestureGestureEvent((Gesture::GestureEvent)value);
    if (enumname == ""Image::Format"")
        return lua_stringFromEnum_ImageFormat((Image::Format)value);
    if (enumname == ""Keyboard::Key"")
        return lua_stringFromEnum_KeyboardKey((Keyboard::Key)value);
    if (enumname == ""Keyboard::KeyEvent"")
        return lua_stringFromEnum_KeyboardKeyEvent((Keyboard::KeyEvent)value);
    if (enumname == ""Layout::Type"")
        return lua_stringFromEnum_LayoutType((Layout::Type)value);
    if (enumname == ""Light::Type"")
        return lua_stringFromEnum_LightType((Light::Type)value);
    if (enumname == ""Logger::Level"")
        return lua_stringFromEnum_LoggerLevel((Logger::Level)value);
    if (enumname == ""Mesh::IndexFormat"")
        return lua_stringFromEnum_MeshIndexFormat((Mesh::IndexFormat)value);
    if (enumname == ""Mesh::PrimitiveType"")
        return lua_stringFromEnum_MeshPrimitiveType((Mesh::PrimitiveType)value);
    if (enumname == ""Mouse::MouseEvent"")
        return lua_stringFromEnum_MouseMouseEvent((Mouse::MouseEvent)value);
    if (enumname == ""Node::Type"")
        return lua_stringFromEnum_NodeType((Node::Type)value);
    if (enumname == ""ParticleEmitter::TextureBlending"")
        return lua_stringFromEnum_ParticleEmitterTextureBlending((ParticleEmitter::TextureBlending)value);
    if (enumname == ""PhysicsCollisionObject::CollisionListener::EventType"")
        return lua_stringFromEnum_PhysicsCollisionObjectCollisionListenerEventType((PhysicsCollisionObject::CollisionListener::EventType)value);
    if (enumname == ""PhysicsCollisionObject::Type"")
        return lua_stringFromEnum_PhysicsCollisionObjectType((PhysicsCollisionObject::Type)value);
    if (enumname == ""PhysicsCollisionShape::Type"")
        return lua_stringFromEnum_PhysicsCollisionShapeType((PhysicsCollisionShape::Type)value);
    if (enumname == ""PhysicsController::Listener::EventType"")
        return lua_stringFromEnum_PhysicsControllerListenerEventType((PhysicsController::Listener::EventType)value);
    if (enumname == ""Properties::Type"")
        return lua_stringFromEnum_PropertiesType((Properties::Type)value);
    if (enumname == ""RenderState::AutoBinding"")
        return lua_stringFromEnum_RenderStateAutoBinding((RenderState::AutoBinding)value);
    if (enumname == ""RenderState::Blend"")
        return lua_stringFromEnum_RenderStateBlend((RenderState::Blend)value);
    if (enumname == ""RenderState::CullFaceSide"")
        return lua_stringFromEnum_RenderStateCullFaceSide((RenderState::CullFaceSide)value);
    if (enumname == ""RenderState::DepthFunction"")
        return lua_stringFromEnum_RenderStateDepthFunction((RenderState::DepthFunction)value);
    if (enumname == ""RenderState::FrontFace"")
        return lua_stringFromEnum_RenderStateFrontFace((RenderState::FrontFace)value);
    if (enumname == ""RenderState::StencilFunction"")
        return lua_stringFromEnum_RenderStateStencilFunction((RenderState::StencilFunction)value);
    if (enumname == ""RenderState::StencilOperation"")
        return lua_stringFromEnum_RenderStateStencilOperation((RenderState::StencilOperation)value);
    if (enumname == ""Terrain::Flags"")
        return lua_stringFromEnum_TerrainFlags((Terrain::Flags)value);
    if (enumname == ""TextBox::InputMode"")
        return lua_stringFromEnum_TextBoxInputMode((TextBox::InputMode)value);
    if (enumname == ""Texture::Filter"")
        return lua_stringFromEnum_TextureFilter((Texture::Filter)value);
    if (enumname == ""Texture::Format"")
        return lua_stringFromEnum_TextureFormat((Texture::Format)value);
    if (enumname == ""Texture::Wrap"")
        return lua_stringFromEnum_TextureWrap((Texture::Wrap)value);
    if (enumname == ""Touch::TouchEvent"")
        return lua_stringFromEnum_TouchTouchEvent((Touch::TouchEvent)value);
    if (enumname == ""VertexFormat::Usage"")
        return lua_stringFromEnum_VertexFormatUsage((VertexFormat::Usage)value);

    GP_ERROR(""Unrecognized enumeration type '%s'."", enumname.c_str());
    return enumStringEmpty;
}

}
",16192,True,3486.1440274412926,median
"//===----------------------------------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// NetBSD does not support LC_COLLATE at the moment
// XFAIL: netbsd

// REQUIRES: locale.cs_CZ.ISO8859-2

// <regex>

// template <class BidirectionalIterator, class Allocator, class charT, class traits>
//     bool
//     regex_search(BidirectionalIterator first, BidirectionalIterator last,
//                  match_results<BidirectionalIterator, Allocator>& m,
//                  const basic_regex<charT, traits>& e,
//                  regex_constants::match_flag_type flags = regex_constants::match_default);

// TODO: investigation needed
// XFAIL: linux-gnu

#include <regex>
#include <cassert>
#include ""test_macros.h""
#include ""test_iterators.h""

#include ""platform_support.h"" // locale name macros

int main(int, char**)
{
    {
        std::cmatch m;
        const char s[] = ""a"";
        assert(std::regex_search(s, m, std::regex(""a"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.empty());
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+1);
        assert(m.length(0) == 1);
        assert(m.position(0) == 0);
        assert(m.str(0) == ""a"");
    }
    {
        std::cmatch m;
        const char s[] = ""ab"";
        assert(std::regex_search(s, m, std::regex(""ab"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+2);
        assert(m.length(0) == 2);
        assert(m.position(0) == 0);
        assert(m.str(0) == ""ab"");
    }
    {
        std::cmatch m;
        const char s[] = ""ab"";
        assert(!std::regex_search(s, m, std::regex(""ba"", std::regex_constants::extended)));
        assert(m.size() == 0);
        assert(m.empty());
    }
    {
        std::cmatch m;
        const char s[] = ""aab"";
        assert(std::regex_search(s, m, std::regex(""ab"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+3);
        assert(m.length(0) == 2);
        assert(m.position(0) == 1);
        assert(m.str(0) == ""ab"");
    }
    {
        std::cmatch m;
        const char s[] = ""aab"";
        assert(!std::regex_search(s, m, std::regex(""ab"", std::regex_constants::extended),
                                            std::regex_constants::match_continuous));
        assert(m.size() == 0);
    }
    {
        std::cmatch m;
        const char s[] = ""abcd"";
        assert(std::regex_search(s, m, std::regex(""bc"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+4);
        assert(m.length(0) == 2);
        assert(m.position(0) == 1);
        assert(m.str(0) == ""bc"");
    }
    {
        std::cmatch m;
        const char s[] = ""abbc"";
        assert(std::regex_search(s, m, std::regex(""ab*c"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+4);
        assert(m.length(0) == 4);
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::cmatch m;
        const char s[] = ""ababc"";
        assert(std::regex_search(s, m, std::regex(""(ab)*c"", std::regex_constants::extended)));
        assert(m.size() == 2);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+5);
        assert(m.length(0) == 5);
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
        assert(m.length(1) == 2);
        assert(m.position(1) == 2);
        assert(m.str(1) == ""ab"");
    }
    {
        std::cmatch m;
        const char s[] = ""abcdefghijk"";
        assert(std::regex_search(s, m, std::regex(""cd((e)fg)hi"",
                                 std::regex_constants::extended)));
        assert(m.size() == 3);
        assert(m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+std::regex_traits<char>::length(s));
        assert(m.length(0) == 7);
        assert(m.position(0) == 2);
        assert(m.str(0) == ""cdefghi"");
        assert(m.length(1) == 3);
        assert(m.position(1) == 4);
        assert(m.str(1) == ""efg"");
        assert(m.length(2) == 1);
        assert(m.position(2) == 4);
        assert(m.str(2) == ""e"");
    }
    {
        std::cmatch m;
        const char s[] = ""abc"";
        assert(std::regex_search(s, m, std::regex(""^abc"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+3);
        assert(m.length(0) == 3);
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::cmatch m;
        const char s[] = ""abcd"";
        assert(std::regex_search(s, m, std::regex(""^abc"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+4);
        assert(m.length(0) == 3);
        assert(m.position(0) == 0);
        assert(m.str(0) == ""abc"");
    }
    {
        std::cmatch m;
        const char s[] = ""aabc"";
        assert(!std::regex_search(s, m, std::regex(""^abc"", std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::cmatch m;
        const char s[] = ""abc"";
        assert(std::regex_search(s, m, std::regex(""abc$"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+3);
        assert(m.length(0) == 3);
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::cmatch m;
        const char s[] = ""efabc"";
        assert(std::regex_search(s, m, std::regex(""abc$"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+5);
        assert(m.length(0) == 3);
        assert(m.position(0) == 2);
        assert(m.str(0) == s+2);
    }
    {
        std::cmatch m;
        const char s[] = ""efabcg"";
        assert(!std::regex_search(s, m, std::regex(""abc$"", std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::cmatch m;
        const char s[] = ""abc"";
        assert(std::regex_search(s, m, std::regex(""a.c"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+3);
        assert(m.length(0) == 3);
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::cmatch m;
        const char s[] = ""acc"";
        assert(std::regex_search(s, m, std::regex(""a.c"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+3);
        assert(m.length(0) == 3);
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::cmatch m;
        const char s[] = ""acc"";
        assert(std::regex_search(s, m, std::regex(""a.c"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+3);
        assert(m.length(0) == 3);
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::cmatch m;
        const char s[] = ""abcdef"";
        assert(std::regex_search(s, m, std::regex(""(.*).*"", std::regex_constants::extended)));
        assert(m.size() == 2);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+6);
        assert(m.length(0) == 6);
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
        assert(m.length(1) == 6);
        assert(m.position(1) == 0);
        assert(m.str(1) == s);
    }
    {
        std::cmatch m;
        const char s[] = ""bc"";
        assert(std::regex_search(s, m, std::regex(""(a*)*"", std::regex_constants::extended)));
        assert(m.size() == 2);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+2);
        assert(m.length(0) == 0);
        assert(m.position(0) == 0);
        assert(m.str(0) == """");
        assert(m.length(1) == 0);
        assert(m.position(1) == 0);
        assert(m.str(1) == """");
    }
    {
        std::cmatch m;
        const char s[] = ""abbc"";
        assert(!std::regex_search(s, m, std::regex(""ab{3,5}c"", std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::cmatch m;
        const char s[] = ""abbbc"";
        assert(std::regex_search(s, m, std::regex(""ab{3,5}c"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::cmatch m;
        const char s[] = ""abbbbc"";
        assert(std::regex_search(s, m, std::regex(""ab{3,5}c"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::cmatch m;
        const char s[] = ""abbbbbc"";
        assert(std::regex_search(s, m, std::regex(""ab{3,5}c"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::cmatch m;
        const char s[] = ""adefc"";
        assert(!std::regex_search(s, m, std::regex(""ab{3,5}c"", std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::cmatch m;
        const char s[] = ""abbbbbbc"";
        assert(!std::regex_search(s, m, std::regex(""ab{3,5}c"", std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::cmatch m;
        const char s[] = ""adec"";
        assert(!std::regex_search(s, m, std::regex(""a.{3,5}c"", std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::cmatch m;
        const char s[] = ""adefc"";
        assert(std::regex_search(s, m, std::regex(""a.{3,5}c"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::cmatch m;
        const char s[] = ""adefgc"";
        assert(std::regex_search(s, m, std::regex(""a.{3,5}c"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::cmatch m;
        const char s[] = ""adefghc"";
        assert(std::regex_search(s, m, std::regex(""a.{3,5}c"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::cmatch m;
        const char s[] = ""adefghic"";
        assert(!std::regex_search(s, m, std::regex(""a.{3,5}c"", std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::cmatch m;
        const char s[] = ""tournament"";
        assert(std::regex_search(s, m, std::regex(""tour|to|tournament"",
                                              std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::cmatch m;
        const char s[] = ""tournamenttotour"";
        assert(std::regex_search(s, m, std::regex(""(tour|to|tournament)+"",
               std::regex_constants::extended | std::regex_constants::nosubs)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::cmatch m;
        const char s[] = ""ttotour"";
        assert(std::regex_search(s, m, std::regex(""(tour|to|t)+"",
                                              std::regex_constants::extended)));
        assert(m.size() == 2);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
        assert(m.length(1) == 4);
        assert(m.position(1) == 3);
        assert(m.str(1) == ""tour"");
    }
    {
        std::cmatch m;
        const char s[] = ""-ab,ab-"";
        assert(!std::regex_search(s, m, std::regex(""-(.*),\\1-"", std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::cmatch m;
        const char s[] = ""-ab,ab-"";
        assert(std::regex_search(s, m, std::regex(""-.*,.*-"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::cmatch m;
        const char s[] = ""a"";
        assert(std::regex_search(s, m, std::regex(""^[a]$"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) == 1);
        assert(m.position(0) == 0);
        assert(m.str(0) == ""a"");
    }
    {
        std::cmatch m;
        const char s[] = ""a"";
        assert(std::regex_search(s, m, std::regex(""^[ab]$"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) == 1);
        assert(m.position(0) == 0);
        assert(m.str(0) == ""a"");
    }
    {
        std::cmatch m;
        const char s[] = ""c"";
        assert(std::regex_search(s, m, std::regex(""^[a-f]$"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) == 1);
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::cmatch m;
        const char s[] = ""g"";
        assert(!std::regex_search(s, m, std::regex(""^[a-f]$"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::cmatch m;
        const char s[] = ""Iraqi"";
        assert(std::regex_search(s, m, std::regex(""q[^u]"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) == 2);
        assert(m.position(0) == 3);
        assert(m.str(0) == ""qi"");
    }
    {
        std::cmatch m;
        const char s[] = ""Iraq"";
        assert(!std::regex_search(s, m, std::regex(""q[^u]"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::cmatch m;
        const char s[] = ""AmB"";
        assert(std::regex_search(s, m, std::regex(""A[[:lower:]]B"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::cmatch m;
        const char s[] = ""AMB"";
        assert(!std::regex_search(s, m, std::regex(""A[[:lower:]]B"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::cmatch m;
        const char s[] = ""AMB"";
        assert(std::regex_search(s, m, std::regex(""A[^[:lower:]]B"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::cmatch m;
        const char s[] = ""AmB"";
        assert(!std::regex_search(s, m, std::regex(""A[^[:lower:]]B"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::cmatch m;
        const char s[] = ""A5B"";
        assert(!std::regex_search(s, m, std::regex(""A[^[:lower:]0-9]B"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::cmatch m;
        const char s[] = ""A?B"";
        assert(std::regex_search(s, m, std::regex(""A[^[:lower:]0-9]B"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::cmatch m;
        const char s[] = ""-"";
        assert(std::regex_search(s, m, std::regex(""[a[.hyphen.]z]"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::cmatch m;
        const char s[] = ""z"";
        assert(std::regex_search(s, m, std::regex(""[a[.hyphen.]z]"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::cmatch m;
        const char s[] = ""m"";
        assert(!std::regex_search(s, m, std::regex(""[a[.hyphen.]z]"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
    {
        std::cmatch m;
        const char s[] = ""m"";
        assert(std::regex_search(s, m, std::regex(""[a[=M=]z]"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::cmatch m;
        const char s[] = ""Ch"";
        assert(std::regex_search(s, m, std::regex(""[a[.ch.]z]"",
                   std::regex_constants::extended | std::regex_constants::icase)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<char>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    std::locale::global(std::locale(""C""));
    {
        std::cmatch m;
        const char s[] = ""m"";
        assert(!std::regex_search(s, m, std::regex(""[a[=M=]z]"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::cmatch m;
        const char s[] = ""01a45cef9"";
        assert(std::regex_search(s, m, std::regex(""[ace1-9]*"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s + std::char_traits<char>::length(s));
        assert(m.length(0) == 0);
        assert(m.position(0) == 0);
        assert(m.str(0) == """");
    }
    {
        std::cmatch m;
        const char s[] = ""01a45cef9"";
        assert(std::regex_search(s, m, std::regex(""[ace1-9]+"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s + std::char_traits<char>::length(s));
        assert(m.length(0) == 6);
        assert(m.position(0) == 1);
        assert(m.str(0) == ""1a45ce"");
    }
    {
        const char r[] = ""^[-+]?[0-9]+[CF]$"";
        std::ptrdiff_t sr = std::char_traits<char>::length(r);
        typedef forward_iterator<const char*> FI;
        typedef bidirectional_iterator<const char*> BI;
        std::regex regex(FI(r), FI(r+sr), std::regex_constants::extended);
        std::match_results<BI> m;
        const char s[] = ""-40C"";
        std::ptrdiff_t ss = std::char_traits<char>::length(s);
        assert(std::regex_search(BI(s), BI(s+ss), m, regex));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == BI(s));
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) == 4);
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }

    {
        std::wcmatch m;
        const wchar_t s[] = L""a"";
        assert(std::regex_search(s, m, std::wregex(L""a"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.empty());
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+1);
        assert(m.length(0) == 1);
        assert(m.position(0) == 0);
        assert(m.str(0) == L""a"");
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""ab"";
        assert(std::regex_search(s, m, std::wregex(L""ab"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+2);
        assert(m.length(0) == 2);
        assert(m.position(0) == 0);
        assert(m.str(0) == L""ab"");
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""ab"";
        assert(!std::regex_search(s, m, std::wregex(L""ba"", std::regex_constants::extended)));
        assert(m.size() == 0);
        assert(m.empty());
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""aab"";
        assert(std::regex_search(s, m, std::wregex(L""ab"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+3);
        assert(m.length(0) == 2);
        assert(m.position(0) == 1);
        assert(m.str(0) == L""ab"");
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""aab"";
        assert(!std::regex_search(s, m, std::wregex(L""ab"", std::regex_constants::extended),
                                            std::regex_constants::match_continuous));
        assert(m.size() == 0);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""abcd"";
        assert(std::regex_search(s, m, std::wregex(L""bc"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+4);
        assert(m.length(0) == 2);
        assert(m.position(0) == 1);
        assert(m.str(0) == L""bc"");
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""abbc"";
        assert(std::regex_search(s, m, std::wregex(L""ab*c"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+4);
        assert(m.length(0) == 4);
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""ababc"";
        assert(std::regex_search(s, m, std::wregex(L""(ab)*c"", std::regex_constants::extended)));
        assert(m.size() == 2);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+5);
        assert(m.length(0) == 5);
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
        assert(m.length(1) == 2);
        assert(m.position(1) == 2);
        assert(m.str(1) == L""ab"");
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""abcdefghijk"";
        assert(std::regex_search(s, m, std::wregex(L""cd((e)fg)hi"",
                                 std::regex_constants::extended)));
        assert(m.size() == 3);
        assert(m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+std::regex_traits<wchar_t>::length(s));
        assert(m.length(0) == 7);
        assert(m.position(0) == 2);
        assert(m.str(0) == L""cdefghi"");
        assert(m.length(1) == 3);
        assert(m.position(1) == 4);
        assert(m.str(1) == L""efg"");
        assert(m.length(2) == 1);
        assert(m.position(2) == 4);
        assert(m.str(2) == L""e"");
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""abc"";
        assert(std::regex_search(s, m, std::wregex(L""^abc"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+3);
        assert(m.length(0) == 3);
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""abcd"";
        assert(std::regex_search(s, m, std::wregex(L""^abc"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+4);
        assert(m.length(0) == 3);
        assert(m.position(0) == 0);
        assert(m.str(0) == L""abc"");
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""aabc"";
        assert(!std::regex_search(s, m, std::wregex(L""^abc"", std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""abc"";
        assert(std::regex_search(s, m, std::wregex(L""abc$"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+3);
        assert(m.length(0) == 3);
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""efabc"";
        assert(std::regex_search(s, m, std::wregex(L""abc$"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+5);
        assert(m.length(0) == 3);
        assert(m.position(0) == 2);
        assert(m.str(0) == s+2);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""efabcg"";
        assert(!std::regex_search(s, m, std::wregex(L""abc$"", std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""abc"";
        assert(std::regex_search(s, m, std::wregex(L""a.c"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+3);
        assert(m.length(0) == 3);
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""acc"";
        assert(std::regex_search(s, m, std::wregex(L""a.c"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+3);
        assert(m.length(0) == 3);
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""acc"";
        assert(std::regex_search(s, m, std::wregex(L""a.c"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+3);
        assert(m.length(0) == 3);
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""abcdef"";
        assert(std::regex_search(s, m, std::wregex(L""(.*).*"", std::regex_constants::extended)));
        assert(m.size() == 2);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+6);
        assert(m.length(0) == 6);
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
        assert(m.length(1) == 6);
        assert(m.position(1) == 0);
        assert(m.str(1) == s);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""bc"";
        assert(std::regex_search(s, m, std::wregex(L""(a*)*"", std::regex_constants::extended)));
        assert(m.size() == 2);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s+2);
        assert(m.length(0) == 0);
        assert(m.position(0) == 0);
        assert(m.str(0) == L"""");
        assert(m.length(1) == 0);
        assert(m.position(1) == 0);
        assert(m.str(1) == L"""");
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""abbc"";
        assert(!std::regex_search(s, m, std::wregex(L""ab{3,5}c"", std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""abbbc"";
        assert(std::regex_search(s, m, std::wregex(L""ab{3,5}c"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""abbbbc"";
        assert(std::regex_search(s, m, std::wregex(L""ab{3,5}c"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""abbbbbc"";
        assert(std::regex_search(s, m, std::wregex(L""ab{3,5}c"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""adefc"";
        assert(!std::regex_search(s, m, std::wregex(L""ab{3,5}c"", std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""abbbbbbc"";
        assert(!std::regex_search(s, m, std::wregex(L""ab{3,5}c"", std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""adec"";
        assert(!std::regex_search(s, m, std::wregex(L""a.{3,5}c"", std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""adefc"";
        assert(std::regex_search(s, m, std::wregex(L""a.{3,5}c"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""adefgc"";
        assert(std::regex_search(s, m, std::wregex(L""a.{3,5}c"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""adefghc"";
        assert(std::regex_search(s, m, std::wregex(L""a.{3,5}c"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""adefghic"";
        assert(!std::regex_search(s, m, std::wregex(L""a.{3,5}c"", std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""tournament"";
        assert(std::regex_search(s, m, std::wregex(L""tour|to|tournament"",
                                              std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""tournamenttotour"";
        assert(std::regex_search(s, m, std::wregex(L""(tour|to|tournament)+"",
               std::regex_constants::extended | std::regex_constants::nosubs)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""ttotour"";
        assert(std::regex_search(s, m, std::wregex(L""(tour|to|t)+"",
                                              std::regex_constants::extended)));
        assert(m.size() == 2);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
        assert(m.length(1) == 4);
        assert(m.position(1) == 3);
        assert(m.str(1) == L""tour"");
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""-ab,ab-"";
        assert(!std::regex_search(s, m, std::wregex(L""-(.*),\\1-"", std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""-ab,ab-"";
        assert(std::regex_search(s, m, std::wregex(L""-.*,.*-"", std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""a"";
        assert(std::regex_search(s, m, std::wregex(L""^[a]$"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) == 1);
        assert(m.position(0) == 0);
        assert(m.str(0) == L""a"");
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""a"";
        assert(std::regex_search(s, m, std::wregex(L""^[ab]$"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) == 1);
        assert(m.position(0) == 0);
        assert(m.str(0) == L""a"");
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""c"";
        assert(std::regex_search(s, m, std::wregex(L""^[a-f]$"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) == 1);
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""g"";
        assert(!std::regex_search(s, m, std::wregex(L""^[a-f]$"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""Iraqi"";
        assert(std::regex_search(s, m, std::wregex(L""q[^u]"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) == 2);
        assert(m.position(0) == 3);
        assert(m.str(0) == L""qi"");
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""Iraq"";
        assert(!std::regex_search(s, m, std::wregex(L""q[^u]"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""AmB"";
        assert(std::regex_search(s, m, std::wregex(L""A[[:lower:]]B"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""AMB"";
        assert(!std::regex_search(s, m, std::wregex(L""A[[:lower:]]B"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""AMB"";
        assert(std::regex_search(s, m, std::wregex(L""A[^[:lower:]]B"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""AmB"";
        assert(!std::regex_search(s, m, std::wregex(L""A[^[:lower:]]B"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""A5B"";
        assert(!std::regex_search(s, m, std::wregex(L""A[^[:lower:]0-9]B"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""A?B"";
        assert(std::regex_search(s, m, std::wregex(L""A[^[:lower:]0-9]B"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""-"";
        assert(std::regex_search(s, m, std::wregex(L""[a[.hyphen.]z]"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""z"";
        assert(std::regex_search(s, m, std::wregex(L""[a[.hyphen.]z]"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""m"";
        assert(!std::regex_search(s, m, std::wregex(L""[a[.hyphen.]z]"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    std::locale::global(std::locale(LOCALE_cs_CZ_ISO8859_2));
    {
        std::wcmatch m;
        const wchar_t s[] = L""m"";
        assert(std::regex_search(s, m, std::wregex(L""[a[=M=]z]"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""Ch"";
        assert(std::regex_search(s, m, std::wregex(L""[a[.ch.]z]"",
                   std::regex_constants::extended | std::regex_constants::icase)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) >= 0 && static_cast<size_t>(m.length(0)) == std::char_traits<wchar_t>::length(s));
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }
    std::locale::global(std::locale(""C""));
    {
        std::wcmatch m;
        const wchar_t s[] = L""m"";
        assert(!std::regex_search(s, m, std::wregex(L""[a[=M=]z]"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 0);
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""01a45cef9"";
        assert(std::regex_search(s, m, std::wregex(L""[ace1-9]*"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s));
        assert(m.length(0) == 0);
        assert(m.position(0) == 0);
        assert(m.str(0) == L"""");
    }
    {
        std::wcmatch m;
        const wchar_t s[] = L""01a45cef9"";
        assert(std::regex_search(s, m, std::wregex(L""[ace1-9]+"",
                                                 std::regex_constants::extended)));
        assert(m.size() == 1);
        assert(m.prefix().matched);
        assert(m.prefix().first == s);
        assert(m.prefix().second == m[0].first);
        assert(m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == s + std::char_traits<wchar_t>::length(s));
        assert(m.length(0) == 6);
        assert(m.position(0) == 1);
        assert(m.str(0) == L""1a45ce"");
    }
    {
        const wchar_t r[] = L""^[-+]?[0-9]+[CF]$"";
        std::ptrdiff_t sr = std::char_traits<wchar_t>::length(r);
        typedef forward_iterator<const wchar_t*> FI;
        typedef bidirectional_iterator<const wchar_t*> BI;
        std::wregex regex(FI(r), FI(r+sr), std::regex_constants::extended);
        std::match_results<BI> m;
        const wchar_t s[] = L""-40C"";
        std::ptrdiff_t ss = std::char_traits<wchar_t>::length(s);
        assert(std::regex_search(BI(s), BI(s+ss), m, regex));
        assert(m.size() == 1);
        assert(!m.prefix().matched);
        assert(m.prefix().first == BI(s));
        assert(m.prefix().second == m[0].first);
        assert(!m.suffix().matched);
        assert(m.suffix().first == m[0].second);
        assert(m.suffix().second == m[0].second);
        assert(m.length(0) == 4);
        assert(m.position(0) == 0);
        assert(m.str(0) == s);
    }

  return 0;
}
",16374,True,4933.687606519526,median
"[[scoreCalculation]]
= Score Calculation
:doctype: book
:sectnums:
:toc: left
:icons: font
:experimental:
:sourcedir: .


[[scoreTerminology]]
== Score Terminology


[[whatIsAScore]]
=== What is a Score?

Every `Solution` has a score.
The score is an objective way to compare two solutions.
The solution with the higher score is better.
The `Solver` aims to find the `Solution` with the highest `Score` of all possible solutions.
The _best solution_ is the `Solution` with the highest `Score` that `Solver` has encountered during solving, which might be the __optimal
      solution__.

Planner cannot automatically know which `Solution` is best for your business, so you need to tell it how to calculate the score of a given `Solution` according to your business needs.
If you forget or are unable to implement an important business constraint, the solution is probably useless:

image::Chapter-Score_calculation/optimalWithIncompleteConstraints.png[align=""center""]


[[formalizeTheBusinessConstraints]]
=== Formalize the Business Constraints

To implement a verbal business constraint, it needs to be formalized as a score constraint.
Luckily, defining constraints in Planner is very flexible through the following score techniques:

* **Score signum (positive or negative)**: maximize or minimize a constraint type
* **Score weight**: put a cost/profit on a constraint type
* **Score level (hard, soft, ...)**: prioritize a group of constraint types
* *Pareto scoring* (rarely used)

Take the time to acquaint yourself with the first 3 techniques.
Once you understand them, formalizing most business constraints becomes straightforward.


[[scoreConstraintSignum]]
=== Score Constraint Signum (Positive or Negative)

All score techniques are based on constraints.
A constraint can be a simple pattern (such as __Maximize the apple harvest in the solution__) or a more complex pattern.
A positive constraint is a constraint you want to maximize.
A negative constraint is a constraint you want to minimize.

image::Chapter-Score_calculation/positiveAndNegativeConstraints.png[align=""center""]

The image above illustrates that **the optimal solution always has the highest
      score**, regardless if the constraints are positive or negative.

Most planning problems have only negative constraints and therefore have a negative score.
In that case, the score is the sum of the weight of the negative constraints being broken, with a perfect score of 0.
This explains why the score of a solution of four queens is the negative of the number of queen pairs which can attack each other.

Negative and positive constraints can be combined, even in the same score level.

[NOTE]
====
Do not presume that your business knows all its score constraints in advance.
Expect score constraints to be added or changed after the first releases.
====

When a constraint activates (because the negative constraint is broken or the positive constraint is fulfilled) on a certain planning entity set, it is called a __constraint match__.


[[scoreConstraintWeight]]
=== Score Constraint Weight

Not all score constraints are equally important.
If breaking one constraint is equally bad as breaking another constraint x times, then those two constraints have a different weight (but they are in the same score level). For example in vehicle routing, you can make one ""unhappy driver"" constraint match count as much as two ""fuel tank usage"" constraint matches:

image::Chapter-Score_calculation/scoreWeighting.png[align=""center""]

Score weighting is easy in use cases where you can __put a price tag on everything__.
In that case, the positive constraints maximize revenue and the negative constraints minimize expenses, so together they maximize profit.
Alternatively, score weighting is also often used to create social <<fairnessScoreConstraints,fairness>>.
For example, a nurse, who requests a free day, pays a higher weight on New Years eve than on a normal day.

The weight of a constraint match can be dynamically based on the planning entities involved.
For example in cloud balance, the weight of the soft constraint match for an active `Computer` is the `cost` of that `Computer` (which differs per computer).

Putting a good weight on a constraint can be a difficult analytical decision, because it is about making choices and tradeoffs with other constraints.
Don't spend too much time on it at the start of an implementation.
A non-accurate weight is less damaging than mediocre algorithms:

image::Chapter-Score_calculation/scoreTradeoffInPerspective.png[align=""center""]


[NOTE]
====
When deciding the weights of some constraints is debatable, it's recommended to make them configurable at runtime, as demonstrated in the exam timetabling example with the `InstitutionParametrization` class.
This allow the end-user to recalibrate constraint weights in the user interface and immediatly discover the impact of the new weights by running the solver again.
====

Most use cases use a `Score` with `int` weights, such as <<hardSoftScore,HardSoftScore>>.


[[scoreLevel]]
=== Score Constraint Level (hard, soft, ...)

Sometimes a score constraint outranks another score constraint, no matter how many times the other is broken.
In that case, those score constraints are in different levels.
For example, a nurse cannot do 2 shifts at the same time (due to the constraints of physical reality), this outranks all nurse happiness constraints.

Most use cases have only two score levels, hard and soft.
The levels of two scores are compared lexicographically.
The first score level gets compared first.
If those differ, the remaining score levels are ignored.
For example, a score that breaks `0` hard constraints and `1000000` soft constraints is better than a score that breaks `1` hard constraint and `0` soft constraints.

image::Chapter-Score_calculation/scoreLevels.png[align=""center""]

If there are two (or more) score levels, for example a hard and soft level, then a score is _feasible_ if no hard constraints are broken.

[NOTE]
====
By default, Planner will always assign all planning variables a planning value.
If there is no feasible solution, this means the best solution will be unfeasible.
To instead leave some of the planning entities unassigned, apply <<overconstrainedPlanning,overconstrained planning>>.
====

For each constraint, you need to pick a score level, a score weight and a score signum.
For example: `-1soft` which has score level of ``soft``, a weight of `1` and a negative signum.
Do not use a big constraint weight when your business actually wants different score levels.
That hack, known as __score folding__, is broken:

image::Chapter-Score_calculation/scoreFoldingIsBroken.png[align=""center""]


[NOTE]
====
Your business might tell you that your hard constraints all have the same weight, because they cannot be broken (so the weight does not matter). This is not true because if no feasible solution exists for a specific dataset, the least infeasible solution allows the business to estimate how many business resources they are lacking.
For example in cloud balancing, how many new computers to buy.

Furthermore, it will likely create a <<scoreTrap,score trap>>.
For example in cloud balance if a `Computer` has seven CPU too little for its ``Process``es, then it must be weighted seven times as much as if it had only one CPU too little.
====

Three or more score levels are supported.
For example: a company might decide that profit outranks employee satisfaction (or visa versa), while both are outranked by the constraints of physical reality.

[NOTE]
====
To model fairness or load balancing, there is <<fairnessScoreConstraints,no need to use lots of score levels>>
(even though Planner can handle many score levels).
====

Most use cases use a `Score` with two weights, such as <<hardSoftScore,HardSoftScore>>.


[[paretoScoring]]
=== Pareto Scoring (AKA Multi-objective Optimization Scoring)

Far less common is the use case of pareto optimization, which is also known under the more confusing term multi-objective optimization.
In pareto scoring, score constraints are in the same score level, yet they are not weighted against each other.
When two scores are compared, each of the score constraints are compared individually and the score with the most dominating score constraints wins.
Pareto scoring can even be combined with score levels and score constraint weighting.

Consider this example with positive constraints, where we want to get the most apples and oranges.
Since it is impossible to compare apples and oranges, we can not weight them against each other.
Yet, despite that we can not compare them, we can state that two apples are better then one apple.
Similarly, we can state that two apples and one orange are better than just one orange.
So despite our inability to compare some Scores conclusively (at which point we declare them equal), we can find a set of optimal scores.
Those are called pareto optimal.

image::Chapter-Score_calculation/paretoOptimizationScoring.png[align=""center""]

Scores are considered equal far more often.
It is left up to a human to choose the better out of a set of best solutions (with equal scores) found by Planner.
In the example above, the user must choose between solution A (three apples and one orange) and solution B (one apple and six oranges). It is guaranteed that Planner has not found another solution which has more apples or more oranges or even a better combination of both (such as two apples and three oranges).

To implement pareto scoring in Planner, <<customScore,implement a custom `ScoreDefinition` and `Score`>> (and replace the ``BestSolutionRecaller``). Future versions will provide out-of-the-box support.

[NOTE]
====
A pareto ``Score``'s `compareTo` method is not transitive because it does a pareto comparison.
For example: having two apples is greater than one apple.
One apple is equal to One orange.
Yet, two apples are not greater than one orange (but actually equal). Pareto comparison violates the contract of the interface ``java.lang.Comparable``'s `compareTo` method, but Planners systems are __pareto comparison safe__, unless explicitly stated otherwise in this documentation.
====


[[combiningScoreTechniques]]
=== Combining Score Techniques

All the score techniques mentioned above, can be combined seamlessly:

image::Chapter-Score_calculation/scoreComposition.png[align=""center""]


[[scoreInterface]]
=== `Score` interface

A score is represented by the `Score` interface, which naturally extends ``Comparable``:

[source,java,options=""nowrap""]
----
public interface Score<...> extends Comparable<...> {
    ...
}
----

The `Score` implementation to use depends on your use case.
Your score might not efficiently fit in a single `long` value.
Planner has several built-in `Score` implementations, but you can implement a custom `Score` too.
Most use cases tend to use the built-in ``HardSoftScore``.

image::Chapter-Score_calculation/scoreClassDiagram.png[align=""center""]

All Score implementations also have an `initScore` (which is an ``int``). It is mostly intended for internal use in Planner: it is the negative number of uninitialized planning variables.
From a user's perspective this is ``0``, unless a Construction Heuristic is terminated before it could initialize all planning variables (in which case `Score.isSolutionInitialized()` returns ``false``).

The `Score` implementation (for example ``HardSoftScore``) must be the same throughout a `Solver` runtime.
The `Score` implementation is configured in the solution domain class:

[source,java,options=""nowrap""]
----
@PlanningSolution
public class CloudBalance {
    ...

    @PlanningScore
    private HardSoftScore score;

}
----


[[avoidFloatingPointNumbersInScoreCalculation]]
=== Avoid Floating Point Numbers in Score Calculation

Avoid the use of `float` or `double` in score calculation.
Use `BigDecimal` or scaled `long` instead.

Floating point numbers (``float`` and ``double``) cannot represent a decimal number correctly.
For example: a `double` cannot hold the value `0.05` correctly.
Instead, it holds the nearest representable value.
Arithmetic (including addition and subtraction) with floating point numbers, especially for planning problems, leads to incorrect decisions:

image::Chapter-Score_calculation/scoreWeightType.png[align=""center""]

Additionally, floating point number addition is not associative:

[source,java,options=""nowrap""]
----
System.out.println( ((0.01 + 0.02) + 0.03) == (0.01 + (0.02 + 0.03)) ); // returns false
----

This leads to __score corruption__.

Decimal numbers (``BigDecimal``) have none of these problems.

[NOTE]
====
BigDecimal arithmetic is considerably slower than ``int``, `long` or `double` arithmetic.
In experiments we have seen the score calculation speed get divided by 5.

Therefore, in many cases, it can be worthwhile to multiply _all_ numbers for a single score weight by a plural of ten, so the score weight fits in a scaled `int` or ``long``.
For example, if we multiple all weights by ``1000``, a fuelCost of `0.07` becomes a fuelCostMillis of `70` and no longer uses a decimal score weight.
====


[[scoreType]]
== Choose a Score Type

Depending on the number of score levels and type of score weights you need, choose a `Score` type.
Most use cases use a ``HardSoftScore``.

[NOTE]
====
To properly write a `Score` to database (with JPA/Hibernate) or to XML/JSON (with XStream/JAXB/Jackson), see <<integration,the integration chapter>>.
====


[[simpleScore]]
=== SimpleScore

A `SimpleScore` has a single `int` value, for example ``-123``.
It has a single score level.

[source,java,options=""nowrap""]
----
    @PlanningScore
    private SimpleScore score;
----

Variants of this `Score` type:

* `SimpleLongScore` uses a `long` value instead of an `int` value.
* `SimpleDoubleScore` uses a `double` value instead of an `int` value. <<avoidFloatingPointNumbersInScoreCalculation,Not recommended to use.>>
* `SimpleBigDecimalScore` uses a `BigDecimal` value instead of an `int` value.


[[hardSoftScore]]
=== HardSoftScore (Recommended)

A `HardSoftScore` has a hard `int` value and a soft `int` value, for example ``-123hard/-456soft``.
It has 2 score levels (hard and soft).

[source,java,options=""nowrap""]
----
    @PlanningScore
    private HardSoftScore score;
----

Variants of this `Score` type:

* `HardSoftLongScore` uses `long` values instead of `int` values.
* `HardSoftDoubleScore` uses `double` values instead of `int` values. <<avoidFloatingPointNumbersInScoreCalculation,Not recommended to use.>>
* `HardSoftBigDecimalScore` uses `BigDecimal` values instead of `int` values.


[[hardMediumSoftScore]]
=== HardMediumSoftScore

A `HardMediumSoftScore` which has a hard `int` value, a medium `int` value and a soft `int` value, for example ``-123hard/-456medium/-789soft``.
It has 3 score levels (hard, medium and soft).

[source,java,options=""nowrap""]
----
    @PlanningScore
    private HardMediumSoftScore score;
----

Variants of this `Score` type:

* `HardMediumSoftLongScore` uses `long` values instead of `int` values.


[[bendableScore]]
=== BendableScore

A `BendableScore` has a configurable number of score levels.
It has an array of hard `int` values and an array of soft `int` value, for example with 2 hard levels and 3 soft levels, the score can be ``[-123/-456]hard/[-789/-012/-345]soft``.
In that case, it has 5 score levels.

[source,java,options=""nowrap""]
----
    @PlanningScore(bendableHardLevelsSize = 2, bendableSoftLevelsSize = 3)
    private BendableScore score;
----

The number of hard and soft score levels need to be set at compilation time.
It is not flexible to change during solving.

[NOTE]
====
Don't use a `BendableScore` with 7 levels just because you have 7 constraints.
It's extremely rare to use a different score level for each constraint, because that means one constraint match on soft 0 outweighs even a million constraint matches of soft 1.

Usually, multiple constraints share the same level and are weighted against each other.
Use <<explainingTheScore,explaining the score>> to get the weight of individual constraints in the same level.
====

Variants of this `Score` type:

* `BendableLongScore` uses `long` values instead of `int` values.
* `BendableBigDecimalScore` uses `BigDecimal` values instead of `int` values.


[[customScore]]
=== Implementing a Custom Score

Internally, each `Score` implementation also has a `ScoreDefinition` implementation.
For example: `SimpleScore` is defined by ``SimpleScoreDefinition``.
The `ScoreDefinition` interface defines the score representation.

To implement a custom ``Score``, also implement such a custom ``ScoreDefinition``.
Extend `AbstractScoreDefinition` (preferably by copy pasting ``HardSoftScoreDefinition``) and start from there.
Then hook your custom `ScoreDefinition` in the domain:

[source,java,options=""nowrap""]
----
    @PlanningScore(scoreDefinitionClass = MyCustomScoreDefinition.class)
    private MyCustomScore score;
----

To have it integrate seamlessly with <<jpaAndHibernatePersistingAScore,JPA/Hibernate>>, <<integrationWithXStream,XStream>>, ..., you 'll need to write some glue code.


[[calculateTheScore]]
== Calculate the `Score`


[[scoreCalculationTypes]]
=== Score Calculation Types

There are several ways to calculate the `Score` of a ``Solution``:

* **Easy Java score calculation**: implement a single Java method
* **Incremental Java score calculation**: implement multiple Java methods
* *Drools score calculation* (recommended): implement score rules

Every score calculation type can use any Score definition.
For example, easy Java score calculation can output a ``HardSoftScore``.

All score calculation types are Object Oriented and can reuse existing Java code.

[IMPORTANT]
====
The score calculation must be read-only.
It must not change the planning entities or the problem facts in any way.
For example, it must not call a setter method on a planning entity in a Drools score rule's RHS.
This does not apply to _logically inserted_ objects, which can be changed by the score rules that logically inserted them in the first place.

Planner will not recalculate the score of a `Solution` if it can predict it (unless an <<environmentMode,environmentMode assertion>> is enabled). For example, after a winning step is done, there is no need to calculate the score because that move was done and undone earlier.
As a result, there is no guarantee that such changes applied during score calculation are actually done.
====


[[easyJavaScoreCalculation]]
=== Easy Java Score Calculation

An easy way to implement your score calculation in Java.

* Advantages:
** Plain old Java: no learning curve
** Opportunity to delegate score calculation to an existing code base or legacy system
* Disadvantages:
** Slower and less scalable
*** Because there is no <<incrementalScoreCalculation,incremental score calculation>>

Just implement one method of the interface ``EasyScoreCalculator``:

[source,java,options=""nowrap""]
----
public interface EasyScoreCalculator<Solution_> {

    Score calculateScore(Solution_ solution);
   
}
----

For example in n queens:

[source,java,options=""nowrap""]
----
public class NQueensEasyScoreCalculator implements EasyScoreCalculator<NQueens> {

    public SimpleScore calculateScore(NQueens nQueens) {
        int n = nQueens.getN();
        List<Queen> queenList = nQueens.getQueenList();
        
        int score = 0;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                Queen leftQueen = queenList.get(i);
                Queen rightQueen = queenList.get(j);
                if (leftQueen.getRow() != null && rightQueen.getRow() != null) {
                    if (leftQueen.getRowIndex() == rightQueen.getRowIndex()) {
                        score--;
                    }
                    if (leftQueen.getAscendingDiagonalIndex() == rightQueen.getAscendingDiagonalIndex()) {
                        score--;
                    }
                    if (leftQueen.getDescendingDiagonalIndex() == rightQueen.getDescendingDiagonalIndex()) {
                        score--;
                    }
                }
            }
        }
        return SimpleScore.valueOf(score);
    }

}
----

Configure it in your solver configuration:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <easyScoreCalculatorClass>org.optaplanner.examples.nqueens.solver.score.NQueensEasyScoreCalculator</easyScoreCalculatorClass>
  </scoreDirectorFactory>
----

Alternatively, build a `EasyScoreCalculator` instance at runtime and set it with the programmatic API:

[source,java,options=""nowrap""]
----
    solverFactory.getSolverConfig().getScoreDirectorFactoryConfig.setEasyScoreCalculator(easyScoreCalculator);
----


[[incrementalJavaScoreCalculation]]
=== Incremental Java Score Calculation

A way to implement your score calculation incrementally in Java.

* Advantages:
** Very fast and scalable
*** Currently the fastest if implemented correctly
* Disadvantages:
** Hard to write
*** A scalable implementation heavily uses maps, indexes, ... (things the Drools rule engine can do for you)
*** You have to learn, design, write and improve all these performance optimizations yourself
** Hard to read
*** Regular score constraint changes can lead to a high maintenance cost

Implement all the methods of the interface `IncrementalScoreCalculator` and extend the class ``AbstractIncrementalScoreCalculator``:

[source,java,options=""nowrap""]
----
public interface IncrementalScoreCalculator<Solution_> {

    void resetWorkingSolution(Solution_ workingSolution);

    void beforeEntityAdded(Object entity);

    void afterEntityAdded(Object entity);

    void beforeVariableChanged(Object entity, String variableName);

    void afterVariableChanged(Object entity, String variableName);

    void beforeEntityRemoved(Object entity);

    void afterEntityRemoved(Object entity);

    Score calculateScore();
    
}
----

image::Chapter-Score_calculation/incrementalScoreCalculatorSequenceDiagram.png[align=""center""]

For example in n queens:

[source,java,options=""nowrap""]
----
public class NQueensAdvancedIncrementalScoreCalculator extends AbstractIncrementalScoreCalculator<NQueens> {

    private Map<Integer, List<Queen>> rowIndexMap;
    private Map<Integer, List<Queen>> ascendingDiagonalIndexMap;
    private Map<Integer, List<Queen>> descendingDiagonalIndexMap;

    private int score;

    public void resetWorkingSolution(NQueens nQueens) {
        int n = nQueens.getN();
        rowIndexMap = new HashMap<Integer, List<Queen>>(n);
        ascendingDiagonalIndexMap = new HashMap<Integer, List<Queen>>(n * 2);
        descendingDiagonalIndexMap = new HashMap<Integer, List<Queen>>(n * 2);
        for (int i = 0; i < n; i++) {
            rowIndexMap.put(i, new ArrayList<Queen>(n));
            ascendingDiagonalIndexMap.put(i, new ArrayList<Queen>(n));
            descendingDiagonalIndexMap.put(i, new ArrayList<Queen>(n));
            if (i != 0) {
                ascendingDiagonalIndexMap.put(n - 1 + i, new ArrayList<Queen>(n));
                descendingDiagonalIndexMap.put((-i), new ArrayList<Queen>(n));
            }
        }
        score = 0;
        for (Queen queen : nQueens.getQueenList()) {
            insert(queen);
        }
    }

    public void beforeEntityAdded(Object entity) {
        // Do nothing
    }

    public void afterEntityAdded(Object entity) {
        insert((Queen) entity);
    }

    public void beforeVariableChanged(Object entity, String variableName) {
        retract((Queen) entity);
    }

    public void afterVariableChanged(Object entity, String variableName) {
        insert((Queen) entity);
    }

    public void beforeEntityRemoved(Object entity) {
        retract((Queen) entity);
    }

    public void afterEntityRemoved(Object entity) {
        // Do nothing
    }

    private void insert(Queen queen) {
        Row row = queen.getRow();
        if (row != null) {
            int rowIndex = queen.getRowIndex();
            List<Queen> rowIndexList = rowIndexMap.get(rowIndex);
            score -= rowIndexList.size();
            rowIndexList.add(queen);
            List<Queen> ascendingDiagonalIndexList = ascendingDiagonalIndexMap.get(queen.getAscendingDiagonalIndex());
            score -= ascendingDiagonalIndexList.size();
            ascendingDiagonalIndexList.add(queen);
            List<Queen> descendingDiagonalIndexList = descendingDiagonalIndexMap.get(queen.getDescendingDiagonalIndex());
            score -= descendingDiagonalIndexList.size();
            descendingDiagonalIndexList.add(queen);
        }
    }

    private void retract(Queen queen) {
        Row row = queen.getRow();
        if (row != null) {
            List<Queen> rowIndexList = rowIndexMap.get(queen.getRowIndex());
            rowIndexList.remove(queen);
            score += rowIndexList.size();
            List<Queen> ascendingDiagonalIndexList = ascendingDiagonalIndexMap.get(queen.getAscendingDiagonalIndex());
            ascendingDiagonalIndexList.remove(queen);
            score += ascendingDiagonalIndexList.size();
            List<Queen> descendingDiagonalIndexList = descendingDiagonalIndexMap.get(queen.getDescendingDiagonalIndex());
            descendingDiagonalIndexList.remove(queen);
            score += descendingDiagonalIndexList.size();
        }
    }

    public SimpleScore calculateScore() {
        return SimpleScore.valueOf(score);
    }

}
----

Configure it in your solver configuration:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <incrementalScoreCalculatorClass>org.optaplanner.examples.nqueens.solver.score.NQueensAdvancedIncrementalScoreCalculator</incrementalScoreCalculatorClass>
  </scoreDirectorFactory>
----

[NOTE]
====
A piece of incremental score calculator code can be difficult to write and to review.
Assert its correctness by using <<invalidScoreDetection,an ``EasyScoreCalculator`` to do the assertions triggered by the ``environmentMode``>>.
====

Optionally, to explain a score with `ScoreDirector.getConstraintMatchTotals()` or to get better output when the `IncrementalScoreCalculator` is corrupted in `FAST_ASSERT` or ``FULL_ASSERT environmentMode``, implement also the `ConstraintMatchAwareIncrementalScoreCalculator` interface:

[source,java,options=""nowrap""]
----
public interface ConstraintMatchAwareIncrementalScoreCalculator<Solution_> {

    void resetWorkingSolution(Solution_ workingSolution, boolean constraintMatchEnabled);

    Collection<ConstraintMatchTotal> getConstraintMatchTotals();
    
}
----


[[droolsScoreCalculation]]
=== Drools Score Calculation


[[droolsScoreCalculationOverview]]
==== Overview

Implement your score calculation using the Drools rule engine.
Every score constraint is written as one or more score rules.

* Advantages:
** Incremental score calculation for free
*** Because most DRL syntax uses forward chaining, it does incremental calculation without any extra code
** Score constraints are isolated as separate rules
*** Easy to add or edit existing score rules
** Flexibility to augment your score constraints by
*** Defining them in decision tables
**** Excel (XLS) spreadsheet
**** KIE Workbench WebUI
*** Translate them into natural language with DSL
*** Store and release in the KIE Workbench repository
** Performance optimizations in future versions for free
*** In every release, the Drools rule engine tends to become faster
* Disadvantages:
** DRL learning curve
** Usage of DRL
*** Polyglot fear can prohibit the use of a new language such as DRL in some organizations


[[droolsScoreRulesConfiguration]]
==== Drools Score Rules Configuration

There are several ways to define where your score rules live.


[[droolsScoreCalculationScoreDrl]]
===== A scoreDrl Resource on the Classpath

This is the easy way.
The score rules live in a DRL file which is provided as a classpath resource.
Just add the score rules DRL file in the solver configuration as a `<scoreDrl>` element:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <scoreDrl>org/optaplanner/examples/nqueens/solver/nQueensScoreRules.drl</scoreDrl>
  </scoreDirectorFactory>
----

In a typical project (following the Maven directory structure), that DRL file would be located at `$PROJECT_DIR/src/main/resources/org/optaplanner/examples/nqueens/solver/nQueensScoreRules.drl` (even for a war project).

[NOTE]
====
The `<scoreDrl>` element expects a classpath resource, as defined by ``ClassLoader.getResource(String)``, it does not accept a ``File``, nor an URL, nor a webapp resource.
See below to use a `File` instead.
====

Add multiple `<scoreDrl>` elements if the score rules are split across multiple DRL files.

Optionally, you can also set drools configuration properties (but be careful of backwards compatibility issues):

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <scoreDrl>org/optaplanner/examples/nqueens/solver/nQueensScoreRules.drl</scoreDrl>
    <kieBaseConfigurationProperties>
      <drools.equalityBehavior>...</drools.equalityBehavior>
    </kieBaseConfigurationProperties>
  </scoreDirectorFactory>
----


[[droolsScoreCalculationScoreDrlFile]]
===== A scoreDrlFile

To use `File` on the local file system, instead of a classpath resource, add the score rules DRL file in the solver configuration as a `<scoreDrlFile>` element:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <scoreDrlFile>/home/ge0ffrey/tmp/nQueensScoreRules.drl</scoreDrlFile>
  </scoreDirectorFactory>
----

[WARNING]
====
For portability reasons, a classpath resource is recommended over a File.
An application build on one computer, but used on another computer, might not find the file on the same location.
Worse, if they use a different Operating System, it is hard to choose a portable file path.
====

Add multiple `<scoreDrlFile>` elements if the score rules are split across multiple DRL files.


[[droolsScoreCalculationKsessionName]]
===== A ksessionName in a Kjar from a Maven repository

This way allows you to use score rules defined by the Workbench or build a kjar and deploy it to the Execution Server.
Both the score rules and the solver configuration are resources in a kjar.
Clients can obtain that kjar either from the local classpath, from a local Maven repository or even from a remote Maven repository.

The score rules still live in a DRL file, but the `KieContainer` finds that DRL file through the `META-INF/kmodule.xml` file:

[source,xml,options=""nowrap""]
----
<kmodule xmlns=""http://www.drools.org/xsd/kmodule"">
  <kbase name=""nQueensKbase"" packages=""org.optaplanner.examples.nqueens.solver"">
    <ksession name=""nQueensKsession""/>
  </kbase>
</kmodule>
----

The kmodule above will pick up all the DRL files in the package ``org.optaplanner.examples.nqueens.solver``.
A kbase can even extend another kbase.

Add the ksession name in the solver configuration as a `<ksessionName>` element:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <ksessionName>nQueensKsession</ksessionName>
  </scoreDirectorFactory>
----

In this approach, it's required to use a `SolverFactory.createFromKieContainerXmlResource(...)` method to <<solverConfigurationByXML,build the `SolverFactory`>>.
If no `<ksessionName>` element is specified, the default ksession of the `kmodule.xml` is used.


[[implementingAScoreRule]]
==== Implementing a Score Rule

Here is an example of a score constraint implemented as a score rule in a DRL file:

[source,options=""nowrap""]
----
rule ""multipleQueensHorizontal""
    when
        Queen($id : id, row != null, $i : rowIndex)
        Queen(id > $id, rowIndex == $i)
    then
        scoreHolder.addConstraintMatch(kcontext, -1);
end
----

This score rule will fire once for every 2 queens with the same ``rowIndex``.
The `(id > $id)` condition is needed to assure that for 2 queens A and B, it can only fire for (A, B) and not for (B, A), (A, A) or (B, B). Let us take a closer look at this score rule on this solution of 4 queens:

image::Chapter-Score_calculation/unsolvedNQueens04.png[align=""center""]

In this solution the multipleQueensHorizontal score rule will fire for 6 queen couples: (A, B), (A, C), (A, D), (B, C), (B, D) and (C, D). Because none of the queens are on the same vertical or diagonal line, this solution will have a score of ``-6``.
An optimal solution of 4 queens has a score of ``0``.

[NOTE]
====
Notice that every score rule will relate to at least one planning entity class (directly or indirectly through a logically inserted fact).

This is a normal case.
It would be a waste of time to write a score rule that only relates to problem facts, as the consequence will never change during planning, no matter what the possible solution.
====

[NOTE]
====
The `kcontext` variable is a magic variable in Drools Expert.
The ``scoreHolder``'s method uses it to do incremental score calculation correctly and to create a `ConstraintMatch` instance.
====


[[weighingScoreRules]]
==== Weighing Score Rules

A `ScoreHolder` instance is asserted into the `KieSession` as a global called ``scoreHolder``.
The score rules need to (directly or indirectly) update that instance.

[source,options=""nowrap""]
----
global SimpleScoreHolder scoreHolder;

rule ""multipleQueensHorizontal""
    when
        Queen($id : id, row != null, $i : rowIndex)
        Queen(id > $id, rowIndex == $i)
    then
        scoreHolder.addConstraintMatch(kcontext, -1);
end

// multipleQueensVertical is obsolete because it is always 0

rule ""multipleQueensAscendingDiagonal""
    when
        Queen($id : id, row != null, $i : ascendingDiagonalIndex)
        Queen(id > $id, ascendingDiagonalIndex == $i)
    then
        scoreHolder.addConstraintMatch(kcontext, -1);
end

rule ""multipleQueensDescendingDiagonal""
    when
        Queen($id : id, row != null, $i : descendingDiagonalIndex)
        Queen(id > $id, descendingDiagonalIndex == $i)
    then
        scoreHolder.addConstraintMatch(kcontext, -1);
end
----

[NOTE]
====
To learn more about the Drools rule language (DRL), consult http://drools.org/learn/documentation.html[the Drools documentation].
====

Most use cases also weigh their constraint types or even their matches differently, by using a specific weight for each constraint match.
For example in <<curriculumCourse,course scheduling>>, assigning a `Lecture` to a `Room` that is lacking two seats is weighted equally bad as having one isolated `Lecture` in a ``Curriculum``:

[source,options=""nowrap""]
----
global HardSoftScoreHolder scoreHolder;

// RoomCapacity: For each lecture, the number of students that attend the course must be less or equal
// than the number of seats of all the rooms that host its lectures.
rule ""roomCapacity""
    when
        $room : Room($capacity : capacity)
        $lecture : Lecture(room == $room, studentSize > $capacity, $studentSize : studentSize)
    then
        // Each student above the capacity counts as 1 point of penalty.
        scoreHolder.addSoftConstraintMatch(kcontext, ($capacity - $studentSize));
end

// CurriculumCompactness: Lectures belonging to a curriculum should be adjacent
// to each other (i.e., in consecutive periods).
// For a given curriculum we account for a violation every time there is one lecture not adjacent
// to any other lecture within the same day.
rule ""curriculumCompactness""
    when
        ...
    then
        // Each isolated lecture in a curriculum counts as 2 points of penalty.
        scoreHolder.addSoftConstraintMatch(kcontext, -2);
end
----


[[initializingScoreTrend]]
=== InitializingScoreTrend

The `InitializingScoreTrend` specifies how the Score will change as more and more variables are initialized (while the already initialized variables do not change). Some optimization algorithms (such Construction Heuristics and Exhaustive Search) run faster if they have such information.

For the Score (or each <<scoreLevel,score level>> separately), specify a trend:

* `ANY` (default): Initializing an extra variable can change the score positively or negatively. Gives no performance gain.
* `ONLY_UP` (rare): Initializing an extra variable can only change the score positively. Implies that:
** There are only positive constraints
** And initializing the next variable can not unmatch a positive constraint that was matched by a previous initialized variable.
* ``ONLY_DOWN``: Initializing an extra variable can only change the score negatively. Implies that:
** There are only negative constraints
** And initializing the next variable can not unmatch a negative constraint that was matched by a previous initialized variable.

Most use cases only have negative constraints.
Many of those have an `InitializingScoreTrend` that only goes down:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <scoreDrl>.../cloudBalancingScoreRules.drl</scoreDrl>
    <initializingScoreTrend>ONLY_DOWN</initializingScoreTrend>
  </scoreDirectorFactory>
----

Alternatively, you can also specify the trend for each score level separately:

[source,xml,options=""nowrap""]
----
  <scoreDirectorFactory>
    <scoreDrl>.../cloudBalancingScoreRules.drl</scoreDrl>
    <initializingScoreTrend>ONLY_DOWN/ONLY_DOWN</initializingScoreTrend>
  </scoreDirectorFactory>
----


[[invalidScoreDetection]]
=== Invalid Score Detection

When you put <<environmentMode,the `environmentMode`>>in `FULL_ASSERT` (or ``FAST_ASSERT``),
it will detect score corruption in the <<incrementalScoreCalculation,incremental score calculation>>.
However, that will not verify that your score calculator actually implements your score constraints as your business desires.
For example, one score rule might consistently match the wrong pattern.
To verify the score rules against an independent implementation, configure a ``assertionScoreDirectorFactory``:

[source,xml,options=""nowrap""]
----
  <environmentMode>FAST_ASSERT</environmentMode>
  ...
  <scoreDirectorFactory>
    <scoreDrl>org/optaplanner/examples/nqueens/solver/nQueensScoreRules.drl</scoreDrl>
    <assertionScoreDirectorFactory>
      <easyScoreCalculatorClass>org.optaplanner.examples.nqueens.solver.score.NQueensEasyScoreCalculator</easyScoreCalculatorClass>
    </assertionScoreDirectorFactory>
  </scoreDirectorFactory>
----

This way, the `scoreDrl` will be validated by the ``EasyScoreCalculator``.

[NOTE]
====
This works well to isolate score corruption,
but to verify that the score rules implement the real business needs,
<<testingScoreConstraints, a unit test with a ScoreVerifier>> is usually better.
====


[[scoreCalculationPerformanceTricks]]
== Score Calculation Performance Tricks


[[scoreCalculationPerformanceTricksOverview]]
=== Overview

The `Solver` will normally spend most of its execution time running the score calculation (which is called in its deepest loops). Faster score calculation will return the same solution in less time with the same algorithm, which normally means a better solution in equal time.


[[scoreCalculationSpeed]]
=== Score Calculation Speed

After solving a problem, the `Solver` will log the __score calculation speed per
      second__.
This is a good measurement of Score calculation performance, despite that it is affected by non score calculation execution time.
It depends on the problem scale of the problem dataset.
Normally, even for high scale problems, it is higher than ``1000``, except when you are using an ``EasyScoreCalculator``.

[IMPORTANT]
====
When improving your score calculation, focus on maximizing the score calculation speed, instead of maximizing the best score.
A big improvement in score calculation can sometimes yield little or no best score improvement, for example when the algorithm is stuck in a local or global optima.
If you are watching the calculation speed instead, score calculation improvements are far more visible.

Furthermore, watching the calculation speed, allows you to remove or add score constraints, and still compare it with the original calculation speed.
Comparing the best score with the original would be wrong, because it is comparing apples and oranges.
====


[[incrementalScoreCalculation]]
=== Incremental Score Calculation (with Deltas)

When a `Solution` changes, incremental score calculation (AKA delta based score calculation), will calculate the delta with the previous state to find the new ``Score``, instead of recalculating the entire score on every solution evaluation.

For example, if a single queen A moves from row `1` to ``2``, it will not bother to check if queen B and C can attack each other, since neither of them changed.

.Incremental Score Calculation for the 4 Queens Puzzle
image::Chapter-Score_calculation/incrementalScoreCalculationNQueens04.png[align=""center""]

This is a huge performance and scalability gain. *Drools score calculation gives you
      this huge scalability gain without forcing you to write a complicated incremental score calculation
      algorithm.* Just let the Drools rule engine do the hard work.

Notice that the speedup is relative to the size of your planning problem (your __n__), making incremental score calculation far more scalable.


[[avoidCallingRemoteServicesDuringScoreCalculation]]
=== Avoid Calling Remote Services During Score Calculation

Do not call remote services in your score calculation (except if you are bridging `EasyScoreCalculator` to a legacy system). The network latency will kill your score calculation performance.
Cache the results of those remote services if possible.

If some parts of a constraint can be calculated once, when the `Solver` starts, and never change during solving, then turn them into <<cachedProblemFact,cached problem facts>>.


[[pointlessConstraints]]
=== Pointless Constraints

If you know a certain constraint can never be broken (or it is always broken), you need not write a score constraint for it.
For example in n queens, the score calculation does not check if multiple queens occupy the same column, because a ``Queen``'s `column` never changes and every `Solution` starts with each `Queen` on a different ``column``.

[NOTE]
====
Do not go overboard with this.
If some datasets do not use a specific constraint but others do, just return out of the constraint as soon as you can.
There is no need to dynamically change your score calculation based on the dataset.
====


[[buildInHardConstraint]]
=== Built-in Hard Constraint

Instead of implementing a hard constraint, it can sometimes be built in.
For example, If `Lecture` A should never be assigned to `Room` X, but it uses `ValueRangeProvider` on Solution, so the `Solver` will often try to assign it to `Room` X too (only to find out that it breaks a hard constraint). Use <<valueRangeProviderOnPlanningEntity,a ValueRangeProvider on the planning entity>> or <<filteredSelection,filtered selection>> to define that Course A should only be assigned a `Room` different than X.

This can give a good performance gain in some use cases, not just because the score calculation is faster, but mainly because most optimization algorithms will spend less time evaluating unfeasible solutions.
However, usually this not a good idea because there is a real risk of trading short term benefits for long term harm:

* Many optimization algorithms rely on the freedom to break hard constraints when changing planning entities, to get out of local optima.
* Both implementation approaches have limitations (feature compatibility, disabling automatic performance optimizations), as explained in their documentation.


[[otherScoreCalculationPerformanceTricks]]
=== Other Score Calculation Performance Tricks

* Verify that your score calculation happens in the correct `Number` type. If you are making the sum of `int` values, do not let Drools sum it in a `double` which takes longer.
* For optimal performance, always use server mode (``java -server``). We have seen performance increases of 50% by turning on server mode.
* For optimal performance, use the latest Java version. For example, in the past we have seen performance increases of 30% by switching from java 1.5 to 1.6.
* Always remember that premature optimization is the root of all evil. Make sure your design is flexible enough to allow configuration based tweaking.


[[scoreTrap]]
=== Score Trap

Make sure that none of your score constraints cause a score trap.
A trapped score constraint uses the same weight for different constraint matches, when it could just as easily use a different weight.
It effectively lumps its constraint matches together, which creates a flatlined score function for that constraint.
This can cause a solution state in which several moves need to be done to resolve or lower the weight of that single constraint.
Some examples of score traps:

* You need two doctors at each table, but you are only moving one doctor at a time. So the solver has no incentive to move a doctor to a table with no doctors. Punish a table with no doctors more then a table with only one doctor in that score constraint in the score function.
* Two exams need to be conducted at the same time, but you are only moving one exam at a time. So the solver has to move one of those exams to another timeslot without moving the other in the same move. Add a coarse-grained move that moves both exams at the same time.

For example, consider this score trap.
If the blue item moves from an overloaded computer to an empty computer, the hard score should improve.
The trapped score implementation fails to do that:

image::Chapter-Score_calculation/scoreTrap.png[align=""center""]

The Solver should eventually get out of this trap, but it will take a lot of effort (especially if there are even more processes on the overloaded computer). Before they do that, they might actually start moving more processes into that overloaded computer, as there is no penalty for doing so.

[NOTE]
====
Avoiding score traps does not mean that your score function should be smart enough to avoid local optima.
Leave it to the optimization algorithms to deal with the local optima.

Avoiding score traps means to avoid, for each score constraint individually, a flatlined score function.
====

[IMPORTANT]
====
Always specify the degree of infeasibility.
The business will often say ""if the solution is infeasible, it does not matter how infeasible it is."" While that is true for the business, it is not true for score calculation as it benefits from knowing how infeasible it is.
In practice, soft constraints usually do this naturally and it is just a matter of doing it for the hard constraints too.
====

There are several ways to deal with a score trap:

* Improve the score constraint to make a distinction in the score weight. For example, penalize `-1hard` for every missing CPU, instead of just `-1hard` if any CPU is missing.
* If changing the score constraint is not allowed from the business perspective, add a lower score level with a score constraint that makes such a distinction. For example, penalize `-1subsoft` for every missing CPU, on top of `-1hard` if any CPU is missing. The business ignores the subsoft score level.
* Add coarse-grained moves and union select them with the existing fine-grained moves. A coarse-grained move effectively does multiple moves to directly get out of a score trap with a single move. For example, move multiple items from the same container to another container.


[[stepLimitBenchmark]]
=== stepLimit Benchmark

Not all score constraints have the same performance cost.
Sometimes one score constraint can kill the score calculation performance outright.
Use the <<benchmarker,Benchmarker>> to do a one minute run and check what happens to the score calculation speed if you comment out all but one of the score constraints.


[[fairnessScoreConstraints]]
=== Fairness Score Constraints

Some use cases have a business requirement to provide a fair schedule (usually as a soft score constraint), for example:

* Fairly distribute the workload amongst the employees, to avoid envy.
* Evenly distribute the workload amongst assets, to improve reliability.

Implementing such a constraint can seem difficult (especially because there are different ways to formalize fairness), but usually the _squared workload_ implementation behaves most desirable.
For each employee/asset, count the workload `w` and subtract `w²` from the score.

image::Chapter-Score_calculation/fairnessScoreConstraint.png[align=""center""]

As shown above, the _squared workload_ implementation guarantees that if you select two employees from a given solution and make their distribution between those two employees fairer, then the resulting new solution will have a better overall score.
Don not just use the difference from the average workload, as that can lead to unfairness, as demonstrated below.

image::Chapter-Score_calculation/fairnessScoreConstraintPitfall.png[align=""center""]


[NOTE]
====
Instead of the __squared workload__, it is also possible to use the http://en.wikipedia.org/wiki/Variance[variance] (squared difference to the average) or the http://en.wikipedia.org/wiki/Standard_deviation[standard deviation] (square root of the variance). This has no effect on the score comparison, because the average will not change during planning.
It is just more work to implement (because the average needs to be known) and trivially slower (because the calculation is a bit longer).
====

When the workload is perfect balanced, the user often likes to see a `0` score, instead of the distracting `-34soft` in the image above (for the last solution which is almost perfectly balanced). To nullify this, either add the average multiplied by the number of entities to the score or instead show the variance or standard deviation in the UI.


[[explainingTheScore]]
== Explaining the Score: Using Score Calculation Outside the `Solver`

If other parts of your application, for example your webUI, need to calculate the score of a solution
or they need to point out what's causing constraints to be broken/fulfilled,
reuse the `ScoreDirectorFactory` of the `Solver` to build a separate `ScoreDirector` for that webUI:

[source,java,options=""nowrap""]
----
ScoreDirectorFactory<CloudBalance> scoreDirectorFactory = solver.getScoreDirectorFactory();
ScoreDirector<CloudBalance> guiScoreDirector = scoreDirectorFactory.buildScoreDirector();
...
guiScoreDirector.dispose();
----

Then use it when you need to calculate the `Score` of a ``Solution``:

[source,java,options=""nowrap""]
----
guiScoreDirector.setWorkingSolution(cloudBalance);
Score score = guiScoreDirector.calculateScore();

----

[IMPORTANT]
====
Don't forget to call `ScoreDirector.dispose()` when the `ScoreDirector` becomes useless,
especially with <<droolsScoreCalculation,Drools score calculation>>, to avoid a memory leak.
====

To explain in the GUI which planning entities and problem facts are causing which part of the ``Score``,
get the `ConstraintMatch` objects from the ``ScoreDirector``:

[source,java,options=""nowrap""]
----
for (ConstraintMatchTotal constraintMatchTotal : guiScoreDirector.getConstraintMatchTotals()) {
    String constraintName = constraintMatchTotal.getConstraintName();
    Number weightTotal = constraintMatchTotal.getWeightTotalAsNumber();
    for (ConstraintMatch constraintMatch : constraintMatchTotal.getConstraintMatchSet()) {
        List<Object> justificationList = constraintMatch.getJustificationList();
        Number weight = constraintMatch.getWeightAsNumber();
        ...
    }
}
----

[NOTE]
====
<<droolsScoreCalculation,Drools score calculation>> supports constraint matches automatically,
but <<incrementalJavaScoreCalculation,incremental Java score calculation>> requires requires implementing an extra interface (see that section).
====


[[testingScoreConstraints]]
== Testing score constraints with JUnit

It's recommended to write a unit test for each score constraint individually to check that it behaves correctly.

Add a test scoped dependency to the `optaplanner-test` jar to take advantage of the JUnit integration and use the `ScoreVerifier` classes to test score rules in DRL (or a constraint match aware incremental score calculator). For example, suppose we want to test these score rules:

[source,options=""nowrap""]
----
global HardSoftScoreHolder scoreHolder;

rule ""requiredCpuPowerTotal""
    when
        ...
    then
        scoreHolder.addHardConstraintMatch(...);
end

...

rule ""computerCost""
    when
        ...
    then
        scoreHolder.addSoftConstraintMatch(...);
end
----

For each score rule, we have a separate `@Test` that only tests the effect of that score rule on the score:

[source,java,options=""nowrap""]
----
public class CloudBalancingScoreConstraintTest {

    private HardSoftScoreVerifier<CloudBalance> scoreVerifier = new HardSoftScoreVerifier<>(
            SolverFactory.createFromXmlResource(
                    ""org/optaplanner/examples/cloudbalancing/solver/cloudBalancingSolverConfig.xml""));

    @Test
    public void requiredCpuPowerTotal() {
        CloudComputer c1 = new CloudComputer(1L, 1000, 1, 1, 1);
        CloudComputer c2 = new CloudComputer(2L, 200, 1, 1, 1);
        CloudProcess p1 = new CloudProcess(1L, 700, 0, 0);
        CloudProcess p2 = new CloudProcess(2L, 70, 0, 0);
        CloudBalance solution = new CloudBalance(0L,
                Arrays.asList(c1, c2),
                Arrays.asList(p1, p2));
        // Uninitialized
        scoreVerifier.assertHardWeight(""requiredCpuPowerTotal"", 0, solution);
        p1.setComputer(c1);
        p2.setComputer(c1);
        // Usage 700 + 70 is within capacity 1000 of c1
        scoreVerifier.assertHardWeight(""requiredCpuPowerTotal"", 0, solution);
        p1.setComputer(c2);
        p2.setComputer(c2);
        // Usage 700 + 70 is above capacity 200 of c2
        scoreVerifier.assertHardWeight(""requiredCpuPowerTotal"", -570, solution);
    }

    ...

    @Test
    public void computerCost() {
        CloudComputer c1 = new CloudComputer(1L, 1, 1, 1, 200);
        CloudComputer c2 = new CloudComputer(2L, 1, 1, 1, 30);
        CloudProcess p1 = new CloudProcess(1L, 0, 0, 0);
        CloudProcess p2 = new CloudProcess(2L, 0, 0, 0);
        CloudBalance solution = new CloudBalance(0L,
                Arrays.asList(c1, c2),
                Arrays.asList(p1, p2));
        // Uninitialized
        scoreVerifier.assertSoftWeight(""computerCost"", 0, solution);
        p1.setComputer(c1);
        p2.setComputer(c1);
        // Pay 200 for c1
        scoreVerifier.assertSoftWeight(""computerCost"", -200, solution);
        p2.setComputer(c2);
        // Pay 200 + 30 for c1 and c2
        scoreVerifier.assertSoftWeight(""computerCost"", -230, solution);
    }

}
----

There is a `ScoreVerifier` implementation for each `Score` implementation.
In the `assertHardWeight()` and `assertSoftWeight()` methods, the weight of the other score rules is ignored (even those of the same score level).

[NOTE]
====
A ScoreVerifier does not work well to isolate score corruption,
use <<invalidScoreDetection, an `assertionScoreDirectorFactory`>> instead.
====
",12126,False,1999.9862660268234,median
"// Copyright (C) 2020 T. Zachary Laine
//
// 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)

// Warning! This file is autogenerated.
#include <boost/text/word_break.hpp>

#include <gtest/gtest.h>

#include <algorithm>


TEST(word, breaks_20)
{
    // ÷ 0020 ÷ 0061 ÷ 002C ÷	
    // ÷ [0.2] SPACE (WSegSpace) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0x20, 0x61, 0x2c }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
    }


    // ÷ 0020 × 0308 ÷ 0061 ÷ 002C ÷	
    // ÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN SMALL LETTER A (ALetter) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
    {
        std::array<uint32_t, 4> cps = {{ 0x20, 0x308, 0x61, 0x2c }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 3, cps.end()) - cps.begin(), 4);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 4, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 3, cps.end()) - cps.begin(), 4);
    }


    // ÷ 0020 ÷ 0031 ÷ 003A ÷	
    // ÷ [0.2] SPACE (WSegSpace) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0x20, 0x31, 0x3a }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
    }


    // ÷ 0020 × 0308 ÷ 0031 ÷ 003A ÷	
    // ÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
    {
        std::array<uint32_t, 4> cps = {{ 0x20, 0x308, 0x31, 0x3a }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 3, cps.end()) - cps.begin(), 4);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 4, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 3, cps.end()) - cps.begin(), 4);
    }


    // ÷ 0020 ÷ 0031 ÷ 0027 ÷	
    // ÷ [0.2] SPACE (WSegSpace) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0x20, 0x31, 0x27 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
    }


    // ÷ 0020 × 0308 ÷ 0031 ÷ 0027 ÷	
    // ÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]
    {
        std::array<uint32_t, 4> cps = {{ 0x20, 0x308, 0x31, 0x27 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 3, cps.end()) - cps.begin(), 4);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 4, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 3, cps.end()) - cps.begin(), 4);
    }


    // ÷ 0020 ÷ 0031 ÷ 002C ÷	
    // ÷ [0.2] SPACE (WSegSpace) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0x20, 0x31, 0x2c }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
    }


    // ÷ 0020 × 0308 ÷ 0031 ÷ 002C ÷	
    // ÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
    {
        std::array<uint32_t, 4> cps = {{ 0x20, 0x308, 0x31, 0x2c }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 3, cps.end()) - cps.begin(), 4);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 4, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 3, cps.end()) - cps.begin(), 4);
    }


    // ÷ 0020 ÷ 0031 ÷ 002E × 2060 ÷	
    // ÷ [0.2] SPACE (WSegSpace) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
    {
        std::array<uint32_t, 4> cps = {{ 0x20, 0x31, 0x2e, 0x2060 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 4);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 4);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 4, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 4);
    }


    // ÷ 0020 × 0308 ÷ 0031 ÷ 002E × 2060 ÷	
    // ÷ [0.2] SPACE (WSegSpace) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ONE (Numeric) ÷ [999.0] FULL STOP (MidNumLet) × [4.0] WORD JOINER (Format_FE) ÷ [0.3]
    {
        std::array<uint32_t, 5> cps = {{ 0x20, 0x308, 0x31, 0x2e, 0x2060 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 3, cps.end()) - cps.begin(), 5);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 4, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 3, cps.end()) - cps.begin(), 5);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 5, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 3, cps.end()) - cps.begin(), 5);
    }


    // ÷ 00AD ÷ 0001 ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
    {
        std::array<uint32_t, 2> cps = {{ 0xad, 0x1 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
    }


    // ÷ 00AD × 0308 ÷ 0001 ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] <START OF HEADING> (Other) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0xad, 0x308, 0x1 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
    }


    // ÷ 00AD ÷ 000D ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [3.2] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
    {
        std::array<uint32_t, 2> cps = {{ 0xad, 0xd }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
    }


    // ÷ 00AD × 0308 ÷ 000D ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.2] <CARRIAGE RETURN (CR)> (CR) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0xad, 0x308, 0xd }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
    }


    // ÷ 00AD ÷ 000A ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [3.2] <LINE FEED (LF)> (LF) ÷ [0.3]
    {
        std::array<uint32_t, 2> cps = {{ 0xad, 0xa }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
    }


    // ÷ 00AD × 0308 ÷ 000A ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.2] <LINE FEED (LF)> (LF) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0xad, 0x308, 0xa }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
    }


    // ÷ 00AD ÷ 000B ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [3.2] <LINE TABULATION> (Newline) ÷ [0.3]
    {
        std::array<uint32_t, 2> cps = {{ 0xad, 0xb }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
    }


    // ÷ 00AD × 0308 ÷ 000B ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [3.2] <LINE TABULATION> (Newline) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0xad, 0x308, 0xb }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
    }


    // ÷ 00AD ÷ 3031 ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
    {
        std::array<uint32_t, 2> cps = {{ 0xad, 0x3031 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
    }


    // ÷ 00AD × 0308 ÷ 3031 ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] VERTICAL KANA REPEAT MARK (Katakana) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0xad, 0x308, 0x3031 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
    }


    // ÷ 00AD ÷ 0041 ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
    {
        std::array<uint32_t, 2> cps = {{ 0xad, 0x41 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
    }


    // ÷ 00AD × 0308 ÷ 0041 ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LATIN CAPITAL LETTER A (ALetter) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0xad, 0x308, 0x41 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
    }


    // ÷ 00AD ÷ 003A ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
    {
        std::array<uint32_t, 2> cps = {{ 0xad, 0x3a }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
    }


    // ÷ 00AD × 0308 ÷ 003A ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COLON (MidLetter) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0xad, 0x308, 0x3a }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
    }


    // ÷ 00AD ÷ 002C ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
    {
        std::array<uint32_t, 2> cps = {{ 0xad, 0x2c }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
    }


    // ÷ 00AD × 0308 ÷ 002C ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] COMMA (MidNum) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0xad, 0x308, 0x2c }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
    }


    // ÷ 00AD ÷ 002E ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]
    {
        std::array<uint32_t, 2> cps = {{ 0xad, 0x2e }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
    }


    // ÷ 00AD × 0308 ÷ 002E ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] FULL STOP (MidNumLet) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0xad, 0x308, 0x2e }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
    }


    // ÷ 00AD ÷ 0030 ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
    {
        std::array<uint32_t, 2> cps = {{ 0xad, 0x30 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
    }


    // ÷ 00AD × 0308 ÷ 0030 ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] DIGIT ZERO (Numeric) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0xad, 0x308, 0x30 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
    }


    // ÷ 00AD ÷ 005F ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
    {
        std::array<uint32_t, 2> cps = {{ 0xad, 0x5f }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
    }


    // ÷ 00AD × 0308 ÷ 005F ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] LOW LINE (ExtendNumLet) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0xad, 0x308, 0x5f }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
    }


    // ÷ 00AD ÷ 1F1E6 ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]
    {
        std::array<uint32_t, 2> cps = {{ 0xad, 0x1f1e6 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
    }


    // ÷ 00AD × 0308 ÷ 1F1E6 ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] REGIONAL INDICATOR SYMBOL LETTER A (RI) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0xad, 0x308, 0x1f1e6 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
    }


    // ÷ 00AD ÷ 05D0 ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]
    {
        std::array<uint32_t, 2> cps = {{ 0xad, 0x5d0 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
    }


    // ÷ 00AD × 0308 ÷ 05D0 ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] HEBREW LETTER ALEF (Hebrew_Letter) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0xad, 0x308, 0x5d0 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
    }


    // ÷ 00AD ÷ 0022 ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]
    {
        std::array<uint32_t, 2> cps = {{ 0xad, 0x22 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
    }


    // ÷ 00AD × 0308 ÷ 0022 ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] QUOTATION MARK (Double_Quote) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0xad, 0x308, 0x22 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
    }


    // ÷ 00AD ÷ 0027 ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]
    {
        std::array<uint32_t, 2> cps = {{ 0xad, 0x27 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
    }


    // ÷ 00AD × 0308 ÷ 0027 ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] APOSTROPHE (Single_Quote) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0xad, 0x308, 0x27 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
    }


    // ÷ 00AD ÷ 231A ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] WATCH (ExtPict) ÷ [0.3]
    {
        std::array<uint32_t, 2> cps = {{ 0xad, 0x231a }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
    }


    // ÷ 00AD × 0308 ÷ 231A ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] WATCH (ExtPict) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0xad, 0x308, 0x231a }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
    }


    // ÷ 00AD ÷ 0020 ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]
    {
        std::array<uint32_t, 2> cps = {{ 0xad, 0x20 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 1);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 1, cps.end()) - cps.begin(), 2);
    }


    // ÷ 00AD × 0308 ÷ 0020 ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) ÷ [999.0] SPACE (WSegSpace) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0xad, 0x308, 0x20 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 2, cps.end()) - cps.begin(), 3);
    }


    // ÷ 00AD × 00AD ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
    {
        std::array<uint32_t, 2> cps = {{ 0xad, 0xad }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
    }


    // ÷ 00AD × 0308 × 00AD ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] SOFT HYPHEN (Format_FE) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0xad, 0x308, 0xad }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 3);
    }


    // ÷ 00AD × 0300 ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
    {
        std::array<uint32_t, 2> cps = {{ 0xad, 0x300 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
    }


    // ÷ 00AD × 0308 × 0300 ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] COMBINING GRAVE ACCENT (Extend_FE) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0xad, 0x308, 0x300 }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 3);
    }


    // ÷ 00AD × 200D ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] ZERO WIDTH JOINER (ZWJ_FE) ÷ [0.3]
    {
        std::array<uint32_t, 2> cps = {{ 0xad, 0x200d }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 2);
    }


    // ÷ 00AD × 0308 × 200D ÷	
    // ÷ [0.2] SOFT HYPHEN (Format_FE) × [4.0] COMBINING DIAERESIS (Extend_FE) × [4.0] ZERO WIDTH JOINER (ZWJ_FE) ÷ [0.3]
    {
        std::array<uint32_t, 3> cps = {{ 0xad, 0x308, 0x200d }};
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 0, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 1, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 2, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 3);
        EXPECT_EQ(boost::text::prev_word_break(cps.begin(), cps.begin() + 3, cps.end()) - cps.begin(), 0);
        EXPECT_EQ(boost::text::next_word_break(cps.begin() + 0, cps.end()) - cps.begin(), 3);
    }


}
",16281,True,6233.502949119925,median
"// infer.cpp - handles queries into fact data

#include ""common.h""

#define MAX_PARENTS 9980
#define MAX_QUEUE 10000
#define FOLLOW_LIMIT 50

static MEANING parents[MAX_PARENTS+20];	// nodes above where we are now
static int parentIndex = 0;		// add into parents at here
static int parentWalk = 0;		// retrieve from parents starting here. when reach parentIndex you have run out
static unsigned int currentBaseInfer;	// start of reserved marks
static unsigned int currentFreeInfer;	// marks before this are reserved

unsigned int inferMark = 0;				// primary ""been-here"" mark for all inferencing and tree traversals
static unsigned int saveMark = 0;		// tertiary mark - used in zone 1 control
static unsigned int ignoremark = 0;		// mark on entries to ignore
static WORDP fact = 0;

#define ORIGINALWORD 0x00000001
#define NORMAL		 0x00000002    //   class and set are a group (recursive)
#define QUOTED		 0x00000004   //   class and set are simple words
#define PREMARK		 0X00000008   //   marking but save word not meaning so wont use as scan
#define NOQUEUE		 0X00000010   //   just marked with mark, not queued
#define QUEUE		 0X00000020	//    add to q
#define NOTOPIC		 0X00000040	//   dont follow topic/set names
#define BLOCKMEANING 0X00000080
#define FACTTYPE	 0X00000100
#define FINDTOPIC	 0X00000200
#define UPDICTIONARY 0X00000400
#define USERFACTS	 0X00000800
#define SYSTEMFACTS	 0X00001000
#define FINDCONCEPT	 0X00002000
// 4 8 unused
#define USE_ORIGINAL_SUBJECT			0x00010000 // use subject as fact source
#define USE_ORIGINAL_OBJECT				0x00020000 // use object as fact source
#define RICCOCHET_USING_SUBJECT			0x00040000 
#define RICCOCHET_USING_OBJECT			0x00080000
#define RICCOCHET_BITS ( USE_ORIGINAL_SUBJECT | USE_ORIGINAL_OBJECT | RICCOCHET_USING_SUBJECT | RICCOCHET_USING_OBJECT )

// queued entries pending scanning
static MEANING queue[MAX_QUEUE+20]; 
static unsigned int queueIndex;

// answers from inferences go in these sets
FACT* factSet[MAX_FIND_SETS+2][MAX_FIND+1]; 
int	  factFlags[MAX_FIND+1];
int	  factIndex[MAX_FIND+1];
unsigned int factSetNext[MAX_FIND_SETS+1];		// when walking a set over time, which index to continue from

static void AddSet2Scan(unsigned int flags,WORDP D,int depth);

unsigned int NextInferMark() // set up for a new inference
{
    return ++inferMark;
}

FACT* IsConceptMember(WORDP D)
{
	if (!D) return NULL;
	FACT* F = GetSubjectNondeadHead(D);
	while (F)
	{
		if (ValidMemberFact(F))  return F;	// is a concept member so it is ok
		F = GetSubjectNondeadNext(F);
	}
	return NULL;
}

static bool IsExcluded(WORDP set,WORDP item)
{
	FACT* F = GetObjectNondeadHead(set);
	while (F)
	{
		if (F->verb == Mmember) break; // exclusions come first, so none found
		if (F->verb == Mexclude)
		{
			if (Meaning2Word(F->subject) == item) break;
		}
		F = GetObjectNondeadNext(F);
	}
	return (F) ? true : false;
}

static bool SetContains1(MEANING set,MEANING M, unsigned int depth) 
{
	if (!M || !set) return false;

	// the word
	WORDP D = Meaning2Word(M);
	unsigned int index = Meaning2Index(M);
	D->inferMark = inferMark;
	FACT* F = GetSubjectNondeadHead(D);

	WORDP D1 = Meaning2Word(set);

	// we walk up the tree from the word and see if it runs into D1, the set.
	if (depth == 0) 
	{
		SetFactBack(D,0); 
		if (trace & TRACE_INFER && CheckTopicTrace()) Log(STDUSERLOG,(char*)"" %s ? %s "",D->word,D1->word);
	}
	unsigned int counter = 20000;
	while (F && --counter)
	{
		if (index != 0 && F->subject != M); // fact doesnt apply
		else if (ValidMemberFact(F))
		{
			// if this topic or concept has exclusions, check to see if this is a marked exclusion
			bool blocked = false;
			WORDP object = Meaning2Word(F->object);
			FACT* G = GetObjectNondeadHead(object);
			while (G && !blocked)
			{
				if (G->verb == Mexclude)
				{
					if (Meaning2Word(G->subject)->inferMark == inferMark) blocked = true;
				}
				else if (G->verb == Mmember) break;
				G = GetObjectNondeadNext(G);
			}

			// since this is not a marked exclusion, we can say it is a member
			if (F->object == set && !blocked) 
			{
				if (trace & TRACE_INFER && CheckTopicTrace()) // show the path from set back to word
				{
					Log(STDUSERLOG,(char*)""\\r\\n"");
					Log(STDTRACETABLOG,(char*)""within: %s "",D1->word);
					WORDP path = Meaning2Word(F->subject); 
					while (path)
					{
						Log(STDUSERLOG,(char*)"" %s "",path->word);
						FACT* prior = Index2Fact(GetFactBack(path));
						path = (prior) ? Meaning2Word(prior->subject) : 0;
					}
					Log(STDUSERLOG,(char*)""\\r\\n"");
					Log(STDTRACETABLOG,(char*)"""");
				}

				return true;
			}
			if (!blocked && object->inferMark != inferMark)
			{
				SetFactBack(object,Fact2Index(F));
				if (SetContains1(set,F->object,depth + 1)) return true;
			}
		}
		else if (F->verb == Mis) // a link up the wordnet ontology
		{
			if (F->object == set)  return true;
			WORDP object = Meaning2Word(F->object);
			if (object->inferMark != inferMark)
			{
				SetFactBack(object,Fact2Index(F));
				if (SetContains1(set,F->object,depth + 1)) return true;
			}
		}
		F = GetSubjectNondeadNext(F);
	}
	if (trace & TRACE_INFER && depth == 0 && CheckTopicTrace())
	{
		Log(STDUSERLOG,(char*)"" not within "");
	}
	return false;
}

bool SetContains(MEANING set,MEANING M) 
{
	bool answer = SetContains1(set,M,0);
	ClearBacktracks();
	return answer;
}

static bool AllowedMember(FACT* F, unsigned int i,unsigned int is,unsigned int index)
{
	if (trace & TRACE_INFER && CheckTopicTrace())  TraceFact(F);
    unsigned int localIndex = Meaning2Index(F->subject);
	unsigned int pos = GetMeaningType(F->subject);
	bool bad = false;
	if (!i && pos ) 
	{
            if (pos & VERB && is & NOUN)  
            {
				bad = true;
            }
            else if (pos & NOUN && is & VERB)  
            {
				bad = true;
            }
            else if ((pos & ADJECTIVE || localIndex & ADVERB) && is & (NOUN|VERB))  
            {
				bad = false;
            }
 	}
	else if (index && pos && pos != index) bad = true;
	return !bad;
}

static void QueryFacts(WORDP original, WORDP D,unsigned int index,unsigned int store,char* kind,MEANING A)
{
    if (!D || D->inferMark == inferMark) return;
    D->inferMark = inferMark; 
    FACT* F;
    FACT* G = GetSubjectNondeadHead(D); 
    unsigned int count = 20000;
    unsigned int restriction = 0;
	if (kind) //   limitation on translation of word as member of a set
	{
		if (!strnicmp(kind,(char*)""subject"",7)) restriction = NOUN;
		else if (!strnicmp(kind,(char*)""verb"",4)) restriction = VERB;
		else if (!strnicmp(kind,(char*)""object"",7)) restriction = NOUN;
	}
	while (G)
    {
        F = G;
        G = GetSubjectNondeadNext(G);
        if (trace & TRACE_INFER  && CheckTopicTrace()) TraceFact(F);

        if (!--count) 
		{
			ReportBug((char*)""matchfacts infinite loop"")
			break;
		}
        uint64 flags = F->flags;
        unsigned int fromindex = Meaning2Index(F->subject);
        if (fromindex == index || !fromindex); //   we allow penguins to go up to bird, then use unnamed bird to go to ~topic
        else if (index ) continue;  //   not following this path
        else if (flags & ORIGINALWORD) continue; //   you must match exactly- generic not allowed to match specific wordnet meaning- hierarchy BELOW only

		if (ValidMemberFact(F) && !AllowedMember(F,0,restriction,0)) continue; // POS doesn't match
        if (ValidMemberFact(F) && !(flags & ORIGINALWORD))
        {
            WORDP object = Meaning2Word(F->object);
            if (object->inferMark != inferMark) 
            {
				if (*object->word == '~') // set, not a word association
                {
					if (IsExcluded(object,original)) continue; // explicitly excluded from this set

					if (object->internalBits & TOPIC)
					{
						int topic = FindTopicIDByName(object->word);
						if (topic && !(GetTopicFlags(topic) & TOPIC_SYSTEM) && HasGambits(topic)) AddFact(store,CreateFact(MakeMeaning(original,0),A,MakeMeaning(object,0),FACTTRANSIENT));
					}
                }
                QueryFacts(original,object,0,store,kind,A);
            }
         }
    }
}

FunctionResult QueryTopicsOf(char* word,unsigned int store,char* kind) // find topics referred to by word
{
	SET_FACTSET_COUNT(store,0);
    NextInferMark(); 
    WORDP D = FindWord(word,0);
    QueryFacts(D,D,0,store,kind,MakeMeaning(FindWord((char*)""a"")));
    if (trace & TRACE_INFER && CheckTopicTrace()) Log(STDUSERLOG,(char*)""QueryTopics: %s %d "",word,FACTSET_COUNT(store));
	impliedSet = ALREADY_HANDLED;
	return  NOPROBLEM_BIT;
}

static bool AddWord2Scan(int flags,MEANING M,MEANING from,int depth,unsigned int type) // mark (and maybe queue) this word + implied wordnet up hierarchy + auto-equivalences
{
    if (queueIndex >= MAX_QUEUE || !M) return false; 
	if (type && !(M & type) && GETTYPERESTRICTION(M)) return false;	// not valid type restriction

	// mark word or abandon marking
    WORDP D = Meaning2Word(M);
	unsigned int index = Meaning2Index(M);
	if (D->inferMark == saveMark || (ignoremark &&  D->inferMark == ignoremark)) return false; // marked with a current mark
	if (depth > FOLLOW_LIMIT)
	{
		ReportBug((char*)""Exceeding follow limit %s\\r\\n"",D->word)
		return false;	
	}

	// concept set has exclusions, so if excluded is already marked, do not allow this topic to be marked
	FACT* G = GetObjectNondeadHead(D);
	while (G)
	{
		if (G->verb == Mexclude)
		{
			if (Meaning2Word(G->subject)->inferMark == saveMark) return false;
		}
		if (G->verb == Mmember) break;
		G = GetObjectNondeadNext(G);
	}

	D->inferMark = saveMark; 
	if (flags & QUEUE) queue[queueIndex++] = M;

	if (trace & TRACE_QUERY && CheckTopicTrace()) 
	{
		static char last[1000];
		if (from)
		{
			char* mean = WriteMeaning(from);
			if (stricmp(last,mean))
			{
				Log(STDUSERLOG,(char*)""\\r\\n"");
				Log(STDTRACETABLOG,(char*)""(%s=>) "",mean);
				if (strlen(mean) > 999) ReportBug(""Scan insert > 1000"")
				else strcpy(last,mean);
			}
		}
		Log(STDUSERLOG,(flags & QUEUE) ? (char*)"" %s+"" : "" %s. "",WriteMeaning(M));
	}

    // auto check all equivalences as well
    FACT* F = GetSubjectNondeadHead(D);
    while (F)
    {
		if (ValidMemberFact(F))  // can be member of an ordinary word (like USA member United_States_of_America), creates equivalence
		{
			WORDP D = Meaning2Word(F->object);
			if (*D->word != '~') AddWord2Scan(flags,F->object,F->subject,depth+1,type); // member is not to a set, but to a word. So it's an equivalence
		}
        F = GetSubjectNondeadNext(F);
    }
	
	// and if item is generic, all synsets
	if (index == 0 && !(flags & ORIGINALWORD))
	{
		unsigned int count = GetMeaningCount(D);
		for (unsigned int i = 1; i <= count; ++i) AddWord2Scan(flags,GetMeaning(D,i),M,depth+1,type);
	}

	return true;
}

static bool AddWordOnly(int flags,char* word,unsigned int type) // mark (and maybe queue) this word 
{
    if (queueIndex >= MAX_QUEUE || !*word) return false; 

	// mark word or abandon marking
    WORDP D = StoreWord(word,AS_IS);
	if (D->inferMark == saveMark) return false; // marked with a current mark
	D->inferMark = saveMark; 
	if (flags & QUEUE) queue[queueIndex++] = MakeMeaning(D);

	if (trace & TRACE_QUERY && CheckTopicTrace())  Log(STDUSERLOG,(flags & QUEUE) ? (char*)"" %s+"" : (char*)"" %s. "",D->word);

	return true;
}

static void AddWordOrSet2Scan(unsigned int how, char* word,int depth)
{
	++depth;
	if (!(how & ORIGINALWORD) && *word == '~' && word[1]) //   recursive on set and all its members
    {
		WORDP D = FindWord(word,0);
		if (D)
		{
			if (how & NOTOPIC && D->internalBits & TOPIC) {;} 
			else if (AddWord2Scan(how, MakeMeaning(D,0),0,depth,0)) AddSet2Scan(how,D,depth);  //   mark the original name and then follow its members
		}
	}
	else 
	{
		if (*word == '\\'')
		{
			// WORDP D = FindWord(word);
			//if (!D) 
			++word; // but dont harm 'tween_decks which is natural
		}
		AddWord2Scan(how, ReadMeaning(word, true, true), 0, depth, 0);
	}
}

static void AddSet2Scan(unsigned int how,WORDP D,int depth)
{
	++depth;
	FACT* F = GetObjectNondeadHead(D);
	while (F)
	{
		if (ValidMemberFact(F))  AddWordOrSet2Scan(how | (F->flags & ORIGINALWORD),Meaning2Word(F->subject)->word,depth);
		F = GetObjectNondeadNext(F);
	}
}

// used by query setup - scans noun hierarchies upwards for inference
static void ScanHierarchy(MEANING T,int savemark,unsigned int flowmark,bool up,unsigned int flag, unsigned int type)
{
	if (!T) return;
	if (trace & TRACE_QUERY && CheckTopicTrace()) Log(STDUSERLOG,(char*)""\\r\\nHierarchy: (%s=>) "",WriteMeaning(T));
	if (!AddWord2Scan(flag,T,0,0,type)) return;

	parentIndex = parentWalk  = 0;
	parents[parentIndex++] = T;

	WORDP A = Meaning2Word(T);

	int index = Meaning2Index(T);
	int start = 1;

	//   find its wordnet ontological meanings, they then link synset head to synset head
	//   automatically store matching synset heads to this also -- THIS APPLIES ONLY TO THE ORIGINAL WORDP
	MEANING* onto = GetMeaningsFromMeaning(T);
	unsigned int size = GetMeaningCount(A);
	if (!up || flag & BLOCKMEANING ) size = 0;//   we are a specific meaning already, so are the synset head of something - or are going down
	else if (index) start= size = index;	//   do JUST this one
	else if (!size) size = 1; //   even if no ontology, do it once for 
	for  (unsigned int k = start; k <= size; ++k) // for each meaning of this word, mark its synset heads
	{
		MEANING T1;
		if (GetMeaningCount(A)) 
		{
			T1 = (MEANING)(ulong_t)onto[k]; //   this is the synset ptr.
			if (T1 & SYNSET_MARKER) T1 = MakeMeaning(A,k) | SYNSET_MARKER;
			else T1 = GetMaster(T1);

			if (type && !(T1 & type)) continue;	
			if (! AddWord2Scan(flag,T1,T,0,type)) continue; //   either already marked OR to be ignored
			parents[parentIndex++] = T1;	
		}
	}

	while (parentWalk < parentIndex) //   walk up its chains in stages
	{
		T = parents[parentWalk++];
		if (!T) continue;
		if (parentIndex > MAX_PARENTS) break;	//   overflow may happen. give up
		WORDP D = Meaning2Word(T);
		unsigned int index = Meaning2Index(T);
		
		// now follow facts of the synset head itself or the word itself.
		FACT* F = GetSubjectNondeadHead(D);
		while (F)
		{
			WORDP verb = Meaning2Word(F->verb); 
			FACT* G = F;
			if (trace & TRACE_QUERY && CheckTopicTrace()) TraceFact(F);
			F = GetSubjectNondeadNext(F);
			if (verb->inferMark !=  flowmark) continue;

			//   if the incoming ptr is generic, it can follow out any generic or pos_generic reference.
			//   It cannot follow out a specific reference of a particular meaning.
			//   An incoming non-generic ptr is always specific (never pos_generic) and can only match specific exact.
			if (index && T !=  G->subject) continue; //   generic can run all meanings out of here
			MEANING x = G->object; 
			if (type && GETTYPERESTRICTION(G->subject )  && !(type & GETTYPERESTRICTION(G->subject ))) continue;  // fact has bad type restriction on subject
			if (!AddWord2Scan(flag,x,G->subject,0,type)) continue;	//   either already marked OR to be ignored
			parents[parentIndex++] = x;
		}
	}

	if (trace & TRACE_QUERY && CheckTopicTrace()) Log(STDUSERLOG,(char*)""\\r\\n"");
}

static bool Riccochet(unsigned int baseFlags, FACT* G,int set,unsigned int limit,unsigned int rmarks,unsigned int rmarkv, unsigned int rmarko)
{// use two fields to select a third. Then look at facts of that third to find a matching verb.
	FACT* F;
	WORDP D1;
	if (G->flags & (FACTSUBJECT|FACTOBJECT)) // we cant get here if the wrong field is a fact.
	{
		D1 = fact;
		F = (baseFlags & USE_ORIGINAL_SUBJECT) ? Index2Fact(G->subject) : Index2Fact(G->object);
	}
	else
	{
		D1 = (baseFlags & USE_ORIGINAL_SUBJECT) ? Meaning2Word(G->subject) : Meaning2Word(G->object);
		F  = (baseFlags & RICCOCHET_USING_SUBJECT) ? GetSubjectNondeadHead(D1) : GetObjectNondeadHead(D1);
	}
	if (trace & TRACE_QUERY && CheckTopicTrace()) 
	{
		WORDP S = (G->flags & FACTSUBJECT) ? fact : Meaning2Word(G->subject);
		WORDP V = (G->flags & FACTVERB) ? fact : Meaning2Word(G->verb);
		WORDP O = (G->flags & FACTOBJECT) ? fact : Meaning2Word(G->object);
		char* use = (baseFlags & RICCOCHET_USING_SUBJECT) ? (char*) ""subjectfield"" : (char*) ""objectfield"";
		if (baseFlags & USE_ORIGINAL_SUBJECT) Log(STDUSERLOG,(char*)""Riccochet incoming (%s %s %s) via subject %s using %s\\r\\n"",S->word,V->word,O->word,D1->word,use);
		else Log(STDUSERLOG,(char*)""Riccochet incoming (%s %s %s) via object %s using %s\\r\\n"",S->word,V->word,O->word,D1->word,use);
	}

	// walk all facts at node testnig for riccochet
	while (F)	 // walk_of_S3
	{
		if (trace & TRACE_QUERY && CheckTopicTrace()) TraceFact(F);
		FACT* I = F; 
		if (D1 == fact) F = NULL; // only the 1 main fact
		else F = (baseFlags & RICCOCHET_USING_SUBJECT)  ? GetSubjectNondeadNext(F) : GetObjectNondeadNext(F);
		if (I->flags & FACTDEAD) continue;	 // cannot use this

		// reasons this fact is no good
		if (I->flags & MARKED_FACT) continue; // already seen this answer
		if ((baseFlags & SYSTEMFACTS && I > factLocked) || (baseFlags & USERFACTS && I <= factLocked) ) continue; // restricted by owner of fact
		if (rmarks && (I->flags & FACTSUBJECT || Meaning2Word(I->subject)->inferMark != rmarks)) continue; // mark must match
		if (rmarkv && (I->flags & FACTVERB || Meaning2Word(I->verb)->inferMark != rmarkv)) continue; // mark must match
		if (rmarko && (I->flags & FACTOBJECT || Meaning2Word(I->object)->inferMark != rmarko)) continue; // mark must match

		I->flags |= MARKED_FACT;
		AddFact(set,I); 
		if (trace & TRACE_QUERY && CheckTopicTrace()) 
		{
			Log(STDUSERLOG,(char*)""    Found:"");
			TraceFact(I);
		}
		if (FACTSET_COUNT(set) >= limit) return false;
	}
	return true;
}

static bool ConceptPropogateTest(MEANING M,unsigned int mark,unsigned int depth)  // is this meaning ultimately in a marked set
{
	if (!depth) 
	{
		NextInferMark();
		if (trace & TRACE_QUERY && CheckTopicTrace())  Log(STDUSERLOG,(char*)""\\r\\n ~propogate: "");
	}
	
	FACT* F = GetSubjectNondeadHead(M);
	while (F)
	{
		if (ValidMemberFact(F) && F->subject == M)
		{
			MEANING O = F->object;
			WORDP D = Meaning2Word(O);
			if (trace & TRACE_QUERY && CheckTopicTrace())  Log(STDUSERLOG,(char*)"" %d->%s "",depth,D->word);
 
			if (D->inferMark == mark) return true; // this is what we seek
			if (D->inferMark != inferMark)// not already visited this pass or is marked for current query for other use
			{
				if (D->inferMark < currentBaseInfer || D->inferMark >= currentFreeInfer) D->inferMark = inferMark; // safely set seen this (efficiency)
				if (*D->word == '~' && ConceptPropogateTest(O,mark,depth+1)) return true;  // NOT setting been here- and dont follow fake members ( word member word)
			}
		}
		F = GetSubjectNondeadNext(F);
	}
	return false;
}

unsigned int Query(char* kind, char* subjectword, char* verbword, char* objectword, unsigned int count, char* fromset, char* toset, char* propogate, char* match)
{
	int store = GetSetID(toset);
	if (store == ILLEGAL_FACTSET) store = 0;
	if (trace & TRACE_QUERY && CheckTopicTrace()) Log(STDTRACETABLOG,(char*)""QUERY: @%d %s "",store,kind);
	WORDP C = FindWord(kind,0);
	if (!C || !(C->internalBits & QUERY_KIND)) 
	{
		ReportBug((char*)""Illegal query name: %s"",kind)
		return 0;
	}
	char copy[MAX_WORD_SIZE];	// hold the actual control value, so we can overwrite it
	char* control = NULL;
	if (C->w.userValue && *C->w.userValue) 
	{	
		strcpy(copy,C->w.userValue);
		control = copy;
	}
	else 
	{
		ReportBug((char*)""query control lacks data %s"",kind)
		return 0;
	}

	// get correct forms of arguments - _ is an empty argument, but legal
	char word[MAX_WORD_SIZE];
	int n;
	if (!strchr(subjectword,' ')) // anything with a natural space in it should be left alone
	{
	    n = BurstWord(subjectword);
		if (n > 1) strcpy(subjectword,JoinWords(n,false));
	}
  	if (!strchr(verbword,' ')) // anything with a natural space in it should be left alone
	{
		n = BurstWord(verbword);
		if (n > 1) strcpy(verbword,JoinWords(n,false));
	}
    if (!strchr(objectword,' ')) // anything with a natural space in it should be left alone
	{	
		n = BurstWord(objectword);
		if (n > 1) strcpy(objectword,JoinWords(n,false));
	}
	if (!strchr(match,' ')) // anything with a natural space in it should be left alone
	{	
		n = BurstWord(match);
		if (n > 1) strcpy(match,JoinWords(n,false));
	}
	if (!strchr(propogate,' ')) // anything with a natural space in it should be left alone
	{	
		n = BurstWord(propogate);
		if (n > 1) strcpy(propogate,JoinWords(n,false));
	}
	if (trace & TRACE_QUERY && CheckTopicTrace()) 
	{
		Log(STDTRACETABLOG,(char*)"" control: %s  s/v/o:[%s %s %s] count:%d "",control,subjectword,verbword,objectword,count);   
		if (*fromset != '?') Log(STDUSERLOG,(char*)""fromset:%s "",fromset);   
		if (*toset != '?') Log(STDUSERLOG,(char*)""toset:%s "",toset);   
		if (*propogate != '?') Log(STDUSERLOG,(char*)""propogate:%s "",propogate);   
		if (*match != '?') Log(STDUSERLOG,(char*)""match:%s "",match);   
		Log(STDUSERLOG,(char*)""\\r\\n"");   
		Log(STDTRACETABLOG,(char*)"""");
	}

	//   handle what sets are involved
	if (impliedOp == 0 || impliedOp == '=')	SET_FACTSET_COUNT(store,0); // auto kill content
	else if (impliedOp != '+') 
	{
		SET_FACTSET_COUNT(store,0); // we dont support other ops like -=
		return 0; 
	}
	int from = GetSetID(fromset);
	if (from == ILLEGAL_FACTSET) from = 0;
	unsigned int baseFlags = 0;
    char myset[10];
    int baseOffset = 0; //   facts come from this side, and go out the verb or other side
    char* choice;
    choice = 0;
    char* at;
    int qMark = 0;
    int mark = 0;
    int whichset = 0;

	if (!stricmp(fromset,(char*)""user"")) baseFlags |= USERFACTS;
	if (!stricmp(fromset,(char*)""system"")) baseFlags |= SYSTEMFACTS;

	queueIndex = 0; 
	ignoremark = 0;
	unsigned int baseMark = inferMark; //   offsets of this value
	currentBaseInfer = baseMark + 1;	// start of used marks

	//   process initialization
nextsearch:  //   can do multiple searches, thought they have the same basemark so can be used across searchs (or not) up to 9 marks

#ifdef INFORMATION
# first segment describes what to initially mark and initially queue for processing (sources of facts)
#	Values:
#		1..9  = set global tag to this label - 0 means turn off global tag
#		i =  use argument tag on words to ignore during a  tag or queue operation 
#			Next char is tag label. 0 means no ignoremark
#		s/v/o/p/m/~set/tick-word  = use subject/verb/object/progogate/match/factset argument as item to process or use named set or given word 
#	    S/V/O  choice is a fact id
#			This is automatically marked using the current mark and is followed by 
#				q  = queue items (sets will follow to all members recursively and wordnet identities will propogate up)
#				Q  = queue this exact word only
#				t  = tag (no queue) items
#				e  = expandtag (no queue) (any set gets all things below it tagged)
#				h  = tag propogation from base (such propogation might be large)
#					1ST char after h is mark on verbs to propogate thru
#					2nd char is t or q (for tag or mark/queue)
#					3rd char (< >) after h is whether to propogate up from left/subject to object or down/right from object to subject when propogating
#		n = implied all topics marked to ignore on object
#		f = use given facts in from as items to process -- f@n  means use this set
#			This is followed by 
#			s/v/o/f	= use corresponding field of fact or entire fact
#		the value to process will be marked AND may or may not get stored, depending on following flag being q or m
#endif
    unsigned int intersectMark = 0, propogateVerb = 0;

	//   ZONE 1 - mark and queue setups
	fact = StoreWord((char*)""fact"");// for foreign languages insure word is there

	char maxmark = '0'; // deepest mark user has used
	if (trace & TRACE_QUERY && CheckTopicTrace()) 
	{
		// convert all _ and periods to spaces for easier viewing
		char* underscore;
		while ((underscore = strchr(control,'_'))) *underscore = ' ';

		char* colon = strchr(control,':');
		if (colon) *colon = 0;
		Log(STDUSERLOG,(char*)""@@@ Control1 mark/queue: %s\\r\\n"",control);
		if (colon) *colon = ':';
		Log(STDTRACETABLOG,(char*)"""");
	}
	--control;
	bool facttype = false;
	while (*++control && *control != ':' )
	{
		choice = NULL;
		switch(*control)
		{
			case '_': case '.': case ' ': // does nothing per se
				continue;	
			case '0':  // means NO savemark
				saveMark = 0; 
				continue;
			case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': //   set current marks
				saveMark = baseMark + *control - '0';
				if (*control > maxmark) maxmark = *control;
				continue;
			case 'n':  // ignore all member facts involving topic as object
				if (trace & TRACE_QUERY && CheckTopicTrace()) Log(STDUSERLOG,(char*)"" ignore all member facts w topics as objects "");
				++control; 
				baseFlags |= NOTOPIC;
				continue;
			case '~': case '\\'': //   use named set or named word
				choice = control; 
				at = strchr(control,'.'); //   set name ends with _ or . or space (generated)
				if (!at) at = strchr(control,'_');
				if (!at) at = strchr(control,' ');
				if (!at) 
				{
					ReportBug((char*)""Couldnt find end of name %s in control"",control)
					return 0; // couldn't find end of name
				}
				*at = 0;
				control = at;	// skip past to end
				break;
			case 'i': 
				++control;
				if (trace & TRACE_QUERY  && CheckTopicTrace()) Log(STDUSERLOG,(char*)"" ignore #%c results "", *control);
				ignoremark = (*control == '0') ? 0 : (baseMark + (*control - '0'));
				break;
			case 's': 
				choice = subjectword; 
				mark = 0; 
				break;
			case 'S':
				choice = subjectword;
				mark = 0;
				facttype = true;
				break;
			case 'v': // automatically quote verbs. NEVER let them wander
				if (*verbword == '\\'') strcpy(word,verbword);
				else
				{
					*word = '\\''; 
					strcpy(word+1,verbword);
				}
				choice = word; 
				mark = 1; 
				break;
			case 'V':
				choice = verbword;
				mark = 1;
				facttype = true;
				break;
			case 'o': 
				choice = objectword; 
				mark = 2; 
				break;
			case 'O':
				choice = objectword;
				mark = 2;
				facttype = true;
				break;
			case 'p': 
				choice = propogate; 
				break;
			case 'm': 
				choice = match; 
				break;
			case 'f':  //   we have incoming facts to use 
				whichset = (control[1] == '@') ? GetSetID(++control) : from; // only allowed sets 1-9
				if (whichset == ILLEGAL_FACTSET) return 0;
				sprintf(myset,""@%d"",whichset);
				choice = myset;
				break;
			default: 
				ReportBug((char*)""Bad control code for query init %s(%s) %s"",C->word,C->w.userValue,control)
				return 0;

		}
		if (choice) // we have something to follow
		{
			++control; // now see flags on the choice
			unsigned int flags = baseFlags;
			// dont treat 'tween_decks as an originalword request
			if (choice[0] == '\\'' ) //  && !IsAlphaUTF8(choice[1]))  //dont expand this beyond its first leve --   $$tmp would come in with its value, which if set would fan out.  '$$tmp gets just its value
			{
				flags |= ORIGINALWORD;
				++choice;
			}
			if (choice[0] == '^') // replace the function arg
			{
				strcpy(word,FNVAR(choice+1));
				choice = word;
			}
			// dynamic choices
			if (choice[0] == '_') 
			{
				int wild = GetWildcardID(choice);
				if (wild == ILLEGAL_MATCHVARIABLE){;}
				else if (flags != 0)
				{
					choice = wildcardOriginalText[wild];
					if (*choice != '~') flags = 0; // '_0 treated as normal word unquoted (original meaning) unless its a set, then it must not expand instead
				}
				else choice = wildcardCanonicalText[wild];
			}
			else if (choice[0] == USERVAR_PREFIX && choice[1]) choice = GetUserVariable(choice);
			else if (choice[0] == SYSVAR_PREFIX && choice[1]) choice = SystemVariable(choice,NULL);
			else if (choice[0] == '@' )
			{
				if (trace & TRACE_QUERY  && CheckTopicTrace())  
				{
					Log(STDUSERLOG,(char*)""\\r\\n"");
					Log(STDTRACETABLOG,(char*)""FactField: %c(%d) "",saveMark-baseMark+'0',saveMark);
				}
				choice = NULL;
				for (unsigned int j = 1; j <= FACTSET_COUNT(whichset); ++j) 
				{
					FACT* F = factSet[whichset][j];
					if (F->flags & FACTDEAD) continue;	 // cannot use this

					MEANING M;
					if (*control == 'f') //   whole fact can be queued. It cannot be marked as on the queue
					{
						queue[queueIndex++] = Fact2Index(F);
						continue;
					}
					else if (*control == 's') M = F->subject; 
					else if (*control == 'v') M = F->verb; 
					else if (*control == 'o') M = F->object; 
					else 
					{
						ReportBug((char*)""bad control for query %s(%s) %s"",C->word,C->w.userValue,control)
						return 0;
					}
					if (trace & TRACE_QUERY  && CheckTopicTrace())  Log(STDUSERLOG,(char*)"" %s "",WriteMeaning(M));
					AddWord2Scan((control[1] == 'q') ? (QUEUE|flags) : flags,M,0,0,0);
				}
				continue;
			}
			else if (facttype) // choice is a fact
			{
				if (!IsDigit(*choice)) return 0; // illegal fact reference
				unsigned int f = atoi(choice);
				if (atoi(choice) > (int) Fact2Index(factFree)) return 0;	// beyond legal range
				// we can q it but we dont mark it....
				queue[queueIndex++] = f;
				baseFlags |= FACTTYPE; 
				facttype = false;
				continue;
			}
			if (choice[0] == '\\\\')  // accept this unchanged
			{
				if (trace & TRACE_QUERY  && CheckTopicTrace()) Log(STDUSERLOG,(char*)"" raw "");
				++choice;
			}

			// for non-factset values of choice
			char buf[1000];
			if (trace & TRACE_QUERY  && CheckTopicTrace()) sprintf(buf,(char*)""%s #%c(%d)"",choice,saveMark-baseMark+'0',saveMark);
            if (*control == ' ') continue;
            if (*control == 'q')
			{
				if (trace & TRACE_QUERY  && CheckTopicTrace()) 
				{
					Log(STDUSERLOG,(char*)""\\r\\n"");
					Log(STDTRACETABLOG,(char*)""Tag+Queue: %s "",buf);
				}
				qMark = saveMark;	//   if we q more later, use this mark by default
				if (*choice) AddWordOrSet2Scan(QUEUE|flags,choice,0); //   mark and queue items
			}
			else if (*control == 'Q') 
			{
				if (trace & TRACE_QUERY  && CheckTopicTrace()) 
				{
					Log(STDUSERLOG,(char*)""\\r\\n"");
					Log(STDTRACETABLOG,(char*)""Tag+QueueWord: %s "",buf);
				}
				qMark = saveMark;	//   if we q more later, use this mark by default
				if (*choice) AddWordOnly(QUEUE|flags,choice,0); //   mark and queue item
			}
			else  if (*control == 't') 
			{
				if (trace & TRACE_QUERY  && CheckTopicTrace()) 
				{
					Log(STDUSERLOG,(char*)""\\r\\n"");
					Log(STDTRACETABLOG,(char*)""Tag: %s "",buf);
					if (flags & ORIGINALWORD) Log(STDUSERLOG,(char*)"" don't expand "");
				}
				if (!*choice);
				else if (*choice == '\\'') AddWord2Scan(flags, ReadMeaning(choice+1,true,true),0,0,0); // ignore unneeded quote
				else AddWord2Scan(flags, ReadMeaning(choice,true,true),0,0,0);
			}
			else  if (*control == 'T') // tag and dont follow
			{
				if (trace & TRACE_QUERY  && CheckTopicTrace()) 
				{
					Log(STDUSERLOG,(char*)""\\r\\n"");
					Log(STDTRACETABLOG,(char*)""Tag: %s "",buf);
					if (flags & ORIGINALWORD) Log(STDUSERLOG,(char*)"" don't expand "");
				}
				qMark = saveMark;	//   if we q more later, use this mark by default
				if (*choice) AddWordOnly(flags,choice,0); //   mark and queue item
			}
			else  if (*control == 'e') 
			{
				if (trace & TRACE_QUERY  && CheckTopicTrace()) 
				{
					Log(STDUSERLOG,(char*)""\\r\\n"");
					Log(STDTRACETABLOG,(char*)"" ExpandTag: %s "",buf);
				}
				if (*choice) AddWordOrSet2Scan(flags,choice,0); // tag but dont queue
			}
			else if (*control == '<' || *control == '>') //   chase hierarchy (exclude VERB hierarchy-- we infer on nouns)
			{ //   callArgumentList are:  flowverbs,  queue or mark, 
				char kind = *control; //< or > 
				int flows = baseMark + *++control - '0'; // mark for flow
				unsigned int flag = (*++control == 'q') ? QUEUE : 0;
				if (trace & TRACE_QUERY  && CheckTopicTrace()) 
				{
					if (flag) Log(STDUSERLOG,(char*)"" Tag+Queue Propogate %c "",kind);
					else Log(STDUSERLOG,(char*)"" Tag Propogate %c "",kind);
				}
				// if (flag & QUEUE) flag |= BLOCKMEANING;
				// mark subject 0 and object 2 are nouns, 1 is verb
				if (*choice) ScanHierarchy(ReadMeaning(choice,true,true),saveMark,flows,kind == '<',flag, (mark != 1) ? NOUN : VERB);
			}
			else 
			{
				ReportBug((char*)""bad follow argument %s"",control)
				return 0;
			}
			if (trace & TRACE_QUERY  && CheckTopicTrace()) 
			{
				Log(STDUSERLOG,(char*)""\\r\\n"");
				Log(STDTRACETABLOG,(char*)"""");
			}
		}
		else if (baseFlags & USERFACTS) // transfer over user flags
		{
			unsigned int total = factFree - factLocked;
			if (total >= MAX_QUEUE) total = MAX_QUEUE - 1;
			FACT* F = factFree - total;
			while (++F <= factFree) queue[queueIndex++] = Fact2Index(F);
			baseFlags |= FACTTYPE; 
		}
	}
	inferMark += maxmark - '0';	//   update to use up marks we have involved
	currentFreeInfer = inferMark;
	ignoremark = 0;				//   require be restated if a matching requirement

	//   ZONE 2 - how to use contents of the queue
	//   given items in queue, what field from a queued entry to use facts from 
	if (*control) control = SkipWhitespace(control+1); // skip over the : and past any white space
	if (!strncmp(control,(char*)""queue"",5))  control = SkipWhitespace(control+5);  // just a label defining the field
	if (trace & TRACE_QUERY  && CheckTopicTrace()) 
	{
		char* colon = strchr(control+1,':');
		if (colon) *colon = 0;
		if (control[1]) 
		{
			Log(STDUSERLOG,(char*)""@@@ Control2 queue use: %s\\r\\n"",control+1);
			Log(STDTRACETABLOG,(char*)"""");
		}
		if (colon) *colon = ':';
	}
	if (*control && --control) while (*++control && *control != ':' )
	{
		switch (*control)
		{
		case '_': case '.':  case ' ': // does nothing per se
			continue;
		case 's': 
			baseOffset = 0; 
			break;
		case 'v': 
			baseOffset = 1; 
			break;
		case 'o': 
			baseOffset = 2; 
			break;
		case 'f': 
			baseFlags |= FACTTYPE; 
			break; //   queued items are facts instead of meaning
		case 'e':
			baseOffset = 3;
			break;
		default:
			ReportBug((char*)""Bad control code for #2 (queue test) %s(%s) %s"",C->word,C->w.userValue,control)
			return 0;
		}
	}

	whichset = store;

	//   ZONE 3 - how to detect facts we can return as answers and where they go
	//   set marks to compare on (test criteria for saving an answer)
    /*
    
# third segment (match) tells how to detect facts that match. 
# set tags to compare on (test criteria for saving an answer)
#		q	= use this word label to tag items added to queue
#       	! = next thing (svo) is ignore, not match
#		s/v/o	=  test corresponding subject/verb/object field of fact 
#			Next character gives label to use 0-9 for testing or the letter t means is it a topic name 
#			t = check object to see if it is a topic name (for indexing things by topic). fact store is xxx member ~topicname - make sure VERB fails (like use the propogation verbs)
#		i =	 set ignore tag (for any propogation)
#		< >	= propogate outward from queued item - < means propogate up/left-to-right    > means propogate down/right-to-left (subject)
#			This is followed by
#			1st char is verb tag to follow out
#		~	= stop on intersection 
#			followed by char label to intersect
#		f   = fact must have flag given by match variable
#		>= range above (use propgate field)
#		<= range below (use match field)
#
# Facts that match will either become result facts OR, if this is a riccochet search, will stimulate further processing.
*/
	bool sentences = false;
	bool sentencev = false;
	bool sentenceo = false;
	float rangelow = -20000.0;
	float rangehigh = -20000.0;
	char field = 0;
	unsigned int marks = 0, markv = 0, marko = 0;
	unsigned int markns = 0, marknv = 0, markno = 0;
	unsigned int rmarks = 0, rmarkv = 0, rmarko = 0;
	unsigned int systemFlags = 0;
	unsigned int ultimateSubjectMember = 0;
	unsigned int ultimateVerbMember = 0;
	unsigned int ultimateObjectMember = 0;
	unsigned int factflags = 0;
	saveMark = qMark;	//   default q value is what we used before
	if (*control) control = SkipWhitespace(control+1); // skip over the : and past any white space
	if (!strncmp(control,(char*)""match"",5)) control = SkipWhitespace(control + 5);  // just a comment label defining what the field does
	if (trace & TRACE_QUERY && *control && CheckTopicTrace()) 
	{
		char* colon = strchr(control+1,':');
		if (colon) *colon = 0;
		if (control[1]) 
		{
			Log(STDUSERLOG,(char*)""@@@ Control3 match requirements: %s\\r\\n"",control+1); // if there is data
			Log(STDTRACETABLOG,(char*)"""");
		}
		if (colon) *colon = ':';
	}
	bool noSystemFlag = false;
	if (*control && --control) while (*++control && *control != ':' )
	{
		switch (*control)
		{
		case '_': case '.':  case ' ':  // does nothing per se
			continue;
		case '!': //   do NOT match this
			++control;
			if (*control == 's')  
			{
				if (trace & TRACE_QUERY  && CheckTopicTrace()) Log(STDUSERLOG,(char*)"" don't match subjects #%c "",*control);
				markns = baseMark + (*++control - '0');
			}
			if (*control == 'v')  
			{
				if (trace & TRACE_QUERY  && CheckTopicTrace()) Log(STDUSERLOG,(char*)"" don't match verbs #%c "",*control);
				marknv = baseMark + (*++control - '0');
			}
			if (*control == 'o')  
			{
				if (trace & TRACE_QUERY  && CheckTopicTrace()) Log(STDUSERLOG,(char*)"" don't match objects #%c "",*control);
				markno = baseMark + (*++control - '0');
			}
			if (*control == 'n')
			{
				if (trace & TRACE_QUERY  && CheckTopicTrace()) Log(STDUSERLOG,(char*)"" don't match concepts with noconceptlist marking "");
				noSystemFlag = true;
				systemFlags = NOCONCEPTLIST;
			}
			break;
		case 'x': // field after has sentence mark
			++control;
			if (*control == 's')  sentences = true; 
			else if (*control == 'v')   sentencev = true; 
			else if (*control == 'o')   sentenceo = true; 
			break;

			//   normal tests of fact fields
		case 's': 
			marks = baseMark + (*++control - '0'); 
			if (trace & TRACE_QUERY  && CheckTopicTrace()) Log(STDUSERLOG,(char*)"" subject must be #%c "",*control);
			break;
		case 'v': 
			markv = baseMark + (*++control - '0'); 
			if (trace & TRACE_QUERY  && CheckTopicTrace()) Log(STDUSERLOG,(char*)"" verb must be #%c "",*control);
			break;
		case 'o': 
			marko = baseMark + (*++control - '0'); 
			if (trace & TRACE_QUERY  && CheckTopicTrace()) Log(STDUSERLOG,(char*)"" object must be #%c "",*control);
			break;
			
		//   dont pay attention to this value during search (opposite the baseOffset)
		case 'i': 
			++control;
			if (trace & TRACE_QUERY  && CheckTopicTrace()) Log(STDUSERLOG,(char*)"" ignore results with #%c "",*control);
			ignoremark = (*control == '0') ? 0 : (baseMark + (*control - '0'));
			break;
		//   future queuing uses this mark (hopefully same as original queued)
		case 'q': 
			saveMark = baseMark + (*++control - '0');  
			break;
		case '~': 
			intersectMark = baseMark + (*++control - '0'); //   label to intersect to in propogation
			break;
		case 'n':
			systemFlags |= NOCONCEPTLIST;
			break;
		case 't': 
			baseFlags |= FINDTOPIC;
			break;
		case 'c': 
			baseFlags |= FINDCONCEPT;
			break;
		case '<':  case '>': 
			if (control[1] == '=') // range check
			{
				if (*control == '<')
				{
					rangelow = (float)atof(propogate);
					field = control[2];
				}
				else
				{
					rangehigh = (float)atof(match);
					field = control[2];
				}
				control += 2;
				break;
			}


			if (trace & TRACE_QUERY  && CheckTopicTrace()) Log(STDUSERLOG,(char*)"" propogate on verb #%c "",*control);
			propogateVerb = baseMark + (*++control - '0'); //   label of verbs to propogate on
			break;
		case '@': //   where to put answers (default is store)
			if (trace & TRACE_QUERY  && CheckTopicTrace()) Log(STDUSERLOG,(char*)"" store facts in @%c"",*control);
			whichset = *++control - '0';
			break;
		case '^':
			baseFlags |= UPDICTIONARY;
			break;	// rise up dominant dictionary meaning 
		case 'f': // has this flag from match
			factflags = atoi(match);
			break;
		case 'm': 
			++control;
			if (*control == 'o') ultimateObjectMember = baseMark + (*++control - '0'); 
			else if (*control == 'v') ultimateVerbMember = baseMark + (*++control - '0'); 
			else if (*control == 's') ultimateSubjectMember = baseMark + (*++control - '0'); 
			if (trace & TRACE_QUERY  && CheckTopicTrace()) Log(STDUSERLOG,(char*)"" object must ultimately be member of set marked #%c "",*control);
			break;
		default: 
			ReportBug((char*)""Bad control code for Zone 3 test %s(%s) %s"",C->word,C->w.userValue,control)
			return 0;
		}
	}

	//   ZONE 4- how to migrate around the graph and save new queue entries
	//   now examine riccochet OR other propogation controls (if any)
	//   May say to match another field, and when it matches store X on queue
/*
# fourth segment( walk) how to take matching facts and migrate around the graph and save new queue entries using it instead of returning it as a result.
#	s/o	 =  1st reference to one of these is which field of initial fact provides the riccochet value
#   s/o  =  2nd reference to one of this is given riccochet value, should be it as subject or object of the fact. 
#	S/V/O	= test riccochet fact for corresponding label immediately followed by id 0-9 of test value
*/
	if (*control) control = SkipWhitespace(control+1); // skip over the : and past any white space
	if (!strncmp(control,(char*)""walk"",4)) control = SkipWhitespace(control +4);
	if (trace & TRACE_QUERY && *control && CheckTopicTrace()) 
	{
		char* colon = strchr(control+1,':');
		if (colon) *colon = 0;
		if (control[1]) 
		{
			Log(STDUSERLOG,(char*)""@@@ Control4 riccochet: %s\\r\\n"",control+1);
			Log(STDTRACETABLOG,(char*)"""");
		}
		if (colon) *colon = ':';
	}
	if (*control && --control) while (*++control && *control != '|')
	{
		switch (*control)
		{
		case '_':  case '.': case ' ': // does nothing per se
			continue;
		//   tests on riccochet fields
		case 'S': 
			if (trace & TRACE_QUERY  && CheckTopicTrace()) Log(STDUSERLOG,(char*)""Riccochet on Subject #%c "",*control);
			rmarks = baseMark + (*++control - '0'); 
			break;
		case 'V': 
			if (trace & TRACE_QUERY  && CheckTopicTrace()) Log(STDUSERLOG,(char*)""Riccochet on Verb #%c "",*control);
			rmarkv = baseMark + (*++control - '0'); 
			break;
		case 'O': 
			if (trace & TRACE_QUERY  && CheckTopicTrace()) Log(STDUSERLOG,(char*)""Riccochet on Object #%c "",*control);
			rmarko = baseMark + (*++control - '0'); 
			break;

		//   fields to access as next element from a NORMAL fact - 1st reference is base fact, second is riccochet fact
		case  's': //   MEANING offsets into a fact to get to subject,verb,object
			baseFlags |=  (baseFlags & (USE_ORIGINAL_SUBJECT|USE_ORIGINAL_OBJECT)) ? RICCOCHET_USING_SUBJECT : USE_ORIGINAL_SUBJECT;
			break; 
		case  'v':
			ReportBug((char*)""bad riccochet field"")
			return 0; 
		case  'o': 
			baseFlags |=  (baseFlags & (USE_ORIGINAL_SUBJECT|USE_ORIGINAL_OBJECT)) ? RICCOCHET_USING_OBJECT : USE_ORIGINAL_OBJECT;
			break;
		default: 
			ReportBug((char*)""Bad control code for Zone 4 test %s(%s) %s"",C->word,C->w.userValue,control)
			return 0;
		}
	}
	if (trace & TRACE_QUERY  && CheckTopicTrace()) 
	{
		Log(STDUSERLOG,(char*)""Start processing loop\\r\\n"");
		Log(STDTRACETABLOG,(char*)"""");
	}
	
	//   now perform the query
	FACT* F;
	unsigned int  scanIndex = 0;
	int pStart,pEnd;
	while (scanIndex < queueIndex)
	{
		MEANING next = queue[scanIndex++];
		next &= SIMPLEMEANING; // no type bits, just word ref
        unsigned int index;

		//   get node which has fact list on it
		if (baseFlags & FACTTYPE) // q data is facts
		{
			F = Index2Fact(next);
			if (baseOffset == 0) F = GetSubjectNondeadHead(F);
			else if (baseOffset == 1) F = GetVerbNondeadHead(F);
			else if (baseOffset == 2) F = GetObjectNondeadHead(F);
			index = 0;
		}
		else // q data is meanings
		{
			WORDP D = Meaning2Word((ulong_t)next);
			if (baseOffset == 0) F = GetSubjectNondeadHead(D);
			else if (baseOffset == 1) F = GetVerbNondeadHead(D);
			else  F = GetObjectNondeadHead(D);
			index = Meaning2Index(next);
		}

		bool once = false;
		while (F)
		{
			if (trace & TRACE_QUERY  && CheckTopicTrace()) TraceFact(F, true);

			//   prepare for next fact to walk
			FACT* G = F;

			MEANING INCOMING;
			MEANING OUTGOING;
			// what fields do we process by default
			if (baseOffset == 0) 
			{
				F = GetSubjectNondeadNext(F);
				INCOMING = G->subject;
				OUTGOING = G->object;
			}
			else if (baseOffset == 1)  
			{
				F = GetVerbNondeadNext(F);
				INCOMING = G->verb;
				OUTGOING = G->object;
			}
			else if (baseOffset == 2)
			{
				F = GetObjectNondeadNext(F);
				INCOMING = G->object;
				OUTGOING = G->subject;
			}
			else // baseOffset == 3 when using user facts as the initial base
			{
				INCOMING = G->subject;
				OUTGOING = G->object;
			}
			if (G->flags & FACTDEAD) continue;	 // cannot use this
			if (baseFlags & USERFACTS && G <= factLocked) continue; // restricted by kind of fact
			if (baseFlags & SYSTEMFACTS && G > factLocked) continue;

			INCOMING &= SIMPLEMEANING;
			OUTGOING &= SIMPLEMEANING;
			//   is this fact based on what we were checking for? (we store all specific instances on the general dictionary)
			if (index && INCOMING != next) continue;
			WORDP OTHER = Meaning2Word(OUTGOING);

			WORDP S = (G->flags & FACTSUBJECT) ? fact : Meaning2Word(G->subject);
			WORDP V = (G->flags & FACTVERB) ? fact : Meaning2Word(G->verb);
			WORDP O = (G->flags & FACTOBJECT) ? fact : Meaning2Word(G->object);

			//   if this is part of ignore set, ignore it (not good if came via verb BUG)
			if (ignoremark && OTHER->inferMark == ignoremark ) 
			{
				if (trace & TRACE_QUERY  && CheckTopicTrace()) Log(STDUSERLOG,(char*)""ignore "");
				continue;
			}
			// pay no attention to topic facts
			if (baseFlags & NOTOPIC && O->internalBits & TOPIC)
			{
				if (trace & TRACE_QUERY  && CheckTopicTrace()) Log(STDUSERLOG,(char*)""notopic "");
				continue;
			}
			
			bool match = true;
			if (trace & TRACE_QUERY  && CheckTopicTrace())
			{
				Log(STDUSERLOG, (char*)""(%d %d %d) => (%d %d %d)\\r\\n"", marks, markv, marko, S->inferMark, V->inferMark, O->inferMark);
				Log(STDTRACETABLOG, (char*)"""");
			}
			// follow dictionary path?
			if (baseFlags & UPDICTIONARY && G->verb == Mis && !once)
			{
				once = true;
				if (AddWord2Scan(QUEUE,OUTGOING,INCOMING,0,0)){;} // add object onto queue
				continue;
			}

			//   field validation fails on some field?
			if (marks && S->inferMark != marks)  match = false;
			else if (markns && S->inferMark == markns)  match = false;
			if (markv && V->inferMark != markv) match = false;
			else if (marknv && V->inferMark == marknv)  match = false;
			if (marko && O->inferMark != marko)  match = false;
			else if (markno && O->inferMark == markno)  match = false;
			if (sentences && !GetNextSpot(S,0,pStart,pEnd)) match = false;
			if (sentencev && !GetNextSpot(V,0,pStart,pEnd)) match = false;
			if (sentenceo && !GetNextSpot(O,0,pStart,pEnd)) match = false;
			if (rangelow != -20000.0)
			{
				float val;
				char* word = NULL;
				if (field == 's') word = S->word;
				else if (field == 'v') word = V->word;
				else if (field == 'o') word = O->word;
				if (word && IsDigit(word[0]))
				{
					val = (float)atof(word);
					if (val < rangelow) match = false;
				}
			}
			if (rangehigh != -20000.0)
			{
				float val;
				char* word = NULL;
				if (field == 's') word = S->word;
				else if (field == 'v') word = V->word;
				else if (field == 'o') word = O->word;
				if (word && IsDigit(word[0]))
				{
					val = (float)atof(word);
					if (val > rangehigh) match = false;
				}
			}

			if (factflags && !(G->flags & factflags)) 
				match = false; // lacks appropriate fact flags
			if (intersectMark && OTHER->inferMark != intersectMark) match = false;// we have not reached requested intersection
			if (ultimateSubjectMember && !(ConceptPropogateTest(G->object,ultimateSubjectMember,0))) match = false;	 // object is not a member of designated set
			if (ultimateVerbMember && !(ConceptPropogateTest(G->object,ultimateVerbMember,0))) match = false;	 // object is not a member of designated set
			if (ultimateObjectMember && !(ConceptPropogateTest(G->object,ultimateObjectMember,0))) match = false;	 // object is not a member of designated set
			if (systemFlags && match && !noSystemFlag)
			{
				if (!(OTHER->systemFlags & systemFlags)) match = false;	// dont go here
			}
			else if (systemFlags && match && noSystemFlag)
			{
				if (OTHER->systemFlags & systemFlags) match = false;	// dont go here
			}

			//   if search is riccochet, we now walk facts of riccochet target
			if (match && baseFlags & RICCOCHET_BITS )
			{
				if (!Riccochet(baseFlags,G,whichset,count,rmarks,rmarkv,rmarko))
				{
					scanIndex = queueIndex; //   end outer loop 
					F = NULL;
				}
			} // end riccochet
			else if (match && !(G->flags & MARKED_FACT) && !(baseFlags & (FINDTOPIC | FINDCONCEPT))) //   find unique fact -- it was not rejected by anything
			{
				G->flags |= MARKED_FACT;
				AddFact(whichset,G);
				if (trace & TRACE_QUERY && CheckTopicTrace() ) 
				{
					Log(STDUSERLOG,(char*)""    Found:"");
					TraceFact(G);
				}
				if (FACTSET_COUNT(whichset) >= count) 
				{
					scanIndex = queueIndex; //   end outer loop 
					F = NULL;
					break;
				}
				if (count == 1 && intersectMark) // create backtract in next set
				{
					int set1 = whichset + 1;
					if (set1 > MAX_FIND_SETS) set1 = 0;	// wrap around end
					WORDP D = Meaning2Word(INCOMING);
					unsigned int count = 0;
					while (D)
					{
						factSet[set1][++count] = CreateFact(INCOMING,MakeMeaning(D),OUTGOING,FACTTRANSIENT);
						D = Meaning2Word(GetFactBack(D));
						OUTGOING = INCOMING;
						INCOMING = MakeMeaning(D);
					}
					SET_FACTSET_COUNT(set1,count);
				}

				continue; // saved fact cannot be used to scan farther out. ineffient and q save tramples infermark
			}

			//   if propogation is enabled, queue appropriate choices
			if (match && baseFlags & FINDTOPIC && OTHER->internalBits & TOPIC) // supposed to find a topic
			{
				if (trace & TRACE_QUERY  && CheckTopicTrace()) 
				{
					Log(STDUSERLOG,(char*)""\\r\\n propogate "");
					Log(STDTRACETABLOG,(char*)"""");
				}
				AddFact(whichset,G); 
				if (trace & TRACE_QUERY  && CheckTopicTrace()) 
				{
					Log(STDUSERLOG,(char*)""    Found:"");
					TraceFact(G);
				}
				if (FACTSET_COUNT(whichset) >= count) 
				{
					scanIndex = queueIndex; //   end outer loop 
					F = NULL;
					break;
				}
				if (G->flags & MARKED_FACT) {;} // stored this fact, stop propogation
				else if (AddWord2Scan(QUEUE,OUTGOING,INCOMING,0,0)) SetFactBack(OTHER,INCOMING);  // add object onto queue and provide traceback
				G->flags |= MARKED_FACT;
			}
			else if (match && baseFlags & FINDCONCEPT && OTHER->internalBits & CONCEPT && !(OTHER->internalBits & TOPIC)) // supposed to find a concept
			{
				if (trace & TRACE_QUERY  && CheckTopicTrace()) 
				{
					Log(STDUSERLOG,(char*)""\\r\\n propogate "");
					Log(STDTRACETABLOG,(char*)"""");
				}
				AddFact(whichset,G); 
				if (trace & TRACE_QUERY  && CheckTopicTrace()) 
				{
					Log(STDUSERLOG,(char*)""    Found:"");
					TraceFact(G);
				}
				if (FACTSET_COUNT(whichset) >= count) 
				{
					scanIndex = queueIndex; //   end outer loop 
					F = NULL;
					break;
				}
				if (G->flags & MARKED_FACT) {;} // stored this fact, stop propogation
				else if (AddWord2Scan(QUEUE,OUTGOING,INCOMING,0,0)) SetFactBack(OTHER,INCOMING);  // add object onto queue and provide traceback
			}

            if (propogateVerb && V->inferMark == propogateVerb) // this is not a fact to check, this is a fact to propogate on
            {
                if (trace & TRACE_QUERY  && CheckTopicTrace())
                {
                    Log(STDUSERLOG, (char*)""\\r\\n propogate %s"", Meaning2Word(OUTGOING)->word);
                    Log(STDTRACETABLOG, (char*)"""");
                }
                if (AddWord2Scan(QUEUE, OUTGOING, INCOMING, 0, 0)) SetFactBack(OTHER, INCOMING);  // add object onto queue and provide traceback
                if (trace & TRACE_QUERY  && CheckTopicTrace())
                {
                    Log(STDUSERLOG, (char*)""\\r\\n"");
                    Log(STDTRACETABLOG, (char*)"""");
                }
            }
            if (baseOffset == 3) break; // resume with next fact in q rather than any chaining
		} // end loop on facts
	} // end loop on scan queue
	
	//   clear marks for duplicates
	unsigned int counter = FACTSET_COUNT(whichset);
	for (unsigned int i = 1; i <= counter; ++i) factSet[whichset][i]->flags &= -1 ^ MARKED_FACT;
	factSetNext[store] = 0;
    if (trace & TRACE_QUERY && CheckTopicTrace()) 
	{
		char word[MAX_WORD_SIZE];
		if (counter) Log(STDTRACETABLOG,(char*)"" result: @%d[%d] e.g. %s\\r\\n"",whichset,counter,WriteFact(factSet[whichset][1],false,word));
		else Log(STDTRACETABLOG,(char*)"" result: @%d none found \\r\\n"",whichset);
		Log(STDTRACETABLOG,(char*)"""");
	}
	ClearBacktracks();

	if (*control++ == '|') goto nextsearch; //   chained search, do the next
	return counter;
}
",16170,True,3293.985284521358,median
"= v1beta1.MutatingWebhookConfiguration
{product-author}
{product-version}
:data-uri:
:icons:
:toc: macro
:toc-title:
:toclevels: 2

toc::[]

== Description
[%hardbreaks]
MutatingWebhookConfiguration describes the configuration of and admission webhook that accept or reject and may change the object.

== 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 metadata; More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata."">metadata</span>:
</summary><details><summary>  <span title=""(object) Annotations is an unstructured key value map stored with a resource that may be set by external tools to store and retrieve arbitrary metadata. They are not queryable and should be preserved when modifying objects. More info: http://kubernetes.io/docs/user-guide/annotations"">annotations</span>:
</summary><div style=""margin-left:13px;"">    <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) The name of the cluster which the object belongs to. This is used to distinguish resources with same name and namespace in different clusters. This field is not set anywhere right now and apiserver is going to ignore it if set in create or update request."">clusterName</span>:
</div><div style=""margin-left:13px;"">  <span title=""(v1.Time) CreationTimestamp is a timestamp representing the server time when this object was created. It is not guaranteed to be set in happens-before order across separate operations. Clients may not set this value. It is represented in RFC3339 form and is in UTC.

Populated by the system. Read-only. Null for lists. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata"">creationTimestamp</span>:
</div><div style=""margin-left:13px;"">  <span title=""(integer) Number of seconds allowed for this object to gracefully terminate before it will be removed from the system. Only set when deletionTimestamp is also set. May only be shortened. Read-only."">deletionGracePeriodSeconds</span>:
</div><div style=""margin-left:13px;"">  <span title=""(v1.Time) DeletionTimestamp is RFC 3339 date and time at which this resource will be deleted. This field is set by the server when a graceful deletion is requested by the user, and is not directly settable by a client. The resource is expected to be deleted (no longer visible from resource lists, and not reachable by name) after the time in this field, once the finalizers list is empty. As long as the finalizers list contains items, deletion is blocked. Once the deletionTimestamp is set, this value may not be unset or be set further into the future, although it may be shortened or the resource may be deleted prior to this time. For example, a user may request that a pod is deleted in 30 seconds. The Kubelet will react by sending a graceful termination signal to the containers in the pod. After that 30 seconds, the Kubelet will send a hard termination signal (SIGKILL) to the container and after cleanup, remove the pod from the API. In the presence of network partitions, this object may still exist after this timestamp, until an administrator or automated process can determine the resource is fully terminated. If not set, graceful deletion of the object has not been requested.

Populated by the system when a graceful deletion is requested. Read-only. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#metadata"">deletionTimestamp</span>:
</div><details><summary>  <span title=""(array) Must be empty before the object is deleted from the registry. Each entry is an identifier for the responsible component that will remove the entry from the list. If the deletionTimestamp of the object is non-nil, entries in this list can only be removed."">finalizers</span>:
</summary><div style=""margin-left:13px;"">  - <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) GenerateName is an optional prefix, used by the server, to generate a unique name ONLY IF the Name field has not been provided. If this field is used, the name returned to the client will be different than the name passed. This value will also be combined with a unique suffix. The provided value has the same validation rules as the Name field, and may be truncated by the length of the suffix required to make the value unique on the server.

If this field is specified and the generated name exists, the server will NOT return a 409 - instead, it will either return 201 Created or 500 with Reason ServerTimeout indicating a unique name could not be found in the time allotted, and the client should retry (optionally after the time indicated in the Retry-After header).

Applied only if Name is not specified. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#idempotency"">generateName</span>:
</div><div style=""margin-left:13px;"">  <span title=""(integer) A sequence number representing a specific generation of the desired state. Populated by the system. Read-only."">generation</span>:
</div><details><summary>  <span title=""(v1.Initializers) An initializer is a controller which enforces some system invariant at object creation time. This field is a list of initializers that have not yet acted on this object. If nil or empty, this object has been completely initialized. Otherwise, the object is considered uninitialized and is hidden (in list/watch and get calls) from clients that haven&#39;t explicitly asked to observe uninitialized objects.

When an object is created, the system will populate this list with the current set of initializers. Only privileged users may set or modify this list. Once it is empty, it may not be modified further by any user."">initializers</span>:
</summary><details><summary>    <span title=""(array) Pending is a list of initializers that must execute in order before this object is visible. When the last pending initializer is removed, and no failing result is set, the initializers struct will be set to nil and the object is considered as initialized and visible to all clients."">pending</span>:
</summary><div style=""margin-left:13px;"">    - <span title=""(string) name of the process that is responsible for initializing this object."">name</span>:
</div></details><details><summary>    <span title=""(v1.Status) If result is set with the Failure field, the object will be persisted to storage and then deleted, ensuring that other clients can observe the deletion."">result</span>:
</summary><div style=""margin-left:13px;"">      <span title=""(string) APIVersion defines the versioned schema of this representation of an object. Servers should convert recognized schemas to the latest internal value, and may reject unrecognized values. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#resources"">apiVersion</span>:
</div><div style=""margin-left:13px;"">      <span title=""(integer) Suggested HTTP return code for this status, 0 if not set."">code</span>:
</div><details><summary>      <span title=""(v1.StatusDetails) Extended data associated with the reason.  Each reason may define its own extended details. This field is optional and the data returned is not guaranteed to conform to any schema except that defined by the reason type."">details</span>:
</summary><details><summary>        <span title=""(array) The Causes array includes more details associated with the StatusReason failure. Not all StatusReasons may provide detailed causes."">causes</span>:
</summary><div style=""margin-left:13px;"">        - <span title=""(string) The field of the resource that has caused this error, as named by its JSON serialization. May include dot and postfix notation for nested attributes. Arrays are zero-indexed.  Fields may appear more than once in an array of causes due to fields having multiple errors. Optional.

Examples:
  &#34;name&#34; - the field &#34;name&#34; on the current resource
  &#34;items[0].name&#34; - the field &#34;name&#34; on the first array entry in &#34;items&#34;"">field</span>:
</div><div style=""margin-left:13px;"">          <span title=""(string) A human-readable description of the cause of the error.  This field may be presented as-is to a reader."">message</span>:
</div><div style=""margin-left:13px;"">          <span title=""(string) A machine-readable description of the cause of the error. If this value is empty there is no information available."">reason</span>:
</div></details><div style=""margin-left:13px;"">        <span title=""(string) The group attribute of the resource associated with the status StatusReason."">group</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) The kind attribute of the resource associated with the status StatusReason. On some operations may differ from the requested resource Kind. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) The name attribute of the resource associated with the status StatusReason (when there is a single name which can be described)."">name</span>:
</div><div style=""margin-left:13px;"">        <span title=""(integer) If specified, the time in seconds before the operation should be retried. Some errors may indicate the client must take an alternate action - for those errors this field may indicate how long to wait before taking the alternate action."">retryAfterSeconds</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) UID of the resource. (when there is a single resource which can be described). More info: http://kubernetes.io/docs/user-guide/identifiers#uids"">uid</span>:
</div></details><div style=""margin-left:13px;"">      <span title=""(string) Kind is a string value representing the REST resource this object represents. Servers may infer this from the endpoint the client submits requests to. Cannot be updated. In CamelCase. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><div style=""margin-left:13px;"">      <span title=""(string) A human-readable description of the status of this operation."">message</span>:
</div><details><summary>      <span title=""(v1.ListMeta) Standard list metadata. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">metadata</span>:
</summary><div style=""margin-left:13px;"">        <span title=""(string) continue may be set if the user set a limit on the number of items returned, and indicates that the server has more data available. The value is opaque and may be used to issue another request to the endpoint that served this list to retrieve the next set of available objects. Continuing a list may not be possible if the server configuration has changed or more than a few minutes have passed. The resourceVersion field returned when using this continue value will be identical to the value in the first response."">continue</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) String that identifies the server&#39;s internal version of this object that can be used by clients to determine when objects have changed. Value must be treated as opaque by clients and passed unmodified back to the server. Populated by the system. Read-only. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#concurrency-control-and-consistency"">resourceVersion</span>:
</div><div style=""margin-left:13px;"">        <span title=""(string) selfLink is a URL representing this object. Populated by the system. Read-only."">selfLink</span>:
</div></details><div style=""margin-left:13px;"">      <span title=""(string) A machine-readable description of why this operation is in the &#34;Failure&#34; status. If this value is empty there is no information available. A Reason clarifies an HTTP status code but does not override it."">reason</span>:
</div><div style=""margin-left:13px;"">      <span title=""(string) Status of the operation. One of: &#34;Success&#34; or &#34;Failure&#34;. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#spec-and-status"">status</span>:
</div></details></details><details><summary>  <span title=""(object) Map of string keys and values that can be used to organize and categorize (scope and select) objects. May match selectors of replication controllers and services. More info: http://kubernetes.io/docs/user-guide/labels"">labels</span>:
</summary><div style=""margin-left:13px;"">    <span title=""(string)"">[string]</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) Name must be unique within a namespace. Is required when creating resources, although some resources may allow a client to request the generation of an appropriate name automatically. Name is primarily intended for creation idempotence and configuration definition. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/identifiers#names"">name</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) Namespace defines the space within each name must be unique. An empty namespace is equivalent to the &#34;default&#34; namespace, but &#34;default&#34; is the canonical representation. Not all objects are required to be scoped to a namespace - the value of this field for those objects will be empty.

Must be a DNS_LABEL. Cannot be updated. More info: http://kubernetes.io/docs/user-guide/namespaces"">namespace</span>:
</div><details><summary>  <span title=""(array) List of objects depended by this object. If ALL objects in the list have been deleted, this object will be garbage collected. If this object is managed by a controller, then an entry in this list will point to this controller, with the controller field set to true. There cannot be more than one managing controller."">ownerReferences</span>:
</summary><div style=""margin-left:13px;"">  - <span title=""(string) API version of the referent."">apiVersion</span>:
</div><div style=""margin-left:13px;"">    <span title=""(boolean) If true, AND if the owner has the &#34;foregroundDeletion&#34; finalizer, then the owner cannot be deleted from the key-value store until this reference is removed. Defaults to false. To set this field, a user needs &#34;delete&#34; permission of the owner, otherwise 422 (Unprocessable Entity) will be returned."">blockOwnerDeletion</span>:
</div><div style=""margin-left:13px;"">    <span title=""(boolean) If true, this reference points to the managing controller."">controller</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) Kind of the referent. More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#types-kinds"">kind</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) Name of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#names"">name</span>:
</div><div style=""margin-left:13px;"">    <span title=""(string) UID of the referent. More info: http://kubernetes.io/docs/user-guide/identifiers#uids"">uid</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) An opaque value that represents the internal version of this object that can be used by clients to determine when objects have changed. May be used for optimistic concurrency, change detection, and the watch operation on a resource or set of resources. Clients must treat these values as opaque and passed unmodified back to the server. They may only be valid for a particular resource or set of resources.

Populated by the system. Read-only. Value must be treated as opaque by clients and . More info: https://git.k8s.io/community/contributors/devel/api-conventions.md#concurrency-control-and-consistency"">resourceVersion</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) SelfLink is a URL representing this object. Populated by the system. Read-only."">selfLink</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) UID is the unique in time and space value for this object. It is typically generated by the server on successful creation of a resource and is not allowed to change on PUT operations.

Populated by the system. Read-only. More info: http://kubernetes.io/docs/user-guide/identifiers#uids"">uid</span>:
</div></details><details><summary><span title=""(array) Webhooks is a list of webhooks and the affected resources and operations."">webhooks</span>:
</summary><details><summary>- <span title=""(v1beta1.WebhookClientConfig) ClientConfig defines how to communicate with the hook. Required"">clientConfig</span>:
</summary><div style=""margin-left:13px;"">-   <span title=""(string) `caBundle` is a PEM encoded CA bundle which will be used to validate the webhook&#39;s server certificate. Required."">caBundle</span>:
</div><details><summary>    <span title=""(v1beta1.ServiceReference) `service` is a reference to the service for this webhook. Either `service` or `url` must be specified.

If the webhook is running within the cluster, then you should use `service`.

If there is only one port open for the service, that port will be used. If there are multiple ports open, port 443 will be used if it is open, otherwise it is an error."">service</span>:
</summary><div style=""margin-left:13px;"">      <span title=""(string) `name` is the name of the service. Required"">name</span>:
</div><div style=""margin-left:13px;"">      <span title=""(string) `namespace` is the namespace of the service. Required"">namespace</span>:
</div><div style=""margin-left:13px;"">      <span title=""(string) `path` is an optional URL path which will be sent in any request to this service."">path</span>:
</div></details><div style=""margin-left:13px;"">    <span title=""(string) `url` gives the location of the webhook, in standard URL form (`[scheme://]host:port/path`). Exactly one of `url` or `service` must be specified.

The `host` should not refer to a service running in the cluster; use the `service` field instead. The host might be resolved via external DNS in some apiservers (e.g., `kube-apiserver` cannot resolve in-cluster DNS as that would be a layering violation). `host` may also be an IP address.

Please note that using `localhost` or `127.0.0.1` as a `host` is risky unless you take great care to run this webhook on all hosts which run an apiserver which might need to make calls to this webhook. Such installs are likely to be non-portable, i.e., not easy to turn up in a new cluster.

The scheme must be &#34;https&#34;; the URL must begin with &#34;https://&#34;.

A path is optional, and if present may be any string permissible in a URL. You may use the path to pass an arbitrary string to the webhook, for example, a cluster identifier.

Attempting to use a user or basic auth e.g. &#34;user:password@&#34; is not allowed. Fragments (&#34;#...&#34;) and query parameters (&#34;?...&#34;) are not allowed, either."">url</span>:
</div></details><div style=""margin-left:13px;"">  <span title=""(string) FailurePolicy defines how unrecognized errors from the admission endpoint are handled - allowed values are Ignore or Fail. Defaults to Ignore."">failurePolicy</span>:
</div><div style=""margin-left:13px;"">  <span title=""(string) The name of the admission webhook. Name should be fully qualified, e.g., imagepolicy.kubernetes.io, where &#34;imagepolicy&#34; is the name of the webhook, and kubernetes.io is the name of the organization. Required."">name</span>:
</div><details><summary>  <span title=""(v1.LabelSelector) NamespaceSelector decides whether to run the webhook on an object based on whether the namespace for that object matches the selector. If the object itself is a namespace, the matching is performed on object.metadata.labels. If the object is other cluster scoped resource, it is not subjected to the webhook.

For example, to run the webhook on any objects whose namespace is not associated with &#34;runlevel&#34; of &#34;0&#34; or &#34;1&#34;;  you will set the selector as follows: &#34;namespaceSelector&#34;: {
  &#34;matchExpressions&#34;: [
    {
      &#34;key&#34;: &#34;runlevel&#34;,
      &#34;operator&#34;: &#34;NotIn&#34;,
      &#34;values&#34;: [
        &#34;0&#34;,
        &#34;1&#34;
      ]
    }
  ]
}

If instead you want to only run the webhook on any objects whose namespace is associated with the &#34;environment&#34; of &#34;prod&#34; or &#34;staging&#34;; you will set the selector as follows: &#34;namespaceSelector&#34;: {
  &#34;matchExpressions&#34;: [
    {
      &#34;key&#34;: &#34;environment&#34;,
      &#34;operator&#34;: &#34;In&#34;,
      &#34;values&#34;: [
        &#34;prod&#34;,
        &#34;staging&#34;
      ]
    }
  ]
}

See https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/ for more examples of label selectors.

Default to the empty LabelSelector, which matches everything."">namespaceSelector</span>:
</summary><details><summary>    <span title=""(array) matchExpressions is a list of label selector requirements. The requirements are ANDed."">matchExpressions</span>:
</summary><div style=""margin-left:13px;"">    - <span title=""(string) key is the label key that the selector applies to."">key</span>:
</div><div style=""margin-left:13px;"">      <span title=""(string) operator represents a key&#39;s relationship to a set of values. Valid operators are In, NotIn, Exists and DoesNotExist."">operator</span>:
</div><details><summary>      <span title=""(array) values is an array of string values. If the operator is In or NotIn, the values array must be non-empty. If the operator is Exists or DoesNotExist, the values array must be empty. This array is replaced during a strategic merge patch."">values</span>:
</summary><div style=""margin-left:13px;"">      - <span title=""(string)"">[string]</span>:
</div></details></details><details><summary>    <span title=""(object) matchLabels is a map of {key,value} pairs. A single {key,value} in the matchLabels map is equivalent to an element of matchExpressions, whose key field is &#34;key&#34;, the operator is &#34;In&#34;, and the values array contains only &#34;value&#34;. The requirements are ANDed."">matchLabels</span>:
</summary><div style=""margin-left:13px;"">      <span title=""(string)"">[string]</span>:
</div></details></details><details><summary>  <span title=""(array) Rules describes what operations on what resources/subresources the webhook cares about. The webhook cares about an operation if it matches _any_ Rule."">rules</span>:
</summary><details><summary>  - <span title=""(array) APIGroups is the API groups the resources belong to. &#39;*&#39; is all groups. If &#39;*&#39; is present, the length of the slice must be one. Required."">apiGroups</span>:
</summary><div style=""margin-left:13px;"">  - - <span title=""(string)"">[string]</span>:
</div></details><details><summary>    <span title=""(array) APIVersions is the API versions the resources belong to. &#39;*&#39; is all versions. If &#39;*&#39; is present, the length of the slice must be one. Required."">apiVersions</span>:
</summary><div style=""margin-left:13px;"">    - <span title=""(string)"">[string]</span>:
</div></details><details><summary>    <span title=""(array) Operations is the operations the admission hook cares about - CREATE, UPDATE, or * for all operations. If &#39;*&#39; is present, the length of the slice must be one. Required."">operations</span>:
</summary><div style=""margin-left:13px;"">    - <span title=""(string)"">[string]</span>:
</div></details><details><summary>    <span title=""(array) Resources is a list of resources this rule applies to.

For example: &#39;pods&#39; means pods. &#39;pods/log&#39; means the log subresource of pods. &#39;*&#39; means all resources, but not subresources. &#39;pods/*&#39; means all subresources of pods. &#39;*/scale&#39; means all scale subresources. &#39;*/*&#39; means all resources and their subresources.

If wildcard is present, the validation rule will ensure resources do not overlap with each other.

Depending on the enclosing object, subresources might not be allowed. Required."">resources</span>:
</summary><div style=""margin-left:13px;"">    - <span title=""(string)"">[string]</span>:
</div></details></details></details>
</pre>
++++

== Operations

[[Post-apis-admissionregistration.k8s.io-v1beta1-mutatingwebhookconfigurations]]
=== Create a MutatingWebhookConfiguration
Create a MutatingWebhookConfiguration

==== HTTP request
----
POST /apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json'

{
  ""kind"": ""MutatingWebhookConfiguration"",
  ""apiVersion"": ""admissionregistration.k8s.io/v1beta1"",
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X POST \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json' \\
    https://$ENDPOINT/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations <<'EOF'
{
  ""kind"": ""MutatingWebhookConfiguration"",
  ""apiVersion"": ""admissionregistration.k8s.io/v1beta1"",
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1beta1.MutatingWebhookConfiguration
|===

==== 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|v1beta1.MutatingWebhookConfiguration
|201 Created|v1beta1.MutatingWebhookConfiguration
|202 Accepted|v1beta1.MutatingWebhookConfiguration
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Get-apis-admissionregistration.k8s.io-v1beta1-mutatingwebhookconfigurations-name]]
=== Get a MutatingWebhookConfiguration
Read the specified MutatingWebhookConfiguration

==== HTTP request
----
GET /apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations/$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/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations/$NAME
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the MutatingWebhookConfiguration
|===

==== 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|v1beta1.MutatingWebhookConfiguration
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Get-apis-admissionregistration.k8s.io-v1beta1-mutatingwebhookconfigurations]]
=== Get all MutatingWebhookConfigurations
List or watch objects of kind MutatingWebhookConfiguration

==== HTTP request
----
GET /apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations 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/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations
----

==== 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|v1beta1.MutatingWebhookConfigurationList
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf
* application/json;stream=watch
* application/vnd.kubernetes.protobuf;stream=watch


[[Get-apis-admissionregistration.k8s.io-v1beta1-watch-mutatingwebhookconfigurations-name]]
=== Watch a MutatingWebhookConfiguration
Watch changes to an object of kind MutatingWebhookConfiguration

==== HTTP request
----
GET /apis/admissionregistration.k8s.io/v1beta1/watch/mutatingwebhookconfigurations/$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/admissionregistration.k8s.io/v1beta1/watch/mutatingwebhookconfigurations/$NAME
----

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the MutatingWebhookConfiguration
|===

==== 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-admissionregistration.k8s.io-v1beta1-watch-mutatingwebhookconfigurations]]
=== Watch all MutatingWebhookConfigurations
Watch individual changes to a list of MutatingWebhookConfiguration

==== HTTP request
----
GET /apis/admissionregistration.k8s.io/v1beta1/watch/mutatingwebhookconfigurations 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/admissionregistration.k8s.io/v1beta1/watch/mutatingwebhookconfigurations
----

==== 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-admissionregistration.k8s.io-v1beta1-mutatingwebhookconfigurations-name]]
=== Update a MutatingWebhookConfiguration
Replace the specified MutatingWebhookConfiguration

==== HTTP request
----
PUT /apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations/$NAME HTTP/1.1
Authorization: Bearer $TOKEN
Accept: application/json
Connection: close
Content-Type: application/json'

{
  ""kind"": ""MutatingWebhookConfiguration"",
  ""apiVersion"": ""admissionregistration.k8s.io/v1beta1"",
  ...
}

----

==== Curl request
----
$ curl -k \\
    -X PUT \\
    -d @- \\
    -H ""Authorization: Bearer $TOKEN"" \\
    -H 'Accept: application/json' \\
    -H 'Content-Type: application/json' \\
    https://$ENDPOINT/apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations/$NAME <<'EOF'
{
  ""kind"": ""MutatingWebhookConfiguration"",
  ""apiVersion"": ""admissionregistration.k8s.io/v1beta1"",
  ...
}
EOF
----

==== HTTP body
[cols=""1,5"", options=""header""]
|===
|Parameter|Schema
|body|v1beta1.MutatingWebhookConfiguration
|===

==== Path parameters
[cols=""1,5"", options=""header""]
|===
|Parameter|Description
|name|name of the MutatingWebhookConfiguration
|===

==== 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|v1beta1.MutatingWebhookConfiguration
|201 Created|v1beta1.MutatingWebhookConfiguration
|401 Unauthorized|
|===

==== Consumes

* \\*/*

==== Produces

* application/json
* application/yaml
* application/vnd.kubernetes.protobuf


[[Patch-apis-admissionregistration.k8s.io-v1beta1-mutatingwebhookconfigurations-name]]
=== Patch a MutatingWebhookConfiguration
Partially update the specified MutatingWebhookConfiguration

==== HTTP request
----
PATCH /apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations/$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/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations/$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 MutatingWebhookConfiguration
|===

==== 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|v1beta1.MutatingWebhookConfiguration
|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-admissionregistration.k8s.io-v1beta1-mutatingwebhookconfigurations-name]]
=== Delete a MutatingWebhookConfiguration
Delete a MutatingWebhookConfiguration

==== HTTP request
----
DELETE /apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations/$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/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations/$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 MutatingWebhookConfiguration
|===

==== 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-admissionregistration.k8s.io-v1beta1-mutatingwebhookconfigurations]]
=== Delete all MutatingWebhookConfigurations
Delete collection of MutatingWebhookConfiguration

==== HTTP request
----
DELETE /apis/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations 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/admissionregistration.k8s.io/v1beta1/mutatingwebhookconfigurations
----

==== 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



",12081,False,2046.2291818138024,median
"#define pointcount 948
uint8_t const PROGMEM data[pointcount][2]=
{{40,76},
{40,76},
{42,71},
{45,66},
{49,62},
{53,59},
{97,27},
{88,48},
{40,76},
{40,76},
{47,135},
{47,135},
{39,142},
{54,97},
{56,92},
{58,89},
{63,85},
{63,84},
{62,82},
{61,82},
{60,82},
{58,83},
{55,86},
{52,91},
{50,95},
{33,146},
{18,159},
{39,92},
{42,86},
{44,82},
{47,79},
{51,75},
{56,72},
{77,59},
{86,54},
{66,110},
{47,135},
{47,135},
{78,143},
{78,143},
{80,142},
{81,142},
{82,142},
{84,143},
{85,145},
{85,147},
{84,148},
{82,149},
{81,150},
{79,149},
{78,148},
{77,147},
{77,146},
{77,144},
{78,143},
{78,143},
{90,142},
{90,142},
{88,142},
{86,142},
{85,141},
{84,139},
{84,138},
{85,136},
{86,135},
{87,134},
{88,134},
{90,135},
{91,136},
{92,137},
{92,139},
{91,141},
{90,142},
{90,142},
{88,135},
{88,135},
{88,135},
{88,135},
{88,135},
{88,135},
{102,136},
{102,136},
{101,136},
{103,134},
{100,131},
{100,131},
{98,133},
{97,132},
{98,129},
{98,129},
{94,127},
{92,130},
{91,130},
{91,130},
{90,127},
{86,127},
{86,130},
{85,130},
{83,127},
{79,129},
{80,132},
{80,132},
{79,133},
{76,131},
{74,134},
{74,134},
{75,136},
{75,136},
{75,137},
{72,136},
{72,136},
{70,140},
{73,142},
{73,143},
{70,144},
{70,144},
{70,148},
{70,148},
{73,148},
{73,149},
{70,151},
{72,155},
{75,154},
{76,155},
{76,155},
{75,155},
{75,155},
{110,130},
{110,130},
{126,142},
{126,182},
{126,182},
{105,163},
{105,163},
{105,163},
{105,163},
{105,163},
{105,163},
{104,163},
{100,165},
{97,166},
{93,167},
{86,170},
{79,173},
{76,174},
{73,175},
{69,177},
{66,178},
{62,179},
{59,181},
{57,181},
{55,182},
{53,183},
{52,183},
{50,184},
{48,185},
{46,185},
{45,186},
{43,187},
{41,187},
{40,188},
{38,189},
{36,189},
{34,190},
{33,191},
{31,192},
{31,192},
{30,192},
{30,192},
{30,192},
{29,192},
{29,192},
{29,192},
{28,193},
{28,193},
{28,193},
{28,193},
{27,193},
{27,193},
{27,193},
{26,193},
{26,193},
{26,193},
{25,193},
{25,193},
{25,193},
{25,193},
{24,194},
{24,194},
{24,194},
{24,194},
{24,194},
{24,194},
{24,194},
{23,194},
{23,194},
{23,194},
{23,194},
{23,194},
{23,194},
{23,194},
{23,194},
{23,194},
{23,194},
{22,194},
{22,194},
{22,194},
{22,194},
{22,194},
{22,194},
{22,194},
{22,194},
{22,194},
{22,194},
{22,194},
{22,194},
{22,194},
{22,194},
{21,194},
{21,194},
{21,194},
{21,194},
{21,194},
{21,194},
{21,194},
{21,194},
{21,194},
{21,194},
{21,194},
{110,130},
{110,130},
{107,125},
{107,125},
{103,128},
{103,128},
{100,125},
{97,124},
{93,122},
{88,122},
{84,122},
{80,123},
{76,125},
{73,127},
{70,131},
{68,134},
{66,138},
{65,142},
{65,146},
{66,150},
{67,155},
{67,155},
{8,200},
{9,194},
{10,187},
{12,181},
{15,176},
{19,171},
{23,166},
{32,157},
{55,138},
{57,133},
{59,128},
{62,123},
{65,119},
{69,116},
{74,113},
{78,111},
{83,110},
{88,109},
{91,109},
{91,109},
{91,109},
{91,109},
{91,109},
{91,109},
{91,109},
{107,125},
{107,125},
{107,117},
{107,117},
{94,103},
{90,102},
{85,103},
{81,104},
{76,106},
{72,108},
{103,23},
{116,30},
{107,117},
{107,117},
{143,119},
{143,119},
{142,122},
{141,124},
{140,126},
{131,133},
{131,125},
{125,125},
{125,134},
{125,134},
{115,125},
{114,123},
{113,121},
{113,117},
{117,74},
{121,32},
{128,17},
{128,17},
{135,32},
{142,103},
{143,119},
{143,119},
{149,117},
{149,117},
{140,30},
{140,30},
{153,23},
{153,23},
{184,108},
{180,106},
{175,104},
{171,103},
{167,102},
{162,103},
{154,112},
{149,117},
{149,117},
{149,125},
{149,125},
{165,109},
{165,109},
{165,109},
{165,109},
{165,109},
{170,109},
{175,110},
{180,112},
{185,115},
{189,118},
{193,122},
{196,126},
{199,131},
{200,136},
{201,138},
{222,156},
{233,166},
{237,170},
{240,175},
{243,181},
{246,187},
{247,193},
{248,200},
{189,155},
{190,151},
{191,147},
{191,143},
{190,139},
{189,135},
{187,131},
{184,128},
{181,126},
{177,124},
{173,122},
{169,122},
{164,122},
{160,123},
{157,125},
{153,128},
{149,125},
{149,125},
{146,130},
{146,130},
{235,194},
{229,193},
{225,191},
{196,180},
{151,163},
{130,182},
{130,182},
{130,142},
{130,142},
{146,130},
{146,130},
{168,135},
{168,135},
{168,135},
{168,135},
{168,135},
{168,134},
{168,134},
{170,135},
{171,136},
{172,137},
{172,139},
{171,141},
{169,142},
{168,142},
{166,142},
{165,140},
{164,139},
{164,137},
{165,136},
{166,135},
{168,134},
{168,134},
{177,142},
{177,142},
{178,144},
{179,145},
{179,147},
{178,148},
{177,149},
{175,150},
{173,149},
{172,148},
{171,147},
{171,145},
{172,143},
{174,142},
{175,142},
{177,142},
{177,142},
{181,155},
{181,155},
{180,155},
{180,155},
{181,154},
{184,155},
{186,151},
{183,149},
{183,148},
{186,148},
{186,144},
{183,143},
{183,142},
{186,140},
{184,136},
{184,136},
{181,137},
{181,136},
{181,136},
{182,134},
{182,134},
{180,131},
{177,133},
{176,132},
{176,132},
{177,129},
{173,127},
{171,130},
{170,130},
{170,127},
{166,127},
{165,130},
{165,130},
{164,130},
{162,127},
{158,129},
{158,129},
{159,132},
{159,132},
{158,133},
{156,131},
{153,134},
{155,136},
{154,136},
{154,136},
{175,204},
{175,204},
{178,204},
{178,207},
{180,207},
{181,204},
{185,206},
{185,206},
{184,209},
{186,210},
{188,208},
{191,211},
{189,214},
{190,215},
{193,214},
{195,218},
{192,220},
{192,220},
{192,222},
{196,222},
{196,226},
{192,227},
{192,228},
{195,230},
{193,234},
{190,233},
{189,234},
{189,234},
{191,237},
{188,240},
{186,238},
{184,239},
{185,242},
{181,244},
{180,241},
{178,241},
{178,244},
{178,244},
{173,244},
{173,244},
{173,241},
{171,241},
{170,244},
{166,242},
{167,239},
{165,238},
{163,240},
{163,240},
{160,237},
{162,234},
{162,234},
{161,234},
{161,234},
{173,229},
{173,229},
{175,228},
{176,228},
{177,229},
{179,230},
{180,231},
{179,233},
{179,235},
{177,236},
{176,236},
{174,236},
{172,235},
{171,233},
{171,232},
{172,230},
{173,229},
{173,229},
{175,224},
{175,224},
{175,180},
{175,224},
{175,224},
{175,224},
{130,255},
{130,255},
{180,226},
{180,226},
{180,224},
{180,222},
{181,221},
{183,220},
{184,220},
{186,221},
{187,222},
{188,223},
{188,225},
{187,227},
{186,228},
{184,228},
{182,228},
{181,227},
{180,226},
{180,226},
{175,212},
{175,212},
{176,212},
{178,212},
{179,214},
{180,215},
{180,217},
{179,219},
{178,220},
{176,220},
{175,220},
{175,220},
{205,227},
{205,227},
{205,223},
{204,218},
{203,213},
{200,209},
{197,205},
{194,202},
{190,199},
{186,197},
{181,196},
{180,195},
{180,193},
{180,191},
{181,190},
{182,189},
{184,189},
{187,190},
{192,192},
{197,194},
{201,198},
{204,202},
{207,206},
{210,211},
{212,216},
{213,221},
{213,226},
{212,232},
{211,237},
{210,241},
{208,242},
{207,242},
{205,242},
{204,241},
{203,240},
{203,238},
{204,232},
{205,227},
{205,227},
{130,226},
{130,226},
{130,255},
{130,226},
{130,226},
{130,226},
{157,204},
{139,213},
{130,220},
{130,220},
{130,220},
{130,211},
{130,220},
{130,220},
{126,220},
{126,220},
{117,213},
{99,204},
{126,226},
{126,226},
{126,226},
{126,255},
{126,226},
{126,226},
{126,211},
{126,211},
{126,220},
{126,211},
{126,211},
{130,211},
{130,211},
{157,189},
{139,198},
{130,206},
{130,206},
{130,206},
{130,187},
{130,206},
{130,206},
{126,206},
{126,206},
{126,187},
{126,206},
{126,206},
{126,206},
{117,198},
{99,189},
{126,211},
{126,211},
{126,255},
{126,255},
{81,224},
{81,224},
{81,224},
{81,180},
{81,224},
{81,224},
{80,228},
{80,228},
{82,228},
{84,230},
{85,231},
{85,233},
{84,235},
{83,236},
{81,236},
{79,236},
{78,235},
{77,234},
{76,232},
{77,231},
{78,229},
{79,228},
{80,228},
{80,228},
{76,227},
{76,227},
{75,228},
{73,228},
{71,228},
{70,227},
{69,226},
{68,224},
{69,223},
{70,221},
{71,220},
{72,220},
{74,221},
{76,222},
{76,223},
{76,225},
{76,227},
{76,227},
{81,212},
{81,212},
{79,212},
{77,213},
{76,215},
{76,216},
{77,218},
{78,219},
{79,220},
{81,220},
{81,220},
{52,234},
{52,234},
{53,238},
{53,240},
{52,241},
{51,242},
{49,242},
{48,242},
{46,240},
{45,237},
{44,231},
{43,226},
{43,220},
{45,215},
{46,210},
{49,206},
{52,201},
{56,197},
{60,194},
{64,191},
{69,189},
{72,189},
{73,189},
{75,190},
{76,191},
{76,193},
{76,194},
{75,196},
{73,196},
{69,198},
{65,200},
{61,203},
{57,207},
{55,211},
{53,215},
{51,220},
{51,224},
{51,229},
{52,234},
{52,234},
{95,234},
{95,234},
{94,234},
{94,234},
{96,237},
{93,240},
{91,238},
{89,239},
{90,242},
{86,244},
{85,241},
{83,241},
{83,244},
{83,244},
{78,244},
{78,244},
{78,241},
{76,241},
{75,244},
{71,242},
{72,239},
{70,238},
{68,240},
{68,240},
{65,237},
{67,234},
{67,234},
{66,233},
{63,234},
{61,230},
{64,228},
{64,227},
{60,226},
{60,222},
{64,222},
{64,220},
{64,220},
{61,218},
{63,214},
{63,214},
{66,215},
{67,214},
{65,211},
{68,208},
{70,210},
{72,209},
{71,206},
{71,206},
{75,204},
{75,204},
{76,207},
{78,207},
{78,204},
{81,204},
{81,204},
{81,201},
{81,201},
{77,201},
{72,203},
{69,204},
{65,207},
{63,210},
{60,213},
{59,217},
{58,221},
{58,225},
{58,230},
{60,234},
{62,237},
{64,240},
{49,256},
{49,256},
{45,251},
{42,246},
{40,241},
{38,235},
{37,230},
{36,224},
{37,218},
{38,213},
{40,207},
{42,202},
{46,197},
{50,193},
{54,189},
{59,185},
{64,183},
{70,181},
{76,180},
{81,180},
{104,169},
{126,187},
{126,187},
{130,187},
{130,187},
{152,169},
{175,180},
{181,180},
{187,181},
{192,183},
{197,186},
{202,189},
{207,193},
{211,198},
{214,203},
{216,208},
{218,213},
{219,219},
{220,225},
{219,230},
{218,236},
{216,242},
{214,247},
{210,252},
{207,256},
{207,256},
{192,240},
{194,237},
{196,234},
{198,230},
{198,226},
{198,222},
{197,217},
{196,214},
{194,210},
{191,207},
{187,205},
{184,203},
{180,202},
{175,201},
{175,201},
{208,134},
{208,134},
{190,110},
{170,54},
{192,67},
{203,73},
{207,77},
{210,80},
{213,84},
{216,89},
{218,97},
{238,159},
{223,146},
{206,95},
{204,91},
{201,87},
{198,84},
{196,82},
{195,82},
{194,82},
{193,83},
{193,85},
{197,89},
{200,92},
{202,96},
{217,142},
{208,134},
{208,134},
{216,76},
{216,76},
{168,48},
{159,27},
{205,60},
{208,64},
{212,68},
{215,73},
{216,76},
{216,76},
{103,19},
{103,19},
{107,17},
{110,14},
{113,11},
{121,1},
{135,1},
{143,11},
{146,14},
{149,17},
{153,19},
{138,26},
{128,9},
{128,10},
{128,9},
{128,10},
{128,9},
{118,26},
{103,19},
{103,19}};

void setup() {
  pinMode(0, OUTPUT);
  pinMode(1, OUTPUT);
  pinMode(2, OUTPUT);
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(6, OUTPUT);
  pinMode(7, OUTPUT);

  pinMode(8, OUTPUT);
  pinMode(9, OUTPUT);
  pinMode(10, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(12, OUTPUT);
  pinMode(13, OUTPUT);

  pinMode(A0, OUTPUT);
  pinMode(A1, OUTPUT);

}

uint16_t i = 0;
uint8_t d = 0;
uint8_t dir = 0;

void loop() {
  uint8_t x = pgm_read_byte(&data[i][0]);
  uint8_t y = pgm_read_byte(&data[i][1]);
  PORTD = x;
  PORTB = y & 0b0011111111;
  PORTC = y >> 6;
  if(dir == 0) {
    i++;
    if(i >= pointcount) {
      dir=1;
    }
  } else {
    i--;
    if(i <= 0) {
      dir=0;
    }
  }
  //delayMicroseconds(11);
  
}
",8293,True,2532.773668544295,median
"[[salesforce-component]]
= Salesforce Component

*Available as of Camel version 2.12*

This component supports producer and consumer endpoints to communicate
with Salesforce using Java DTOs.  +
 There is a companion maven plugin Camel Salesforce Plugin that
generates these DTOs (see further below).

Maven users will need to add the following dependency to their `pom.xml`
for this component:

[source,xml]
----
<dependency>
    <groupId>org.apache.camel</groupId>
    <artifactId>camel-salesforce</artifactId>
    <version>x.x.x</version>
    <!-- use the same version as your Camel core version -->
</dependency>
----

NOTE: Developers wishing to contribute to the component are instructed
to look at the https://github.com/apache/camel/tree/master/components/camel-salesforce/camel-salesforce-component/README.md[README.md] file on instructions on how to get started and
setup your environment for running integration tests.

== Authenticating to Salesforce

The component supports three OAuth authentication flows:

* https://help.salesforce.com/articleView?id=remoteaccess_oauth_username_password_flow.htm[OAuth 2.0 Username-Password Flow]
* https://help.salesforce.com/articleView?id=remoteaccess_oauth_refresh_token_flow.htm[OAuth 2.0 Refresh Token Flow]
* https://help.salesforce.com/articleView?id=remoteaccess_oauth_jwt_flow.htm[OAuth 2.0 JWT Bearer Token Flow]

For each of the flow different set of properties needs to be set:

.Properties to set for each authentication flow
|===
| Property     | Where to find it on Salesforce     | Flow

| clientId     | Connected App, Consumer Key        | All flows
| clientSecret | Connected App, Consumer Secret     | Username-Password, Refresh Token
| userName     | Salesforce user username           | Username-Password, JWT Bearer Token
| password     | Salesforce user password           | Username-Password
| refreshToken | From OAuth flow callback           | Refresh Token
| keystore     | Connected App, Digital Certificate | JWT Bearer Token
|===

The component auto determines what flow you're trying to configure, to
be remove ambiguity set the `authenticationType` property.

NOTE: Using Username-Password Flow in production is not encouraged.

NOTE: The certificate used in JWT Bearer Token Flow can be a selfsigned 
certificate. The KeyStore holding the certificate and the private key
must contain only single certificate-private key entry.

== URI format

When used as a consumer, receiving streaming events, the URI scheme is:

[source,java]
----
salesforce:topic?options
----

When used as a producer, invoking the Salesforce REST APIs, the URI
scheme is:

[source,java]
----
salesforce:operationName?options
----

You can append query options to the URI in the following format,
`?option=value&option=value&...`

== Passing in Salesforce headers and fetching Salesforce response headers

There is support to pass https://developer.salesforce.com/docs/atlas.en-us.api_rest.meta/api_rest/headers.htm[Salesforce headers]
via inbound message headers, header names that start with `Sforce` or
`x-sfdc` on the Camel message will be passed on in the request, and
response headers that start with `Sforce` will be present in the outbound
message headers.

For example to fetch API limits you can specify:

[source,java]
----
// in your Camel route set the header before Salesforce endpoint
//...
  .setHeader(""Sforce-Limit-Info"", constant(""api-usage""))
  .to(""salesforce:getGlobalObjects"")
  .to(myProcessor);

// myProcessor will receive `Sforce-Limit-Info` header on the outbound
// message
class MyProcessor implements Processor {
    public void process(Exchange exchange) throws Exception {
        Message in = exchange.getIn();
        String apiLimits = in.getHeader(""Sforce-Limit-Info"", String.class);
   }
}
----

== Supported Salesforce APIs

The component supports the following Salesforce APIs

Producer endpoints can use the following APIs. Most of the APIs process
one record at a time, the Query API can retrieve multiple Records.

=== Rest API

You can use the following for `operationName`:

* getVersions - Gets supported Salesforce REST API versions
* getResources - Gets available Salesforce REST Resource endpoints
* getGlobalObjects - Gets metadata for all available SObject types
* getBasicInfo - Gets basic metadata for a specific SObject type
* getDescription - Gets comprehensive metadata for a specific SObject
type
* getSObject - Gets an SObject using its Salesforce Id
* createSObject - Creates an SObject
* updateSObject - Updates an SObject using Id
* deleteSObject - Deletes an SObject using Id
* getSObjectWithId - Gets an SObject using an external (user defined) id
field
* upsertSObject - Updates or inserts an SObject using an external id
* deleteSObjectWithId - Deletes an SObject using an external id
* query - Runs a Salesforce SOQL query
* queryMore - Retrieves more results (in case of large number of
results) using result link returned from the 'query' API
* search - Runs a Salesforce SOSL query
* limits - fetching organization API usage limits
* recent - fetching recent items
* approval - submit a record or records (batch) for approval process
* approvals - fetch a list of all approval processes
* composite - submit up to 25 possibly related REST requests and receive individual responses
* composite-tree - create up to 200 records with parent-child relationships (up to 5 levels) in one go
* composite-batch - submit a composition of requests in batch
* queryAll - Runs a SOQL query. It returns the results that are deleted because of a merge or delete. Also returns the  information about archived Task and Event records.
* getBlobField - Retrieves the specified blob field from an individual record.
* apexCall - Executes a user defined APEX REST API call.

For example, the following producer endpoint uses the upsertSObject API,
with the sObjectIdName parameter specifying 'Name' as the external id
field. 
The request message body should be an SObject DTO generated using the
maven plugin.  
The response message will either be `null` if an existing record was
updated, or `CreateSObjectResult` with an id of the new record, or a
list of errors while creating the new object.

[source,java]
----
...to(""salesforce:upsertSObject?sObjectIdName=Name"")...
----

=== Rest Bulk API

Producer endpoints can use the following APIs. All Job data formats,
i.e. xml, csv, zip/xml, and zip/csv are supported.  +
 The request and response have to be marshalled/unmarshalled by the
route. Usually the request will be some stream source like a CSV file,
 +
 and the response may also be saved to a file to be correlated with the
request.

You can use the following for `operationName`:

* createJob - Creates a Salesforce Bulk Job
* getJob - Gets a Job using its Salesforce Id
* closeJob - Closes a Job
* abortJob - Aborts a Job
* createBatch - Submits a Batch within a Bulk Job
* getBatch - Gets a Batch using Id
* getAllBatches - Gets all Batches for a Bulk Job Id
* getRequest - Gets Request data (XML/CSV) for a Batch
* getResults - Gets the results of the Batch when its complete
* createBatchQuery - Creates a Batch from an SOQL query
* getQueryResultIds - Gets a list of Result Ids for a Batch Query
* getQueryResult - Gets results for a Result Id
* getRecentReports - Gets up to 200 of the reports you most recently viewed by sending a GET request to the Report List resource.
* getReportDescription - Retrieves the report, report type, and related metadata for a report, either in a tabular or summary or matrix format.
* executeSyncReport - Runs a report synchronously with or without changing filters and returns the latest summary data.
* executeAsyncReport - Runs an instance of a report asynchronously with or without filters and returns the summary data with or without details.
* getReportInstances - Returns a list of instances for a report that you requested to be run asynchronously. Each item in the list is treated as a separate instance of the report.
* getReportResults: Contains the results of running a report.

For example, the following producer endpoint uses the createBatch API to
create a Job Batch. The in message must contain a body that can be converted into an
`InputStream` (usually UTF-8 CSV or XML content from a file, etc.) and
header fields 'jobId' for the Job and 'contentType' for the Job content
type, which can be XML, CSV, ZIP_XML or ZIP_CSV. The put message body
will contain `BatchInfo` on success, or throw a `SalesforceException` on
error.

[source,java]
----
...to(""salesforce:createBatchJob"")..
----

=== Rest Streaming API

Consumer endpoints can use the following syntax for streaming endpoints
to receive Salesforce notifications on create/update.

To create and subscribe to a topic

[source,java]
----
from(""salesforce:CamelTestTopic?notifyForFields=ALL&notifyForOperations=ALL&sObjectName=Merchandise__c&updateTopic=true&sObjectQuery=SELECT Id, Name FROM Merchandise__c"")...
----

To subscribe to an existing topic

[source,java]
----
from(""salesforce:CamelTestTopic&sObjectName=Merchandise__c"")...
----

=== Platform events

To emit a platform event use `createSObject` operation. And set the
message body can be JSON string or InputStream with key-value data --
in that case `sObjectName` needs to be set to the API name of the
event, or a class that extends from AbstractDTOBase with the
appropriate class name for the event.

For example using a DTO:

[source,java]
----
class Order_Event__e extends AbstractDTOBase {
  @JsonProperty(""OrderNumber"")
  private String orderNumber;
  // ... other properties and getters/setters
}

from(""timer:tick"")
    .process(exchange -> {
        final Message in = exchange.getIn();
        String orderNumber = ""ORD"" + String.valueOf(in.getHeader(Exchange.TIMER_COUNTER));
        Order_Event__e event = new Order_Event__e();
        event.setOrderNumber(orderNumber);
        in.setBody(event);
    })
    .to(""salesforce:createSObject"");
----

Or using JSON event data:

[source,java]
----
from(""timer:tick"")
    .process(exchange -> {
        final Message in = exchange.getIn();
        String orderNumber = ""ORD"" + String.valueOf(in.getHeader(Exchange.TIMER_COUNTER));
        in.setBody(""{\\""OrderNumber\\"":\\"""" + orderNumber + ""\\""}"");
    })
    .to(""salesforce:createSObject?sObjectName=Order_Event__e"");
----

To receive platform events use the consumer endpoint with the API name of
the platform event prefixed with `event/` (or `/event/`), e.g.:
`salesforce:events/Order_Event__e`. Processor consuming from that
endpoint will receive either `org.apache.camel.component.salesforce.api.dto.PlatformEvent`
object or `org.cometd.bayeux.Message` in the body depending on the
`rawPayload` being `false` or `true` respectively.

For example, in the simplest form to consume one event:

[source,java]
----
PlatformEvent event = consumer.receiveBody(""salesforce:event/Order_Event__e"", PlatformEvent.class);
----

=== Change data capture events

On the one hand, Salesforce could be configured to emit notifications for record changes of select objects.
On the other hand, the Camel Salesforce component could react to such notifications, allowing for instance to
https://trailhead.salesforce.com/en/content/learn/modules/change-data-capture/understand-change-data-capture[synchronize those changes into an external system].

The notifications of interest could be specified in the `from(""salesforce:XXX"")` clause of a Camel route via the subscription channel, e.g:

[source,java]
----
from(""salesforce:data/ChangeEvents?replayId=-1"").log(""being notified of all change events"")
from(""salesforce:data/AccountChangeEvent?replayId=-1"").log(""being notified of change events for Account records"")
from(""salesforce:data/Employee__ChangeEvent?replayId=-1"").log(""being notified of change events for Employee__c custom object"")
----

The received message contains either `java.util.Map<String,Object>` or `org.cometd.bayeux.Message` in the body depending on the `rawPayload` being `false` or `true` respectively. The `CamelSalesforceChangeType` header could be valued to one of `CREATE`, `UPDATE`,  `DELETE` or `UNDELETE`.

More details about how to use the Camel Salesforce component change data capture capabilities could be found in the https://github.com/apache/camel/tree/master/components/camel-salesforce/camel-salesforce-component/src/test/java/org/apache/camel/component/salesforce/ChangeEventsConsumerIntegrationTest.java[ChangeEventsConsumerIntegrationTest].

The https://developer.salesforce.com/docs/atlas.en-us.change_data_capture.meta/change_data_capture/cdc_intro.htm[Salesforce developer guide]
is a good fit to better know the subtleties of implementing a change data capture integration application.
The dynamic nature of change event body fields, high level replication steps as well as security considerations could be of interest.

== Examples

=== Uploading a document to a ContentWorkspace

Create the ContentVersion in Java, using a Processor instance:

[source,java]
----
public class ContentProcessor implements Processor {
    public void process(Exchange exchange) throws Exception {
        Message message = exchange.getIn();

        ContentVersion cv = new ContentVersion();
        ContentWorkspace cw = getWorkspace(exchange);
        cv.setFirstPublishLocationId(cw.getId());
        cv.setTitle(""test document"");
        cv.setPathOnClient(""test_doc.html"");
        byte[] document = message.getBody(byte[].class);
        ObjectMapper mapper = new ObjectMapper();
        String enc = mapper.convertValue(document, String.class);
        cv.setVersionDataUrl(enc);
        message.setBody(cv);
    }

    protected ContentWorkspace getWorkSpace(Exchange exchange) {
        // Look up the content workspace somehow, maybe use enrich() to add it to a
        // header that can be extracted here
        ....
    }
} 
----

Give the output from the processor to the Salesforce component:

[source,java]
----
from(""file:///home/camel/library"")
    .to(new ContentProcessor())     // convert bytes from the file into a ContentVersion SObject 
                                    // for the salesforce component
    .to(""salesforce:createSObject""); 
----

== Using Salesforce Limits API

With `salesforce:limits` operation you can fetch of API limits from Salesforce and then act upon that data received.
The result of `salesforce:limits` operation is mapped to `org.apache.camel.component.salesforce.api.dto.Limits`
class and can be used in a custom processors or expressions.

For instance, consider that you need to limit the API usage of Salesforce so that 10% of daily API requests is left for
other routes. The body of output message contains an instance of
`org.apache.camel.component.salesforce.api.dto.Limits` object that can be used in conjunction with
Content Based Router and Content Based Router and 
xref:spel-language.adoc[Spring Expression Language (SpEL)] to choose when to perform queries.

Notice how multiplying `1.0` with the integer value held in `body.dailyApiRequests.remaining` makes the expression
evaluate as with floating point arithmetic, without it - it would end up making integral division which would result
with either `0` (some API limits consumed) or `1` (no API limits consumed).

[source,java]
----
from(""direct:querySalesforce"")
    .to(""salesforce:limits"")
    .choice()
    .when(spel(""#{1.0 * body.dailyApiRequests.remaining / body.dailyApiRequests.max < 0.1}""))
        .to(""salesforce:query?..."")
    .otherwise()
        .setBody(constant(""Used up Salesforce API limits, leaving 10% for critical routes""))
    .endChoice()
----

== Working with approvals

All the properties are named exactly the same as in the Salesforce REST API prefixed with `approval.`. You can set
approval properties by setting `approval.PropertyName` of the Endpoint these will be used as template -- meaning
that any property not present in either body or header will be taken from the Endpoint configuration. Or you can set
the approval template on the Endpoint by assigning `approval` property to a reference onto a bean in the Registry.

You can also provide header values using the same `approval.PropertyName` in the incoming message headers.

And finally body can contain one `AprovalRequest` or an `Iterable` of `ApprovalRequest` objects to process as
a batch.

The important thing to remember is the priority of the values specified in these three mechanisms:

. value in body takes precedence before any other
. value in message header takes precedence before template value
. value in template is set if no other value in header or body was given

For example to send one record for approval using values in headers use:

Given a route:

[source,java]
----
from(""direct:example1"")//
        .setHeader(""approval.ContextId"", simple(""${body['contextId']}""))
        .setHeader(""approval.NextApproverIds"", simple(""${body['nextApproverIds']}""))
        .to(""salesforce:approval?""//
            + ""approval.actionType=Submit""//
            + ""&approval.comments=this is a test""//
            + ""&approval.processDefinitionNameOrId=Test_Account_Process""//
            + ""&approval.skipEntryCriteria=true"");
----

You could send a record for approval using:

[source,java]
----
final Map<String, String> body = new HashMap<>();
body.put(""contextId"", accountIds.iterator().next());
body.put(""nextApproverIds"", userId);

final ApprovalResult result = template.requestBody(""direct:example1"", body, ApprovalResult.class);
----

== Using Salesforce Recent Items API

To fetch the recent items use `salesforce:recent` operation. This operation returns an `java.util.List` of
`org.apache.camel.component.salesforce.api.dto.RecentItem` objects (`List<RecentItem>`) that in turn contain
the `Id`, `Name` and `Attributes` (with `type` and `url` properties). You can limit the number of returned items
by specifying `limit` parameter set to maximum number of records to return. For example:

[source,java]
----
from(""direct:fetchRecentItems"")
    to(""salesforce:recent"")
        .split().body()
            .log(""${body.name} at ${body.attributes.url}"");
----

== Using Salesforce Composite API to submit SObject tree

To create up to 200 records including parent-child relationships use `salesforce:composite-tree` operation. This
requires an instance of `org.apache.camel.component.salesforce.api.dto.composite.SObjectTree` in the input 
message and returns the same tree of objects in the output message. The 
`org.apache.camel.component.salesforce.api.dto.AbstractSObjectBase` instances within the tree get updated with
the identifier values (`Id` property) or their corresponding
`org.apache.camel.component.salesforce.api.dto.composite.SObjectNode` is populated with `errors` on failure.

Note that for some records operation can succeed and for some it can fail -- so you need to manually check for errors.

Easiest way to use this functionality is to use the DTOs generated by the `camel-salesforce-maven-plugin`, but you
also have the option of customizing the references that identify the each object in the tree, for instance primary keys
from your database.

Lets look at an example:

[source,java]
----
Account account = ...
Contact president = ...
Contact marketing = ...

Account anotherAccount = ...
Contact sales = ...
Asset someAsset = ...

// build the tree
SObjectTree request = new SObjectTree();
request.addObject(account).addChildren(president, marketing);
request.addObject(anotherAccount).addChild(sales).addChild(someAsset);

final SObjectTree response = template.requestBody(""salesforce:composite-tree"", tree, SObjectTree.class);
final Map<Boolean, List<SObjectNode>> result = response.allNodes()
                                                   .collect(Collectors.groupingBy(SObjectNode::hasErrors));

final List<SObjectNode> withErrors = result.get(true);
final List<SObjectNode> succeeded = result.get(false);

final String firstId = succeeded.get(0).getId();
----

== Using Salesforce Composite API to submit multiple requests in a batch
The Composite API batch operation (`composite-batch`) allows you to accumulate multiple requests in a batch and then
submit them in one go, saving the round trip cost of multiple individual requests. Each response is then received in a
list of responses with the order preserved, so that the n-th requests response is in the n-th place of the response.

NOTE: The results can vary from API to API so the result of the request is given as a `java.lang.Object`. In most cases
the result will be a `java.util.Map` with string keys and values or other `java.util.Map` as value. Requests made in
JSON format hold some type information (i.e. it is known what values are strings and what values are numbers), so in
general those will be more type friendly. Note that the responses will vary between XML and JSON, this is due to the
responses from Salesforce API being different. So be careful if you switch between formats without changing the response
handling code.

Lets look at an example:

[source,java]
----
final String acountId = ...
final SObjectBatch batch = new SObjectBatch(""38.0"");

final Account updates = new Account();
updates.setName(""NewName"");
batch.addUpdate(""Account"", accountId, updates);

final Account newAccount = new Account();
newAccount.setName(""Account created from Composite batch API"");
batch.addCreate(newAccount);

batch.addGet(""Account"", accountId, ""Name"", ""BillingPostalCode"");

batch.addDelete(""Account"", accountId);

final SObjectBatchResponse response = template.requestBody(""salesforce:composite-batch?format=JSON"", batch, SObjectBatchResponse.class);

boolean hasErrors = response.hasErrors(); // if any of the requests has resulted in either 4xx or 5xx HTTP status
final List<SObjectBatchResult> results = response.getResults(); // results of three operations sent in batch

final SObjectBatchResult updateResult = results.get(0); // update result
final int updateStatus = updateResult.getStatusCode(); // probably 204
final Object updateResultData = updateResult.getResult(); // probably null

final SObjectBatchResult createResult = results.get(1); // create result
@SuppressWarnings(""unchecked"")
final Map<String, Object> createData = (Map<String, Object>) createResult.getResult();
final String newAccountId = createData.get(""id""); // id of the new account, this is for JSON, for XML it would be createData.get(""Result"").get(""id"")

final SObjectBatchResult retrieveResult = results.get(2); // retrieve result
@SuppressWarnings(""unchecked"")
final Map<String, Object> retrieveData = (Map<String, Object>) retrieveResult.getResult();
final String accountName = retrieveData.get(""Name""); // Name of the retrieved account, this is for JSON, for XML it would be createData.get(""Account"").get(""Name"")
final String accountBillingPostalCode = retrieveData.get(""BillingPostalCode""); // Name of the retrieved account, this is for JSON, for XML it would be createData.get(""Account"").get(""BillingPostalCode"")

final SObjectBatchResult deleteResult = results.get(3); // delete result
final int updateStatus = deleteResult.getStatusCode(); // probably 204
final Object updateResultData = deleteResult.getResult(); // probably null
----

== Using Salesforce Composite API to submit multiple chained requests
The `composite` operation allows submitting up to 25 requests that can be chained together, for instance identifier
generated in previous request can be used in subsequent request. Individual requests and responses are linked with the
provided _reference_.

NOTE: Composite API supports only JSON payloads.

NOTE: As with the batch API the results can vary from API to API so the result of the request is given as a
`java.lang.Object`. In most cases the result will be a `java.util.Map` with string keys and values or other
`java.util.Map` as value. Requests made in JSON format hold some type information (i.e. it is known what values are
strings and what values are numbers), so in general those will be more type friendly.

Lets look at an example:

[source,java]
----
SObjectComposite composite = new SObjectComposite(""38.0"", true);

// first insert operation via an external id
final Account updateAccount = new TestAccount();
updateAccount.setName(""Salesforce"");
updateAccount.setBillingStreet(""Landmark @ 1 Market Street"");
updateAccount.setBillingCity(""San Francisco"");
updateAccount.setBillingState(""California"");
updateAccount.setIndustry(Account_IndustryEnum.TECHNOLOGY);
composite.addUpdate(""Account"", ""001xx000003DIpcAAG"", updateAccount, ""UpdatedAccount"");

final Contact newContact = new TestContact();
newContact.setLastName(""John Doe"");
newContact.setPhone(""1234567890"");
composite.addCreate(newContact, ""NewContact"");

final AccountContactJunction__c junction = new AccountContactJunction__c();
junction.setAccount__c(""001xx000003DIpcAAG"");
junction.setContactId__c(""@{NewContact.id}"");
composite.addCreate(junction, ""JunctionRecord"");

final SObjectCompositeResponse response = template.requestBody(""salesforce:composite?format=JSON"", composite, SObjectCompositeResponse.class);
final List<SObjectCompositeResult> results = response.getCompositeResponse();

final SObjectCompositeResult accountUpdateResult = results.stream().filter(r -> ""UpdatedAccount"".equals(r.getReferenceId())).findFirst().get()
final int statusCode = accountUpdateResult.getHttpStatusCode(); // should be 200
final Map<String, ?> accountUpdateBody = accountUpdateResult.getBody();

final SObjectCompositeResult contactCreationResult = results.stream().filter(r -> ""JunctionRecord"".equals(r.getReferenceId())).findFirst().get()
----

==  Sending null values to salesforce

By default, SObject fields with null values are not sent to salesforce. In order to
send null values to salesforce, use the `fieldsToNull` property, as follows:

[source,java]
----
accountSObject.getFieldsToNull().add(""Site"");
----

== Generating SOQL query strings

`org.apache.camel.component.salesforce.api.utils.QueryHelper` contains helper
methods to generate SOQL queries. For instance to fetch all custom fields from
_Account_ SObject you can simply generate the SOQL SELECT by invoking:

[source,java]
----
String allCustomFieldsQuery = QueryHelper.queryToFetchFilteredFieldsOf(new Account(), SObjectField::isCustom);
----

== Camel Salesforce Maven Plugin

This Maven plugin generates DTOs for the Camel. 

For obvious security reasons it is recommended that the clientId,
clientSecret, userName and password fields be not set in the pom.xml.  
The plugin should be configured for the rest of the properties, and can
be executed using the following command:

[source,java]
----
mvn camel-salesforce:generate -DcamelSalesforce.clientId=<clientid> -DcamelSalesforce.clientSecret=<clientsecret> \\
    -DcamelSalesforce.userName=<username> -DcamelSalesforce.password=<password>
----

The generated DTOs use Jackson and XStream annotations. All Salesforce
field types are supported. Date and time fields are mapped to
`java.time.ZonedDateTime` by default, and picklist fields are mapped to
generated Java Enumerations.

Please refer to
https://github.com/apache/camel/tree/master/components/camel-salesforce/camel-salesforce-maven-plugin[README.md]
for details on how to generate the DTO.

== Options







// component options: START
The Salesforce component supports 31 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *authenticationType* (security) | Explicit authentication method to be used, one of USERNAME_PASSWORD, REFRESH_TOKEN or JWT. Salesforce component can auto-determine the authentication method to use from the properties set, set this property to eliminate any ambiguity. |  | AuthenticationType
| *loginConfig* (security) | All authentication configuration in one nested bean, all properties set there can be set directly on the component as well |  | SalesforceLoginConfig
| *instanceUrl* (security) | URL of the Salesforce instance used after authentication, by default received from Salesforce on successful authentication |  | String
| *loginUrl* (security) | *Required* URL of the Salesforce instance used for authentication, by default set to \\https://login.salesforce.com | https://login.salesforce.com | String
| *clientId* (security) | *Required* OAuth Consumer Key of the connected app configured in the Salesforce instance setup. Typically a connected app needs to be configured but one can be provided by installing a package. |  | String
| *clientSecret* (security) | OAuth Consumer Secret of the connected app configured in the Salesforce instance setup. |  | String
| *keystore* (security) | KeyStore parameters to use in OAuth JWT flow. The KeyStore should contain only one entry with private key and certificate. Salesforce does not verify the certificate chain, so this can easily be a selfsigned certificate. Make sure that you upload the certificate to the corresponding connected app. |  | KeyStoreParameters
| *refreshToken* (security) | Refresh token already obtained in the refresh token OAuth flow. One needs to setup a web application and configure a callback URL to receive the refresh token, or configure using the builtin callback at \\https://login.salesforce.com/services/oauth2/success or \\https://test.salesforce.com/services/oauth2/success and then retrive the refresh_token from the URL at the end of the flow. Note that in development organizations Salesforce allows hosting the callback web application at localhost. |  | String
| *userName* (security) | Username used in OAuth flow to gain access to access token. It's easy to get started with password OAuth flow, but in general one should avoid it as it is deemed less secure than other flows. |  | String
| *password* (security) | Password used in OAuth flow to gain access to access token. It's easy to get started with password OAuth flow, but in general one should avoid it as it is deemed less secure than other flows. Make sure that you append security token to the end of the password if using one. |  | String
| *lazyLogin* (security) | If set to true prevents the component from authenticating to Salesforce with the start of the component. You would generally set this to the (default) false and authenticate early and be immediately aware of any authentication issues. | false | boolean
| *config* (common) | Global endpoint configuration - use to set values that are common to all endpoints |  | SalesforceEndpoint Config
| *httpClientProperties* (common) | Used to set any properties that can be configured on the underlying HTTP client. Have a look at properties of SalesforceHttpClient and the Jetty HttpClient for all available options. |  | Map
| *longPollingTransport Properties* (common) | Used to set any properties that can be configured on the LongPollingTransport used by the BayeuxClient (CometD) used by the streaming api |  | Map
| *sslContextParameters* (security) | SSL parameters to use, see SSLContextParameters class for all available options. |  | SSLContextParameters
| *useGlobalSslContext Parameters* (security) | Enable usage of global SSL context parameters | false | boolean
| *httpClientIdleTimeout* (common) | Timeout used by the HttpClient when waiting for response from the Salesforce server. | 10000 | long
| *httpClientConnection Timeout* (common) | Connection timeout used by the HttpClient when connecting to the Salesforce server. | 60000 | long
| *httpProxyHost* (proxy) | Hostname of the HTTP proxy server to use. |  | String
| *httpProxyPort* (proxy) | Port number of the HTTP proxy server to use. |  | Integer
| *httpProxyUsername* (security) | Username to use to authenticate against the HTTP proxy server. |  | String
| *httpProxyPassword* (security) | Password to use to authenticate against the HTTP proxy server. |  | String
| *isHttpProxySocks4* (proxy) | If set to true the configures the HTTP proxy to use as a SOCKS4 proxy. | false | boolean
| *isHttpProxySecure* (security) | If set to false disables the use of TLS when accessing the HTTP proxy. | true | boolean
| *httpProxyIncluded Addresses* (proxy) | A list of addresses for which HTTP proxy server should be used. |  | Set
| *httpProxyExcluded Addresses* (proxy) | A list of addresses for which HTTP proxy server should not be used. |  | Set
| *httpProxyAuthUri* (security) | Used in authentication against the HTTP proxy server, needs to match the URI of the proxy server in order for the httpProxyUsername and httpProxyPassword to be used for authentication. |  | String
| *httpProxyRealm* (security) | Realm of the proxy server, used in preemptive Basic/Digest authentication methods against the HTTP proxy server. |  | String
| *httpProxyUseDigest Auth* (security) | If set to true Digest authentication will be used when authenticating to the HTTP proxy,otherwise Basic authorization method will be used | false | boolean
| *packages* (common) | In what packages are the generated DTO classes. Typically the classes would be generated using camel-salesforce-maven-plugin. Set it if using the generated DTOs to gain the benefit of using short SObject names in parameters/header values. |  | String[]
| *basicPropertyBinding* (advanced) | Whether the component should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
|===
// component options: END










// endpoint options: START
The Salesforce endpoint is configured using URI syntax:

----
salesforce:operationName:topicName
----

with the following path and query parameters:

=== Path Parameters (2 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *operationName* | The operation to use |  | OperationName
| *topicName* | The name of the topic/channel to use |  | String
|===


=== Query Parameters (45 parameters):


[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *apexMethod* (common) | APEX method name |  | String
| *apexQueryParams* (common) | Query params for APEX method |  | Map
| *apexUrl* (common) | APEX method URL |  | String
| *apiVersion* (common) | Salesforce API version, defaults to SalesforceEndpointConfig.DEFAULT_VERSION |  | String
| *backoffIncrement* (common) | Backoff interval increment for Streaming connection restart attempts for failures beyond CometD auto-reconnect. |  | long
| *batchId* (common) | Bulk API Batch ID |  | String
| *contentType* (common) | Bulk API content type, one of XML, CSV, ZIP_XML, ZIP_CSV |  | ContentType
| *defaultReplayId* (common) | Default replayId setting if no value is found in initialReplayIdMap |  | Long
| *format* (common) | Payload format to use for Salesforce API calls, either JSON or XML, defaults to JSON |  | PayloadFormat
| *httpClient* (common) | Custom Jetty Http Client to use to connect to Salesforce. |  | SalesforceHttpClient
| *includeDetails* (common) | Include details in Salesforce1 Analytics report, defaults to false. |  | Boolean
| *initialReplayIdMap* (common) | Replay IDs to start from per channel name. |  | Map
| *instanceId* (common) | Salesforce1 Analytics report execution instance ID |  | String
| *jobId* (common) | Bulk API Job ID |  | String
| *limit* (common) | Limit on number of returned records. Applicable to some of the API, check the Salesforce documentation. |  | Integer
| *maxBackoff* (common) | Maximum backoff interval for Streaming connection restart attempts for failures beyond CometD auto-reconnect. |  | long
| *notFoundBehaviour* (common) | Sets the behaviour of 404 not found status received from Salesforce API. Should the body be set to NULL NotFoundBehaviour#NULL or should a exception be signaled on the exchange NotFoundBehaviour#EXCEPTION - the default. |  | NotFoundBehaviour
| *notifyForFields* (common) | Notify for fields, options are ALL, REFERENCED, SELECT, WHERE |  | NotifyForFieldsEnum
| *notifyForOperationCreate* (common) | Notify for create operation, defaults to false (API version = 29.0) |  | Boolean
| *notifyForOperationDelete* (common) | Notify for delete operation, defaults to false (API version = 29.0) |  | Boolean
| *notifyForOperations* (common) | Notify for operations, options are ALL, CREATE, EXTENDED, UPDATE (API version 29.0) |  | NotifyForOperations Enum
| *notifyForOperationUndelete* (common) | Notify for un-delete operation, defaults to false (API version = 29.0) |  | Boolean
| *notifyForOperationUpdate* (common) | Notify for update operation, defaults to false (API version = 29.0) |  | Boolean
| *objectMapper* (common) | Custom Jackson ObjectMapper to use when serializing/deserializing Salesforce objects. |  | ObjectMapper
| *rawPayload* (common) | Use raw payload String for request and response (either JSON or XML depending on format), instead of DTOs, false by default | false | boolean
| *reportId* (common) | Salesforce1 Analytics report Id |  | String
| *reportMetadata* (common) | Salesforce1 Analytics report metadata for filtering |  | ReportMetadata
| *resultId* (common) | Bulk API Result ID |  | String
| *sObjectBlobFieldName* (common) | SObject blob field name |  | String
| *sObjectClass* (common) | Fully qualified SObject class name, usually generated using camel-salesforce-maven-plugin |  | String
| *sObjectFields* (common) | SObject fields to retrieve |  | String
| *sObjectId* (common) | SObject ID if required by API |  | String
| *sObjectIdName* (common) | SObject external ID field name |  | String
| *sObjectIdValue* (common) | SObject external ID field value |  | String
| *sObjectName* (common) | SObject name if required or supported by API |  | String
| *sObjectQuery* (common) | Salesforce SOQL query string |  | String
| *sObjectSearch* (common) | Salesforce SOSL search string |  | String
| *updateTopic* (common) | Whether to update an existing Push Topic when using the Streaming API, defaults to false | false | boolean
| *bridgeErrorHandler* (consumer) | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN or ERROR level and ignored. | false | boolean
| *replayId* (consumer) | The replayId value to use when subscribing |  | Long
| *exceptionHandler* (consumer) | To let the consumer use a custom ExceptionHandler. Notice if the option bridgeErrorHandler is enabled then this option is not in use. By default the consumer will deal with exceptions, that will be logged at WARN or ERROR level and ignored. |  | ExceptionHandler
| *exchangePattern* (consumer) | Sets the exchange pattern when the consumer creates an exchange. |  | ExchangePattern
| *lazyStartProducer* (producer) | Whether the producer should be started lazy (on the first message). By starting lazy you can use this to allow CamelContext and routes to startup in situations where a producer may otherwise fail during starting and cause the route to fail being started. By deferring this startup to be lazy then the startup failure can be handled during routing messages via Camel's routing error handlers. Beware that when the first message is processed then creating and starting the producer may take a little time and prolong the total processing time of the processing. | false | boolean
| *basicPropertyBinding* (advanced) | Whether the endpoint should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | boolean
| *synchronous* (advanced) | Sets whether synchronous processing should be strictly used, or Camel is allowed to use asynchronous processing (if supported). | false | boolean
|===
// endpoint options: END
// spring-boot-auto-configure options: START
== Spring Boot Auto-Configuration

When using Spring Boot make sure to use the following Maven dependency to have support for auto configuration:

[source,xml]
----
<dependency>
  <groupId>org.apache.camel</groupId>
  <artifactId>camel-salesforce-starter</artifactId>
  <version>x.x.x</version>
  <!-- use the same version as your Camel core version -->
</dependency>
----


The component supports 87 options, which are listed below.



[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *camel.component.salesforce.authentication-type* | Explicit authentication method to be used, one of USERNAME_PASSWORD, REFRESH_TOKEN or JWT. Salesforce component can auto-determine the authentication method to use from the properties set, set this property to eliminate any ambiguity. |  | AuthenticationType
| *camel.component.salesforce.basic-property-binding* | Whether the component should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities | false | Boolean
| *camel.component.salesforce.client-id* | OAuth Consumer Key of the connected app configured in the Salesforce instance setup. Typically a connected app needs to be configured but one can be provided by installing a package. |  | String
| *camel.component.salesforce.client-secret* | OAuth Consumer Secret of the connected app configured in the Salesforce instance setup. |  | String
| *camel.component.salesforce.config.apex-method* | APEX method name |  | String
| *camel.component.salesforce.config.apex-query-params* | Query params for APEX method |  | Map
| *camel.component.salesforce.config.apex-url* | APEX method URL |  | String
| *camel.component.salesforce.config.api-version* | Salesforce API version, defaults to SalesforceEndpointConfig.DEFAULT_VERSION |  | String
| *camel.component.salesforce.config.approval* | The approval request for Approval API. |  | ApprovalRequest
| *camel.component.salesforce.config.approval-action-type* | Represents the kind of action to take: Submit, Approve, or Reject. |  | ApprovalRequest$Action
| *camel.component.salesforce.config.approval-comments* | The comment to add to the history step associated with this request. |  | String
| *camel.component.salesforce.config.approval-context-actor-id* | The ID of the submitter who’s requesting the approval record. |  | String
| *camel.component.salesforce.config.approval-context-id* | The ID of the item that is being acted upon. |  | String
| *camel.component.salesforce.config.approval-next-approver-ids* | If the process requires specification of the next approval, the ID of the user to be assigned the next request. |  | List
| *camel.component.salesforce.config.approval-process-definition-name-or-id* | The developer name or ID of the process definition. |  | String
| *camel.component.salesforce.config.approval-skip-entry-criteria* | Determines whether to evaluate the entry criteria for the process (true) or not (false) if the process definition name or ID isn’t null. If the process definition name or ID isn’t specified, this argument is ignored, and standard evaluation is followed based on process order. By default, the entry criteria isn’t skipped if it’s not set by this request. |  | Boolean
| *camel.component.salesforce.config.backoff-increment* | Backoff interval increment for Streaming connection restart attempts for failures beyond CometD auto-reconnect. |  | Long
| *camel.component.salesforce.config.batch-id* | Bulk API Batch ID |  | String
| *camel.component.salesforce.config.content-type* | Bulk API content type, one of XML, CSV, ZIP_XML, ZIP_CSV |  | ContentType
| *camel.component.salesforce.config.default-replay-id* | Default replayId setting if no value is found in {@link #initialReplayIdMap} |  | Long
| *camel.component.salesforce.config.format* | Payload format to use for Salesforce API calls, either JSON or XML, defaults to JSON |  | PayloadFormat
| *camel.component.salesforce.config.http-client* | Custom Jetty Http Client to use to connect to Salesforce. |  | SalesforceHttpClient
| *camel.component.salesforce.config.include-details* | Include details in Salesforce1 Analytics report, defaults to false. |  | Boolean
| *camel.component.salesforce.config.initial-replay-id-map* | Replay IDs to start from per channel name. |  | Map
| *camel.component.salesforce.config.instance-id* | Salesforce1 Analytics report execution instance ID |  | String
| *camel.component.salesforce.config.job-id* | Bulk API Job ID |  | String
| *camel.component.salesforce.config.limit* | Limit on number of returned records. Applicable to some of the API, check the Salesforce documentation. |  | Integer
| *camel.component.salesforce.config.max-backoff* | Maximum backoff interval for Streaming connection restart attempts for failures beyond CometD auto-reconnect. |  | Long
| *camel.component.salesforce.config.not-found-behaviour* | Sets the behaviour of 404 not found status received from Salesforce API. Should the body be set to NULL {@link NotFoundBehaviour#NULL} or should a exception be signaled on the exchange {@link NotFoundBehaviour#EXCEPTION} - the default. |  | NotFoundBehaviour
| *camel.component.salesforce.config.notify-for-fields* | Notify for fields, options are ALL, REFERENCED, SELECT, WHERE |  | NotifyForFieldsEnum
| *camel.component.salesforce.config.notify-for-operation-create* | Notify for create operation, defaults to false (API version >= 29.0) |  | Boolean
| *camel.component.salesforce.config.notify-for-operation-delete* | Notify for delete operation, defaults to false (API version >= 29.0) |  | Boolean
| *camel.component.salesforce.config.notify-for-operation-undelete* | Notify for un-delete operation, defaults to false (API version >= 29.0) |  | Boolean
| *camel.component.salesforce.config.notify-for-operation-update* | Notify for update operation, defaults to false (API version >= 29.0) |  | Boolean
| *camel.component.salesforce.config.notify-for-operations* | Notify for operations, options are ALL, CREATE, EXTENDED, UPDATE (API version < 29.0) |  | NotifyForOperations Enum
| *camel.component.salesforce.config.object-mapper* | Custom Jackson ObjectMapper to use when serializing/deserializing Salesforce objects. |  | ObjectMapper
| *camel.component.salesforce.config.raw-payload* | Use raw payload {@link String} for request and response (either JSON or XML depending on {@code format}), instead of DTOs, false by default | false | Boolean
| *camel.component.salesforce.config.report-id* | Salesforce1 Analytics report Id |  | String
| *camel.component.salesforce.config.report-metadata* | Salesforce1 Analytics report metadata for filtering |  | ReportMetadata
| *camel.component.salesforce.config.result-id* | Bulk API Result ID |  | String
| *camel.component.salesforce.config.s-object-blob-field-name* | SObject blob field name |  | String
| *camel.component.salesforce.config.s-object-class* | Fully qualified SObject class name, usually generated using camel-salesforce-maven-plugin |  | String
| *camel.component.salesforce.config.s-object-fields* | SObject fields to retrieve |  | String
| *camel.component.salesforce.config.s-object-id* | SObject ID if required by API |  | String
| *camel.component.salesforce.config.s-object-id-name* | SObject external ID field name |  | String
| *camel.component.salesforce.config.s-object-id-value* | SObject external ID field value |  | String
| *camel.component.salesforce.config.s-object-name* | SObject name if required or supported by API |  | String
| *camel.component.salesforce.config.s-object-query* | Salesforce SOQL query string |  | String
| *camel.component.salesforce.config.s-object-search* | Salesforce SOSL search string |  | String
| *camel.component.salesforce.config.serialize-nulls* | Should the NULL values of given DTO be serialized with empty (NULL) values. This affects only JSON data format. | false | Boolean
| *camel.component.salesforce.config.update-topic* | Whether to update an existing Push Topic when using the Streaming API, defaults to false | false | Boolean
| *camel.component.salesforce.enabled* | Enable salesforce component | true | Boolean
| *camel.component.salesforce.http-client-connection-timeout* | Connection timeout used by the HttpClient when connecting to the Salesforce server. | 60000 | Long
| *camel.component.salesforce.http-client-idle-timeout* | Timeout used by the HttpClient when waiting for response from the Salesforce server. | 10000 | Long
| *camel.component.salesforce.http-client-properties* | Used to set any properties that can be configured on the underlying HTTP client. Have a look at properties of SalesforceHttpClient and the Jetty HttpClient for all available options. |  | Map
| *camel.component.salesforce.http-proxy-auth-uri* | Used in authentication against the HTTP proxy server, needs to match the URI of the proxy server in order for the httpProxyUsername and httpProxyPassword to be used for authentication. |  | String
| *camel.component.salesforce.http-proxy-excluded-addresses* | A list of addresses for which HTTP proxy server should not be used. |  | Set
| *camel.component.salesforce.http-proxy-host* | Hostname of the HTTP proxy server to use. |  | String
| *camel.component.salesforce.http-proxy-included-addresses* | A list of addresses for which HTTP proxy server should be used. |  | Set
| *camel.component.salesforce.http-proxy-password* | Password to use to authenticate against the HTTP proxy server. |  | String
| *camel.component.salesforce.http-proxy-port* | Port number of the HTTP proxy server to use. |  | Integer
| *camel.component.salesforce.http-proxy-realm* | Realm of the proxy server, used in preemptive Basic/Digest authentication methods against the HTTP proxy server. |  | String
| *camel.component.salesforce.http-proxy-use-digest-auth* | If set to true Digest authentication will be used when authenticating to the HTTP proxy,otherwise Basic authorization method will be used | false | Boolean
| *camel.component.salesforce.http-proxy-username* | Username to use to authenticate against the HTTP proxy server. |  | String
| *camel.component.salesforce.instance-url* | URL of the Salesforce instance used after authentication, by default received from Salesforce on successful authentication |  | String
| *camel.component.salesforce.is-http-proxy-secure* | If set to false disables the use of TLS when accessing the HTTP proxy. | true | Boolean
| *camel.component.salesforce.is-http-proxy-socks4* | If set to true the configures the HTTP proxy to use as a SOCKS4 proxy. | false | Boolean
| *camel.component.salesforce.keystore* | KeyStore parameters to use in OAuth JWT flow. The KeyStore should contain only one entry with private key and certificate. Salesforce does not verify the certificate chain, so this can easily be a selfsigned certificate. Make sure that you upload the certificate to the corresponding connected app. The option is a org.apache.camel.support.jsse.KeyStoreParameters type. |  | String
| *camel.component.salesforce.lazy-login* | If set to true prevents the component from authenticating to Salesforce with the start of the component. You would generally set this to the (default) false and authenticate early and be immediately aware of any authentication issues. | false | Boolean
| *camel.component.salesforce.login-config.client-id* | Salesforce connected application Consumer Key |  | String
| *camel.component.salesforce.login-config.client-secret* | Salesforce connected application Consumer Secret |  | String
| *camel.component.salesforce.login-config.instance-url* | Configuration object for Salesforce login properties |  | String
| *camel.component.salesforce.login-config.keystore* | Keystore parameters for keystore containing certificate and private key needed for OAuth 2.0 JWT Bearer Token Flow. |  | KeyStoreParameters
| *camel.component.salesforce.login-config.lazy-login* | Flag to enable/disable lazy OAuth, default is false. When enabled, OAuth token retrieval or generation is not done until the first API call | false | Boolean
| *camel.component.salesforce.login-config.login-url* | Salesforce login URL, defaults to \\https://login.salesforce.com | https://login.salesforce.com | String
| *camel.component.salesforce.login-config.password* | Salesforce account password |  | String
| *camel.component.salesforce.login-config.refresh-token* | Salesforce connected application Consumer token |  | String
| *camel.component.salesforce.login-config.type* | Salesforce connected application Consumer token |  | AuthenticationType
| *camel.component.salesforce.login-config.user-name* | Salesforce account user name |  | String
| *camel.component.salesforce.login-url* | URL of the Salesforce instance used for authentication, by default set to \\https://login.salesforce.com | https://login.salesforce.com | String
| *camel.component.salesforce.long-polling-transport-properties* | Used to set any properties that can be configured on the LongPollingTransport used by the BayeuxClient (CometD) used by the streaming api |  | Map
| *camel.component.salesforce.packages* | In what packages are the generated DTO classes. Typically the classes would be generated using camel-salesforce-maven-plugin. Set it if using the generated DTOs to gain the benefit of using short SObject names in parameters/header values. |  | String[]
| *camel.component.salesforce.password* | Password used in OAuth flow to gain access to access token. It's easy to get started with password OAuth flow, but in general one should avoid it as it is deemed less secure than other flows. Make sure that you append security token to the end of the password if using one. |  | String
| *camel.component.salesforce.refresh-token* | Refresh token already obtained in the refresh token OAuth flow. One needs to setup a web application and configure a callback URL to receive the refresh token, or configure using the builtin callback at \\https://login.salesforce.com/services/oauth2/success or \\https://test.salesforce.com/services/oauth2/success and then retrive the refresh_token from the URL at the end of the flow. Note that in development organizations Salesforce allows hosting the callback web application at localhost. |  | String
| *camel.component.salesforce.ssl-context-parameters* | SSL parameters to use, see SSLContextParameters class for all available options. The option is a org.apache.camel.support.jsse.SSLContextParameters type. |  | String
| *camel.component.salesforce.use-global-ssl-context-parameters* | Enable usage of global SSL context parameters | false | Boolean
| *camel.component.salesforce.user-name* | Username used in OAuth flow to gain access to access token. It's easy to get started with password OAuth flow, but in general one should avoid it as it is deemed less secure than other flows. |  | String
|===
// spring-boot-auto-configure options: END
",12174,False,2171.52135704662,median
"/**
 * @file ir_grammar.hpp
 * @author Farenain
 * @brief Header file which includes all the grammar of the IR, this will be
 *        used as header file by all the intermediate representation cpp files.
 * @version 0.1
 * @date 2021-11-09
 *
 * @copyright Copyright (c) 2021
 *
 */

#include <iostream>
#include <sstream>
#include <fstream>
#include <memory>
#include <vector>
#include <list>

// lifters
#include ""ir_x86.hpp""
#include ""ir_dalvik.hpp""

namespace KUNAI
{
    namespace MJOLNIR
    {
        class IRBlock;
        class IRStmnt;
        class IRUJmp;
        class IRCJmp;
        class IRRet;
        class IRNop;
        class IRSwitch;
        class IRExpr;
        class IRBinOp;
        class IRUnaryOp;
        class IRAssign;
        class IRCall;
        class IRLoad;
        class IRStore;
        class IRZComp;
        class IRBComp;
        class IRType;
        class IRReg;
        class IRTempReg;
        class IRConstInt;
        class IRMemory;
        class IRString;
        class IRClass;
        class IRCallee;

        /**
         * Useful methods you can use
         * for getting information about
         * the instructions.
         */

        /**
         * @brief Check if the given statement is a IRField.
         *
         * @param instr
         * @return true
         * @return false
         */
        bool is_ir_field(std::shared_ptr<IRStmnt> instr);

        /**
         * @brief Check if given statement object is
         *        a callee method/function
         *
         * @param instr
         * @return true
         * @return false
         */
        bool is_ir_callee(std::shared_ptr<IRStmnt> instr);

        /**
         * @brief Check if given statement object is a class.
         *
         * @param instr
         * @return true
         * @return false
         */
        bool is_ir_class(std::shared_ptr<IRStmnt> instr);

        /**
         * @brief Check if given statement object is a string.
         *
         * @param instr
         * @return true
         * @return false
         */
        bool is_ir_string(std::shared_ptr<IRStmnt> instr);

        /**
         * @brief Check if given statement object is a memory.
         *
         * @param instr
         * @return true
         * @return false
         */
        bool is_ir_memory(std::shared_ptr<IRStmnt> instr);

        /**
         * @brief Check if given statement object is a constant integer.
         *
         * @param instr
         * @return true
         * @return false
         */
        bool is_ir_const_int(std::shared_ptr<IRStmnt> instr);

        /**
         * @brief Check if a given statement object is a temporal register.
         *
         * @param instr
         * @return true
         * @return false
         */
        bool is_ir_temp_reg(std::shared_ptr<IRStmnt> instr);

        /**
         * @brief Check if the given statement object is
         *        a register.
         *
         * @param instr
         * @return true
         * @return false
         */
        bool is_ir_register(std::shared_ptr<IRStmnt> instr);

        /**
         * @brief Check if the given statement is an unconditional jump instruction.
         *
         * @param instr
         * @return true
         * @return false
         */
        bool is_unconditional_jump(std::shared_ptr<IRStmnt> instr);

        /**
         * @brief Check if the given statement is a conditional jump instruction.
         *
         * @param instr
         * @return true
         * @return false
         */
        bool is_conditional_jump(std::shared_ptr<IRStmnt> instr);

        /**
         * @brief Check if given statement is a ret instruction.
         *
         * @param instr
         * @return true
         * @return false
         */
        bool is_ret(std::shared_ptr<IRStmnt> instr);

        /**
         * @brief Check if given statement is a call instruction.
         *
         * @param instr
         * @return true
         * @return false
         */
        bool is_call(std::shared_ptr<IRStmnt> instr);

        /**
         * @brief Check if given statement is a switch instruction.
         *
         * @param instr
         * @return true
         * @return false
         */
        bool is_switch(std::shared_ptr<IRStmnt> instr);

        class IRBlock
        {
        public:
            /**
             * @brief Constructor of IRBlock, this class represent blocks of statements.
             * @return void
             */
            IRBlock();

            /**
             * @brief Destructor of IRBlock, nothing to be done here.
             * @return void
             */
            ~IRBlock() = default;

            /**
             * @brief Append one statement to the list, we use the class std::list as it allows us to
             *        insert instructions between other instructions easily.
             * @param statement: statement to append to the list.
             * @return void
             */
            void append_statement_to_block(std::shared_ptr<IRStmnt> statement)
            {
                block_statements.push_back(statement);
            }

            /**
             * @brief Remove on of the statements given its position.
             * @param pos: position of the statement in the vector.
             * @return bool
             */
            bool delete_statement_by_position(size_t pos);

            /**
             * @brief Get the number of statements from the block.
             * @return size_t
             */
            size_t get_number_of_statements()
            {
                return block_statements.size();
            }

            /**
             * @brief Get the list of statements.
             * @return std::list<std::shared_ptr<IRStmnt>>
             */
            std::list<std::shared_ptr<IRStmnt>> &get_statements()
            {
                return block_statements;
            }

            /**
             * @brief Set the start_idx value from the block.
             *
             * @param start_idx
             */
            void set_start_idx(uint64_t start_idx)
            {
                this->start_idx = start_idx;
            }

            /**
             * @brief Set the end_idx value from the block.
             *
             * @param end_idx
             */
            void set_end_idx(uint64_t end_idx)
            {
                this->end_idx = end_idx;
            }

            /**
             * @brief Return the start_idx of the current block.
             *
             * @return uint64_t
             */
            uint64_t get_start_idx()
            {
                return start_idx;
            }

            /**
             * @brief Return the end_idx of the current block.
             *
             * @return uint64_t
             */
            uint64_t get_end_idx()
            {
                return end_idx;
            }

            /**
             * @brief Return a string with a representative name of the basic block.
             *
             * @return std::string
             */
            std::string get_name();

            /**
             * @brief Return a string representation of the basic block.
             *
             * @return std::string
             */
            std::string to_string();

        private:
            //! starting idx and last idx (used for jump calculation)
            uint64_t start_idx, end_idx;
            //! statements from the basic block.
            std::list<std::shared_ptr<IRStmnt>> block_statements;
        };

        class IRStmnt
        {
        public:
            enum stmnt_type_t
            {
                UJMP_STMNT_T,
                CJMP_STMNT_T,
                RET_STMNT_T,
                NOP_STMNT_T,
                SWITCH_STMNT_T,
                EXPR_STMNT_T,
                NONE_STMNT_T = 99 // used to finish the chain of statements
            };

            /**
             * @brief Constructor of IRStmnt.
             * @param stmnt_type: type of the statement.
             * @return void
             */
            IRStmnt(stmnt_type_t stmnt_type);

            /**
             * @brief Destroy the IRStmnt object
             */
            virtual ~IRStmnt() = default;

            /**
             * @brief Get the type of the statement.
             * @return stmnt_type_t
             */
            stmnt_type_t get_statement_type()
            {
                return stmnt_type;
            }

            /**
             * @brief Return correct string representation for IRStmnt.
             *
             * @return std::string
             */
            std::string to_string();

        private:
            //! Type of the statement.
            stmnt_type_t stmnt_type;
        };

        class IRUJmp : public IRStmnt
        {
        public:
            /**
             * @brief Constructor of IRUJmp, this kind of class is an unconditional jump with just one target.
             * @param target: target of the jump.
             * @return void
             */
            IRUJmp(uint64_t addr, std::shared_ptr<IRBlock> target);

            /**
             * @brief Destructor of IRUJmp, nothing to be done here.
             * @return void
             */
            ~IRUJmp() = default;

            /**
             * @brief Set the jump target block.
             *
             * @param target: block target where will jump.
             */
            void set_jump_target(std::shared_ptr<IRBlock> target)
            {
                this->target = target;
            }

            /**
             * @brief Get the target of the unconditional jump.
             * @return std::shared_ptr<IRBlock>
             */
            std::shared_ptr<IRBlock> get_jump_target()
            {
                return target;
            }

            /**
             * @brief Return the address or offset from the jump.
             *
             * @return uint64_t
             */
            uint64_t get_jump_addr()
            {
                return addr;
            }

            /**
             * @brief Return a string representation of IRUJmp.
             *
             * @return std::string
             */
            std::string to_string();

        private:
            //! offset or address of target
            uint64_t addr;
            //! target where the jump will fall
            std::shared_ptr<IRBlock> target;
        };

        class IRCJmp : public IRStmnt
        {
        public:
            /**
             * @brief Constructor of IRCJmp, this represent a conditional jump.
             * @param addr: address where jump goes if not taken.
             * @param condition: condition (commonly a register from a CMP) that if true takes target.
             * @param target: block target of the conditional jump.
             * @param fallthrough: block of the statement if the condition is not true.
             * @return void
             */
            IRCJmp(uint64_t addr, std::shared_ptr<IRStmnt> condition, std::shared_ptr<IRBlock> target, std::shared_ptr<IRBlock> fallthrough);

            /**
             * @brief Destructor of IRCJmp, nothing to be done.
             * @return void
             */
            ~IRCJmp() = default;

            /**
             * @brief Get address target from the jump.
             *
             * @return uint64_t
             */
            uint64_t get_addr()
            {
                return addr;
            }

            /**
             * @brief Get the condition of the conditional jump.
             * @return std::shared_ptr<IRStmnt>
             */
            std::shared_ptr<IRStmnt> get_condition()
            {
                return condition;
            }

            /**
             * @brief Set the target block.
             *
             * @param target: target where jump would go if taken.
             */
            void set_jump_target(std::shared_ptr<IRBlock> target)
            {
                this->target = target;
            }

            /**
             * @brief Get the jump target if the condition is true.
             * @return std::shared_ptr<IRStmnt>
             */
            std::shared_ptr<IRBlock> get_jump_target()
            {
                return target;
            }

            /**
             * @brief Set fallthrough block
             *
             * @param fallthrough: block where jump would go if not taken.
             */
            void set_fallthrough_Target(std::shared_ptr<IRBlock> fallthrough)
            {
                this->fallthrough = fallthrough;
            }

            /**
             * @brief Get the fallthrough target in case condition is false.
             * @return std::shared_ptr<IRStmnt>
             */
            std::shared_ptr<IRBlock> get_fallthrough_target()
            {
                return fallthrough;
            }

            /**
             * @brief Return string representation of IRCJmp.
             *
             * @return std::string
             */
            std::string to_string();

        private:
            //! offset or address of target
            uint64_t addr;
            //! Condition for taking the target jump
            std::shared_ptr<IRStmnt> condition;
            //! target where the jump will fall
            std::shared_ptr<IRBlock> target;
            //! fallthrough target.
            std::shared_ptr<IRBlock> fallthrough;
        };

        class IRRet : public IRStmnt
        {
        public:
            /**
             * @brief Constructor of IRRet, this statement represent a return instruction.
             * @param ret_value: return value, this can be a NONE type or a register.
             * @return void
             */
            IRRet(std::shared_ptr<IRStmnt> ret_value);

            /**
             * @brief Destructor of IRRet, nothing to be done.
             * @return void
             */
            ~IRRet() = default;

            /**
             * @brief Get the return value this will be a NONE IRType, or an IRReg.
             * @return std::shared_ptr<IRStmnt>
             */
            std::shared_ptr<IRStmnt> get_return_value()
            {
                return ret_value;
            }

            /**
             * @brief Return the string representation of IRRet.
             *
             * @return std::string
             */
            std::string to_string();

        private:
            //! Returned value, commonly a NONE IRType, or an IRReg.
            std::shared_ptr<IRStmnt> ret_value;
        };

        class IRNop : public IRStmnt
        {
        public:
            /**
             * @brief Construct a new IRNop::IRNop object
             */
            IRNop();

            /**
             * @brief Destroy the IRNop::IRNop object
             */
            ~IRNop() = default;

            std::string to_string()
            {
                return ""IRNop[]"";
            }
        };

        class IRSwitch : public IRStmnt
        {
        public:
            /**
             * @brief Construct a new IRSwitch::IRSwitch object
             *
             * @param offsets: offsets where switch branch goes.
             * @param condition: possible condition checked on switch.
             * @param constants_checks: values checked on switch (if any)
             */
            IRSwitch(std::vector<int32_t> offsets,
                     std::shared_ptr<IRExpr> condition,
                     std::vector<int32_t> constants_checks);

            /**
             * @brief Destroy the IRSwitch::IRSwitch object
             */
            ~IRSwitch() = default;

            /**
             * @brief Return the offsets where switch can jump to.
             *
             * @return std::vector<int32_t>
             */
            const std::vector<int32_t> &get_offsets() const
            {
                return offsets;
            }

            /**
             * @brief Return the possible condition checked on switch.
             *
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_condition()
            {
                return condition;
            }

            /**
             * @brief Return possible constant checks used in switch.
             *
             * @return std::vector<int32_t>
             */
            const std::vector<int32_t> &get_constants_checks() const
            {
                return constants_checks;
            }

            /**
             * @brief To string method print IR instruction.
             *
             * @return std::string
             */
            std::string to_string();

        private:
            //! switch offsets where instruction will jump.
            std::vector<int32_t> offsets;
            //! condition taken to decide where to jump
            std::shared_ptr<IRExpr> condition;
            //! conditions checked during switch.
            std::vector<int32_t> constants_checks;
        };

        class IRExpr : public IRStmnt
        {
        public:
            enum expr_type_t
            {
                BINOP_EXPR_T,
                UNARYOP_EXPR_T,
                ASSIGN_EXPR_T,
                CALL_EXPR_T,
                TYPE_EXPR_T,
                LOAD_EXPR_T,
                STORE_EXPR_T,
                ZCOMP_EXPR_T,
                BCOMP_EXPR_T,
                NEW_EXPR_T,
                NONE_EXPR_T = 99 // used to finish the expressions
            };

            /**
             * @brief Constructor of IRExpr this will be the most common type of instruction of the IR.
             * @param type: type of the expression (type of the instruction).
             * @param left: left expression for the AST.
             * @param right: right expression for the AST.
             * @return void
             */
            IRExpr(expr_type_t type, std::shared_ptr<IRExpr> left, std::shared_ptr<IRExpr> right);

            /**
             * @brief Destructor of IRExpr, nothing to be done.
             * @return void
             */
            ~IRExpr() = default;

            /**
             * @brief Set the left expression (for the AST).
             * @param left: left part of expression for the AST.
             */
            void set_left_expr(std::shared_ptr<IRExpr> left)
            {
                this->left = left;
            }

            /**
             * @brief Set the right expression (for the AST).
             * @param left: right part of expression for the AST.
             */
            void set_right_expr(std::shared_ptr<IRExpr> right)
            {
                this->right = right;
            }

            /**
             * @brief Get the left expression (from the AST)
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_left_expr()
            {
                return left;
            }

            /**
             * @brief Get the right expression (from the AST)
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_right_expr()
            {
                return right;
            }

            /**
             * @brief Get the type of current expression.
             * @return expr_type_t
             */
            expr_type_t get_expression_type()
            {
                return type;
            }

            /**
             * @brief Return the correct string representation for the IRExpr.
             *
             * @return std::string
             */
            std::string to_string();

            /**
             * @brief Comparison of IRExpr instructions.
             * @return bool
             */
            bool equals(std::shared_ptr<IRExpr> irexpr);

            /**
             * @brief Operator == for IRExpr.
             * @param ope1: first operation to compare.
             * @param ope2: second operation to compare.
             * @return bool
             */
            friend bool operator==(IRExpr &, IRExpr &);

        private:
            //! pointers used for the abstract syntax tree
            //! these pointers are common in the IRExpr.
            std::shared_ptr<IRExpr> left;
            std::shared_ptr<IRExpr> right;

            //! ir expression as string
            std::string ir_expr_str;

            //! expression type
            expr_type_t type;
        };

        class IRBinOp : public IRExpr
        {
        public:
            enum bin_op_t
            {
                // common arithmetic instructions
                ADD_OP_T,
                SUB_OP_T,
                S_MUL_OP_T,
                U_MUL_OP_T,
                S_DIV_OP_T,
                U_DIV_OP_T,
                MOD_OP_T,
                // common logic instructions
                AND_OP_T,
                XOR_OP_T,
                OR_OP_T,
                SHL_OP_T,
                SHR_OP_T,
                USHR_OP_T,
            };

            /**
             * @brief Constructor of IRBinOp, this class represent different instructions with two operators and a result.
             * @param bin_op_type: type of binary operation.
             * @param result: where result of operation is stored.
             * @param op1: first operand of the operation.
             * @param op2: second operand of the operation.
             * @param left: left expression for the AST.
             * @param right: right expression for the AST.
             * @return void
             */
            IRBinOp(bin_op_t bin_op_type,
                    std::shared_ptr<IRExpr> result,
                    std::shared_ptr<IRExpr> op1,
                    std::shared_ptr<IRExpr> op2,
                    std::shared_ptr<IRExpr> left,
                    std::shared_ptr<IRExpr> right);

            /**
             * @brief Destructor of IRBinOp.
             * @return void
             */
            ~IRBinOp() = default;

            /**
             * @brief Get the type of binary operation applied.
             * @return bin_op_t
             */
            bin_op_t get_bin_op_type()
            {
                return bin_op_type;
            }

            /**
             * @brief Get expression of type where result is stored.
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_result()
            {
                return result;
            }

            /**
             * @brief Get the operand 1 of the operation.
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_op1()
            {
                return op1;
            }

            /**
             * @brief Get the operand 2 of the operation.
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_op2()
            {
                return op2;
            }

            /**
             * @brief Return a string representation of IRBinOp.
             *
             * @return std::string
             */
            std::string to_string();

            /**
             * @brief Comparison of IRBinOp instructions.
             * @return bool
             */
            bool equals(std::shared_ptr<IRBinOp> irbinop);

            /**
             * @brief Operator == for IRBinOp.
             * @param ope1: first operation to compare.
             * @param ope2: second operation to compare.
             * @return bool
             */
            friend bool operator==(IRBinOp &, IRBinOp &);

        private:
            //! type of binary operation
            bin_op_t bin_op_type;
            //! IRBinOp =>  IRExpr(result) = IRExpr(op1) <binop> IRExpr(op2)
            //! for the result we will have an IRExpr too.
            std::shared_ptr<IRExpr> result;
            //! now each one of the operators
            std::shared_ptr<IRExpr> op1;
            std::shared_ptr<IRExpr> op2;
        };

        class IRUnaryOp : public IRExpr
        {
        public:
            enum unary_op_t
            {
                INC_OP_T,
                DEC_OP_T,
                NOT_OP_T,
                NEG_OP_T,
                CAST_OP_T,  // maybe not used in binary
                Z_EXT_OP_T, // zero extend
                S_EXT_OP_T  // sign extend
            };

            enum cast_type_t
            {
                NONE_CAST,
                TO_BYTE,
                TO_CHAR,
                TO_SHORT,
                TO_INT,
                TO_LONG,
                TO_FLOAT,
                TO_DOUBLE,
                TO_ADDR,
                TO_BOOLEAN,
                TO_CLASS,
            };

            /**
             * @brief Constructor of IRUnaryOp class, this will get different values for the instruction.
             * @param unary_op_type: type of unary operation.
             * @param result: where the operation stores the result.
             * @param op: operand from the instruction.
             * @param left: left expression for the AST.
             * @param right: right expression for the AST.
             * @return void
             */
            IRUnaryOp(unary_op_t unary_op_type,
                      std::shared_ptr<IRExpr> result,
                      std::shared_ptr<IRExpr> op,
                      std::shared_ptr<IRExpr> left,
                      std::shared_ptr<IRExpr> right);

            /**
             * @brief Constructor of IRUnaryOp class, this will get different values for the instruction.
             * @param unary_op_type: type of unary operation.
             * @param cast_type: instruction is cast, specify type of cast.
             * @param result: where the operation stores the result.
             * @param op: operand from the instruction.
             * @param left: left expression for the AST.
             * @param right: right expression for the AST.
             * @return void
             */
            IRUnaryOp(unary_op_t unary_op_type,
                      cast_type_t cast_type,
                      std::shared_ptr<IRExpr> result,
                      std::shared_ptr<IRExpr> op,
                      std::shared_ptr<IRExpr> left,
                      std::shared_ptr<IRExpr> right);

            /**
             * @brief  Constructor of IRUnaryOp class, this will get different values for the instruction.
             *
             * @param unary_op_type: type of unary operation.
             * @param cast_type: instruction is cast, specify type of cast.
             * @param class_name: if cast is TO_CLASS, specify the name of the class.
             * @param result: where the operation stores the result.
             * @param op: operand from the instruction.
             * @param left: left expression for the AST.
             * @param right: right expression for the AST.
             * @return void
             */
            IRUnaryOp(unary_op_t unary_op_type,
                      cast_type_t cast_type,
                      std::string class_name,
                      std::shared_ptr<IRExpr> result,
                      std::shared_ptr<IRExpr> op,
                      std::shared_ptr<IRExpr> left,
                      std::shared_ptr<IRExpr> right);

            /**
             * @brief Destructor of IRUnaryOp class, nothing to be done.
             * @return void
             */
            ~IRUnaryOp() = default;

            /**
             * @brief Get the type of unary operation of the instruction.
             * @return unary_op_t
             */
            unary_op_t get_unary_op_type()
            {
                return unary_op_type;
            }

            /**
             * @brief Get the IRExpr where result of the operation would be stored.
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_result()
            {
                return result;
            }

            /**
             * @brief Get the IRExpr of the operand of the instruction.
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_op()
            {
                return op;
            }

            /**
             * @brief Set the cast type of the Cast operation.
             * @param cast_type: type of cast to assign.
             * @return void
             */
            void set_cast_type(cast_type_t cast_type)
            {
                this->cast_type = cast_type;
            }

            /**
             * @brief Get the type of cast of the instruction.
             * @return cast_type_t
             */
            cast_type_t get_cast_type()
            {
                return cast_type;
            }

            /**
             * @brief Get the class name where register is casted to.
             *
             * @return std::string
             */
            std::string get_class_cast()
            {
                return class_name;
            }

            /**
             * @brief Return a string representation of IRUnaryOp.
             *
             * @return std::string
             */
            std::string to_string();

            /**
             * @brief Comparison of IRUnaryOp instructions.
             * @return bool
             */
            bool equals(std::shared_ptr<IRUnaryOp> irunaryop);

            /**
             * @brief Operator == for IRUnaryOp.
             * @param ope1: first operation to compare.
             * @param ope2: second operation to compare.
             * @return bool
             */
            friend bool operator==(IRUnaryOp &, IRUnaryOp &);

        private:
            //! type of unary operation =D
            unary_op_t unary_op_type;
            //! used for casting operations
            cast_type_t cast_type;
            //! Class casted to
            std::string class_name;
            //! IRUnaryOp => IRExpr(result) = <unaryop> IRExpr(op)
            //! an IRExpr for where the result is stored.
            std::shared_ptr<IRExpr> result;
            // operator
            std::shared_ptr<IRExpr> op;
        };

        class IRAssign : public IRExpr
        {
        public:
            /**
             * @brief Constructor of IRAssign, this one will have just those from the basic types,
             *        no more information is needed, the left part and the right part.
             * @param destination: type where the value will be assigned.
             * @param source: type from where the value is taken.
             * @param left: left part of the assignment (also used for AST).
             * @param right: right part of the assignment (also used for AST).
             * @return void
             */
            IRAssign(std::shared_ptr<IRExpr> destination,
                     std::shared_ptr<IRExpr> source,
                     std::shared_ptr<IRExpr> left,
                     std::shared_ptr<IRExpr> right);

            /**
             * @brief Destructor of IRAssign, nothing to be done here.
             * @return void
             */
            ~IRAssign() = default;

            /**
             * @brief Get destination type where value is assigned.
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_destination()
            {
                return destination;
            }

            /**
             * @brief Get the source operand from the assignment.
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_source()
            {
                return source;
            }

            /**
             * @brief Return the string representation of IRAssign.
             *
             * @return std::string
             */
            std::string to_string();

            /**
             * @brief Comparison of IRAssign instructions.
             * @return bool
             */
            bool equals(std::shared_ptr<IRAssign> irassign);

            /**
             * @brief Operator == for IRAssign.
             * @param ope1: first operation to compare.
             * @param ope2: second operation to compare.
             * @return bool
             */
            friend bool operator==(IRAssign &, IRAssign &);

        private:
            //! destination where the value will be stored.
            std::shared_ptr<IRExpr> destination;
            //! source expression from where the value is taken
            std::shared_ptr<IRExpr> source;
        };

        class IRCall : public IRExpr
        {
        public:
            enum call_type_t
            {
                INTERNAL_CALL_T,  // call to internal component
                EXTERNAL_CALL_T,  // call to external library (example DLL, .so file, external component, etc)
                SYSCALL_T,        // a syscall type
                NONE_CALL_T = 99, // Not specified
            };

            /**
             * @brief Constructor of IRCall, this expression represents a Call to a function or method.
             * @param callee: function/method called represented as IRExpr (super-super-class of IRCallee).
             * @param args: vector of arguments to the function/method.
             * @param left: left part of the call (used for AST).
             * @param right: right part of the call (used for AST).
             * @return void
             */
            IRCall(std::shared_ptr<IRExpr> callee,
                   std::vector<std::shared_ptr<IRExpr>> args,
                   std::shared_ptr<IRExpr> left,
                   std::shared_ptr<IRExpr> right);

            /**
             * @brief Constructor of IRCall, this expression represents a Call to a function or method.
             * @param callee: function/method called represented as IRExpr (super-super-class of IRCallee).
             * @param call_type: type of call instruction.
             * @param args: vector of arguments to the function/method.
             * @param left: left part of the call (used for AST).
             * @param right: right part of the call (used for AST).
             */
            IRCall(std::shared_ptr<IRExpr> callee,
                   call_type_t call_type,
                   std::vector<std::shared_ptr<IRExpr>> args,
                   std::shared_ptr<IRExpr> left,
                   std::shared_ptr<IRExpr> right);

            /**
             * @brief Destructor of IRCall, nothing to be done.
             * @return void
             */
            ~IRCall() = default;

            /**
             * @brief Get the callee object from the function/method called.
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_callee()
            {
                return callee;
            }

            /**
             * @brief Get the arguments from the call.
             * @return std::vector<std::shared_ptr<IRExpr>>
             */
            const std::vector<std::shared_ptr<IRExpr>> &get_args() const
            {
                return args;
            }

            /**
             * @brief Get a string representation of IRCall.
             *
             * @return std::string
             */
            std::string to_string();

            /**
             * @brief Set the ret_val object
             *
             * @param ret_val
             */
            void set_ret_val(std::shared_ptr<IRExpr> ret_val)
            {
                this->ret_val = ret_val;
            }

            /**
             * @brief Get the ret_val object
             *
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_ret_val()
            {
                return ret_val;
            }

            /**
             * @brief Comparison of IRCall instructions.
             * @return bool
             */
            bool equals(std::shared_ptr<IRCall> ircall);

            /**
             * @brief Operator == for IRCall.
             * @param ope1: first operation to compare.
             * @param ope2: second operation to compare.
             * @return bool
             */
            friend bool operator==(IRCall &, IRCall &);

        private:
            //! Type of call
            call_type_t call_type;
            //! Type representing the function/method called
            std::shared_ptr<IRExpr> callee;
            //! Vector with possible arguments
            std::vector<std::shared_ptr<IRExpr>> args;
            //! Return value (if it's for example a register)
            std::shared_ptr<IRExpr> ret_val;
        };

        class IRLoad : public IRExpr
        {
        public:
            /**
             * @brief Constructor of IRLoad class, this class represent a load from memory (using memory or using register).
             * @param destination: register where the value will be stored.
             * @param source: expression from where the memory will be retrieved.
             * @param size: loaded size.
             * @param left: left part of the load (used for AST).
             * @param right: right part of the load (used for AST).
             * @return void
             */
            IRLoad(std::shared_ptr<IRExpr> destination,
                   std::shared_ptr<IRExpr> source,
                   std::uint32_t size,
                   std::shared_ptr<IRExpr> left,
                   std::shared_ptr<IRExpr> right);

            /**
             * @brief Constructor of IRLoad class, this class represent a load from memory (using memory or using register).
             * @param destination: register where the value will be stored.
             * @param source: expression from where the memory will be retrieved.
             * @param index: index from the load if this is referenced with an index.
             * @param size: loaded size.
             * @param left: left part of the load (used for AST).
             * @param right: right part of the load (used for AST).
             * @return void
             */
            IRLoad(std::shared_ptr<IRExpr> destination,
                   std::shared_ptr<IRExpr> source,
                   std::shared_ptr<IRExpr> index,
                   std::uint32_t size,
                   std::shared_ptr<IRExpr> left,
                   std::shared_ptr<IRExpr> right);

            /**
             * @brief Destructor of IRLoad, nothing to be done.
             * @return void
             */
            ~IRLoad() = default;

            /**
             * @brief Get destination register from the load.
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_destination()
            {
                return destination;
            }

            /**
             * @brief Get the expression from where value is loaded.
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_source()
            {
                return source;
            }

            /**
             * @brief Get the index of the instruction used.
             *
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_index()
            {
                return index;
            }

            /**
             * @brief Get the loaded size.
             * @return std::uint32_t
             */
            std::uint32_t get_size()
            {
                return size;
            }

            /**
             * @brief Return string representation of IRLoad.
             *
             * @return std::string
             */
            std::string to_string();

            /**
             * @brief Comparison of IRLoad instruction.
             * @return bool
             */
            bool equals(std::shared_ptr<IRLoad> irload);

            /**
             * @brief Operator == for IRLoad.
             * @param ope1: first operation to compare.
             * @param ope2: second operation to compare.
             * @return bool
             */
            friend bool operator==(IRLoad &, IRLoad &);

        private:
            //! Register where the memory pointed by a register will be loaded.
            std::shared_ptr<IRExpr> destination;
            //! Expression from where memory is read.
            std::shared_ptr<IRExpr> source;
            //! Index if this is referenced by for example a register.
            std::shared_ptr<IRExpr> index;
            //! Size of loaded value
            std::uint32_t size;
        };

        class IRStore : public IRExpr
        {
        public:
            /**
             * @brief Constructor of IRStore class, this represent an store to memory instruction.
             * @param destination: Expression where value is written to.
             * @param source: register with the value to be stored.
             * @param size: size of the stored value.
             * @param left: left part of the store (used for AST).
             * @param right: right part of the store (used for AST).
             * @return void
             */
            IRStore(std::shared_ptr<IRExpr> destination,
                    std::shared_ptr<IRExpr> source,
                    std::uint32_t size,
                    std::shared_ptr<IRExpr> left,
                    std::shared_ptr<IRExpr> right);

            /**
             * @brief Constructor of IRStore class, this represent an store to memory instruction.
             * @param destination: Expression where value is written to.
             * @param source: register with the value to be stored.
             * @param index: index where value is stored.
             * @param size: size of the stored value.
             * @param left: left part of the store (used for AST).
             * @param right: right part of the store (used for AST).
             * @return void
             */
            IRStore(std::shared_ptr<IRExpr> destination,
                    std::shared_ptr<IRExpr> source,
                    std::shared_ptr<IRExpr> index,
                    std::uint32_t size,
                    std::shared_ptr<IRExpr> left,
                    std::shared_ptr<IRExpr> right);

            /**
             * @brief Destructor of IRStore class, nothing to be done.
             * @return void
             */
            ~IRStore() = default;

            /**
             * @brief Get expression destination where value is going to be written.
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_destination()
            {
                return destination;
            }

            /**
             * @brief Get source where value is taken from.
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_source()
            {
                return source;
            }

            /**
             * @brief Get size of value to be written.
             * @return std::uint32_t
             */
            std::uint32_t get_size()
            {
                return size;
            }

            /**
             * @brief Return a string representation of IRStore.
             *
             * @return std::string
             */
            std::string to_string();

            /**
             * @brief Comparison of IRStore instructions.
             * @return bool
             */
            bool equals(std::shared_ptr<IRStore> irstore);

            /**
             * @brief Operator == for IRStore.
             * @param ope1: first operation to compare.
             * @param ope2: second operation to compare.
             * @return bool
             */
            friend bool operator==(IRStore &, IRStore &);

        private:
            //! Memory pointed by register where value will be stored.
            std::shared_ptr<IRExpr> destination;
            //! Expression with source of value to be stored.
            std::shared_ptr<IRExpr> source;
            //! Index if this is referenced by for example a register.
            std::shared_ptr<IRExpr> index;
            //! Size of stored value
            std::uint32_t size;
        };

        class IRZComp : public IRExpr
        {
        public:
            enum zero_comp_t
            {
                EQUAL_ZERO_T,       // ==
                NOT_EQUAL_ZERO_T,   // !=
                LOWER_ZERO_T,       // <
                GREATER_EQUAL_ZERO, // >=
                GREATER_ZERO_T,     // >
                LOWER_EQUAL_ZERO    // <=
            };

            /**
             * @brief Constructor of IRZComp, this is a comparison with zero.
             * @param comp: type of comparison (== or !=).
             * @param result: register or temporal register where result is stored.
             * @param reg: register used in the comparison.
             * @param left: left part of the zero comparison (used for AST).
             * @param right: right part of the zero comparison (used for AST).
             * @return void
             */
            IRZComp(zero_comp_t comp,
                    std::shared_ptr<IRExpr> result,
                    std::shared_ptr<IRExpr> reg,
                    std::shared_ptr<IRExpr> left,
                    std::shared_ptr<IRExpr> right);

            /**
             * @brief Destructor of IRZComp, nothing to be done.
             * @return void
             */
            ~IRZComp() = default;

            /**
             * @brief Return the result register or temporal register.
             *
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_result()
            {
                return result;
            }

            /**
             * @brief Get register used in the comparison.
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_reg()
            {
                return reg;
            }

            /**
             * @brief Get the type of comparison with zero.
             * @return zero_comp_t
             */
            zero_comp_t get_comparison()
            {
                return comp;
            }

            /**
             * @brief Return the string expression of IRZComp.
             *
             * @return std::string
             */
            std::string to_string();

            /**
             * @brief Comparison of IRZComp instruction with shared_ptr.
             * @return bool
             */
            bool equals(std::shared_ptr<IRZComp> irzcomp);

            /**
             * @brief Operator == for IRZComp.
             * @param ope1: first operation to compare.
             * @param ope2: second operation to compare.
             * @return bool
             */
            friend bool operator==(IRZComp &, IRZComp &);

        private:
            //! Register where result is stored
            std::shared_ptr<IRExpr> result;
            //! Register for comparison with zero.
            std::shared_ptr<IRExpr> reg;
            //! Type of comparison
            zero_comp_t comp;
        };

        class IRBComp : public IRExpr
        {
        public:
            enum comp_t
            {
                EQUAL_T,         // ==
                NOT_EQUAL_T,     // !=
                GREATER_T,       // >
                GREATER_EQUAL_T, // >=
                LOWER_T,         // <
                LOWER_EQUAL_T,   // <=
                ABOVE_T,         // (unsigned) >
                ABOVE_EQUAL_T,   // (unsigned) >=
                BELOW_T,         // (unsigned) <
            };

            /**
             * @brief Constructor of IRBComp, this class represent a comparison between two types.
             * @param comp: type of comparison from an enum.
             * @param result: register or temporal register where result is stored.
             * @param reg1: first type where the comparison is applied.
             * @param reg2: second type where the comparison is applied.
             * @param left: left part of the comparison (used for AST).
             * @param right: right part of the comparison (used for AST).
             * @return void
             */
            IRBComp(comp_t comp,
                    std::shared_ptr<IRExpr> result,
                    std::shared_ptr<IRExpr> reg1,
                    std::shared_ptr<IRExpr> reg2,
                    std::shared_ptr<IRExpr> left,
                    std::shared_ptr<IRExpr> right);

            /**
             * @brief Destructor of IRBComp, nothing to be done.
             * @return void
             */
            ~IRBComp() = default;

            /**
             * @brief Get the result register or temporal register.
             *
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_result()
            {
                return result;
            }

            /**
             * @brief Return the first part of the comparison.
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_reg1()
            {
                return reg1;
            }

            /**
             * @brief Return the second part of the comparison.
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_reg2()
            {
                return reg2;
            }

            /**
             * @brief Return the type of comparison
             * @return comp_t
             */
            comp_t get_comparison()
            {
                return comp;
            }

            /**
             * @brief Return the string representation of IRBComp.
             *
             * @return std::string
             */
            std::string to_string();

            /**
             * @brief Comparison of IRBComp instruction with shared_ptr.
             * @return bool
             */
            bool equals(std::shared_ptr<IRBComp> bcomp);

            /**
             * @brief Operator == for IRBComp.
             * @param ope1: first operation to compare.
             * @param ope2: second operation to compare.
             * @return bool
             */
            friend bool operator==(IRBComp &, IRBComp &);

        private:
            //! register or temporal register where result is stored
            std::shared_ptr<IRExpr> result;
            //! registers used in the comparisons.
            std::shared_ptr<IRExpr> reg1;
            std::shared_ptr<IRExpr> reg2;
            //! Type of comparison
            comp_t comp;
        };

        class IRNew : public IRExpr
        {
        public:
            /**
             * @brief Construct a new IRNew::IRNew object which represents
             *        the creation of an instance of a class.
             *
             * @param result: result register where object is stored.
             * @param class_instance: IRClass object which represent the instance.
             * @param left: left part of the comparison (used for AST).
             * @param right: right part of the comparison (used for AST).
             * @return void
             */
            IRNew(std::shared_ptr<IRExpr> result,
                  std::shared_ptr<IRExpr> class_instance,
                  std::shared_ptr<IRExpr> left,
                  std::shared_ptr<IRExpr> right);

            /**
             * @brief Destroy the IRNew::IRNew object
             *
             */
            ~IRNew() = default;

            /**
             * @brief Get the destination register
             *
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_result()
            {
                return result;
            }

            /**
             * @brief Get the source class.
             *
             * @return std::shared_ptr<IRExpr>
             */
            std::shared_ptr<IRExpr> get_source_class()
            {
                return class_instance;
            }

            /**
             * @brief Return string representation of IRNew
             *
             * @return std::string
             */
            std::string to_string();

            /**
             * @brief Compare two IRNew instructions with shared_ptr
             *
             * @param new_i
             * @return true
             * @return false
             */
            bool equals(std::shared_ptr<IRNew> bcomp);

            /**
             * @brief Operator == for IRNew instruction.
             *
             * @param new1
             * @param new2
             * @return true
             * @return false
             */
            friend bool operator==(IRNew &, IRNew &);

        private:
            //! register where the result will be stored.
            std::shared_ptr<IRExpr> result;
            //! class type which will create a new instance.
            std::shared_ptr<IRExpr> class_instance;
        };

        class IRType : public IRExpr
        {
        public:
            enum type_t
            {
                REGISTER_TYPE = 0,
                TEMP_REGISTER_TYPE,
                CONST_INT_TYPE,
                CONST_FLOAT_TYPE,
                FIELD_TYPE,
                MEM_TYPE,
                STRING_TYPE,
                CLASS_TYPE,
                CALLEE_TYPE,
                NONE_TYPE = 99
            };

            enum mem_access_t
            {
                LE_ACCESS = 0, //! little-endian access
                BE_ACCESS,     //! big-endian access
                ME_ACCESS,     //! This shouldn't commonly happen?
                NONE_ACCESS = 99
            };

            /**
             * @brief Constructor of the IRType, this will be the generic type used for the others.
             * @param type: type of the class.
             * @param type_name: name used for representing the type while printing.
             * @param type_size: size of the type in bytes.
             * @return void
             */
            IRType(type_t type, std::string type_name, size_t type_size);

            /**
             * @brief Destructor of the IRType.
             * @return void
             */
            ~IRType() = default;

            /**
             * @brief retrieve the type name.
             * @return std::string
             */
            std::string get_type_name()
            {
                return type_name;
            }

            /**
             * @brief retrieve the type size.
             * @return size_t
             */
            size_t get_type_size()
            {
                return type_size;
            }

            /**
             * @brief method from IRType this return one of the types given by class.
             * @return type_t
             */
            type_t get_type()
            {
                return type;
            }

            virtual std::string get_type_str()
            {
                return """";
            }

            /**
             * @brief virtual method from IRType this must be implemented by other types too. Returns one of the mem_access_t enum values.
             * @return mem_access_t
             */
            mem_access_t get_access()
            {
                return NONE_ACCESS;
            }

            /**
             * @brief Write an annotations to the type object.
             * @return void
             */
            void write_annotations(std::string annotations)
            {
                this->annotations = annotations;
            }

            /**
             * @brief Read the annotations from the type object.
             * @return std::string
             */
            std::string read_annotations()
            {
                return annotations;
            }

            /**
             * @brief Return the proper to_string.
             *
             * @return std::string
             */
            std::string to_string();

            /**
             * @brief Comparison of two IRType with shared_ptr.
             * @return bool
             */
            bool equal(std::shared_ptr<IRType> type);

            /**
             * @brief == operator for IRType, we have specific check to do.
             * @param type1: first type for comparison.
             * @param type2: second type for comparison
             * @return bool
             */
            friend bool operator==(IRType &, IRType &);

        private:
            //! type value as a type_t
            type_t type;

            //! name used to represent the type in IR representation.
            std::string type_name;

            //! size of the type, this can vary depending on architecture
            //! and so on.
            size_t type_size;

            //! annotations are there for you to write whatever you want
            std::string annotations;
        };

        class IRReg : public IRType
        {
        public:
            /**
             * @brief Constructor of IRReg type.
             * @param reg_id: id of the register this can be an enum if is a well known register, or just an id.
             * @param current_arch: curreng architecture to create the register.
             * @param type_name: string for representing the register.
             * @param type_size: size of the register.
             * @return void
             */
            IRReg(std::uint32_t reg_id, int current_arch, std::string type_name, size_t type_size);

            /**
             * @brief Destructor of IRReg.
             * @return void
             */
            ~IRReg() = default;

            /**
             * @brief Return the ID from the register.
             * @return std::uint32_t
             */
            std::uint32_t get_id()
            {
                return id;
            }

            /**
             * @brief Return the register type as str.
             * @return std::string
             */
            std::string get_type_str()
            {
                return ""Register"";
            }

            /**
             * @brief Return the access type to the register. We get as all the register are accessed as Little-Endian.
             * @return mem_access_t
             */
            mem_access_t get_access()
            {
                return NONE_ACCESS;
            }

            /**
             * @brief Return string representation of IRReg.
             * @return std::string
             */
            std::string to_string();

            /**
             * @brief Compare two IRRegs given by smart pointer.
             * @return bool
             */
            bool equal(std::shared_ptr<IRReg> reg);

            /**
             * @brief == operator for IRRegs, we have specific check to do.
             * @param type1: first type for comparison.
             * @param type2: second type for comparison
             * @return bool
             */
            friend bool operator==(IRReg &, IRReg &);

        private:
            //! id of the register, this will be an enum
            //! in case the arquitecture contains a known set
            //! of registers, for example x86-64 will have a
            //! well known set of registers, e.g. EAX, AX, RSP
            //! RIP, etc.
            //! Other arquitectures like DEX VM will not have
            //! an specific set.
            std::uint32_t id;

            int current_arch;
        };

        class IRTempReg : public IRType
        {
        public:
            /**
             * @brief Constructor of IRTempReg type.
             * @param reg_id: id of the register this will be an incremental id.
             * @param type_name: string for representing the register.
             * @param type_size: size of the register.
             * @return void
             */
            IRTempReg(std::uint32_t reg_id, std::string type_name, size_t type_size);

            /**
             * @brief Destructor of IRTempReg.
             * @return void
             */
            ~IRTempReg() = default;

            /**
             * @brief Return the ID from the register.
             * @return std::uint32_t
             */
            std::uint32_t get_id()
            {
                return id;
            }

            /**
             * @brief Return the temporal register type as str.
             * @return std::string
             */
            std::string get_type_str()
            {
                return ""Temporal Register"";
            }

            /**
             * @brief Return the access type to the register. We get as all the register are accessed as Little-Endian.
             * @return mem_access_t
             */
            mem_access_t get_access()
            {
                return NONE_ACCESS;
            }

            /**
             * @brief String representation of IRTempReg.
             * @return std::string
             */
            std::string to_string();

            /**
             * @brief Compare two IRTempReg temporal registers.
             * @param temp_reg: IRTempReg to compare with.
             * @return bool
             */
            bool equal(std::shared_ptr<IRTempReg> temp_reg);

            /**
             * @brief == operator for IRTempReg, we have specific check to do.
             * @param type1: first type for comparison.
             * @param type2: second type for comparison
             * @return bool
             */
            friend bool operator==(IRTempReg &, IRTempReg &);

        private:
            //! This id will be just an incremental number
            //! as these are temporal registers.
            std::uint32_t id;
        };

        class IRConstInt : public IRType
        {
        public:
            /**
             * @brief Constructor of IRConstInt this represent any integer used in the code.
             * @param value: value of the constant integer
             * @param is_signed: is signed value (true) or unsigned (false).
             * @param byte_order: byte order of the value.
             * @param type_name: name used for representing the value.
             * @param type_size: size of the integer.
             * @return void
             */
            IRConstInt(std::uint64_t value, bool is_signed, mem_access_t byte_order, std::string type_name, size_t type_size);

            /**
             * @brief Destructor of IRConstInt.
             * @return void
             */
            ~IRConstInt() = default;

            /**
             * @brief Get if the int value is signed  or not.
             * @return bool
             */
            bool get_is_signed()
            {
                return is_signed;
            }

            /**
             * @brief Return the CONST_INT type as string.
             * @return std::string
             */
            std::string get_type_str()
            {
                return ""ConstInt"";
            }

            /**
             * @brief Return the type of access of the constant int.
             * @return mem_access_t
             */
            mem_access_t get_access()
            {
                return byte_order;
            }

            /**
             * @brief Return a string representation of the IRConstInt instruction.
             * @return bool
             */
            std::string to_string();

            /**
             * @brief Comparison of two IRConstInt instructions with shared pointers.
             * @param const_int: IRConstInt to compare with.
             * @return bool
             */
            bool equal(std::shared_ptr<IRConstInt> const_int);

            /**
             * @brief == operator for IRConstInt, we have specific check to do.
             * @param type1: first type for comparison.
             * @param type2: second type for comparison
             * @return bool
             */
            friend bool operator==(IRConstInt &, IRConstInt &);

        private:
            //! Value of the integer
            std::uint64_t value;
            //! Check to know if the constant is a unsigned
            //! or signed value.
            bool is_signed;
            //! byte order of the value.
            mem_access_t byte_order;
        };

        class IRMemory : public IRType
        {
        public:
            /**
             * @brief IRMemory constructor this represent a memory address with accessed offset and size.
             * @param mem_address: address of the memory.
             * @param offset: offset accessed (commonly 0).
             * @param byte_order: byte order of the memory (LE, BE, ME?).
             * @param type_name: memory representation with a string.
             * @param type_size: size of the memory.
             * @return void
             */
            IRMemory(std::uint64_t mem_address, std::int32_t offset, mem_access_t byte_order, std::string type_name, size_t type_size);

            /**
             * @brief IRMemory destructor.
             * @return void
             */
            ~IRMemory() = default;

            /**
             * @brief Get the memory address of the type.
             * @return std::uint64_t
             */
            std::uint64_t get_mem_address()
            {
                return mem_address;
            }

            /**
             * @brief Get the accessed offset of the type.
             * @return std::int32_t
             */
            std::int32_t get_offset()
            {
                return offset;
            }

            /**
             * @brief Get the MEM_TYPE as string.
             * @return std::string
             */
            std::string get_type_str()
            {
                return ""Memory"";
            }

            /**
             * @brief Get the mem access type from the memory.
             * @return mem_access_t
             */
            mem_access_t get_access()
            {
                return byte_order;
            }

            /**
             * @brief Return a string representation of IRMemory instruction.
             * @return std::string
             */
            std::string to_string();

            /**
             * @brief Comparison of two IRMemory by shared_ptr.
             * @param memory: IRMemory instruction to compare.
             * @return bool.
             */
            bool equal(std::shared_ptr<IRMemory> memory);

            /**
             * @brief == operator for IRMemory, we have specific check to do.
             * @param type1: first type for comparison.
             * @param type2: second type for comparison
             * @return bool
             */
            friend bool operator==(IRMemory &, IRMemory &);

        private:
            //! accessed address
            std::uint64_t mem_address;
            //! offset of the memory accessed
            std::int32_t offset;
            //! byte order of the memory.
            mem_access_t byte_order;
        };

        class IRString : public IRType
        {
        public:
            /**
             * @brief Constructor of IRString class, this represent strings used in code.
             * @param str_value: value of that string.
             * @param type_name: some meaninful string name.
             * @param type_size: size of the type (probably here string length)
             * @return void
             */
            IRString(std::string str_value, std::string type_name, size_t type_size);

            /**
             * @brief Destructor of IRString, nothing to be done.
             * @return void
             */
            ~IRString() = default;

            /**
             * @brief Return the value of the string.
             * @return std::string
             */
            std::string get_str_value()
            {
                return str_value;
            }

            /**
             * @brief Get the type as a string.
             * @return std::string
             */
            std::string get_type_str()
            {
                return ""String"";
            }

            /**
             * @brief Get the type of access of string, in this one NONE.
             * @return mem_access_t
             */
            mem_access_t get_access()
            {
                return NONE_ACCESS;
            }

            /**
             * @brief Get a string representation from IRString instruction.
             * @return std::string
             */
            std::string to_string();

            /**
             * @brief Compare two IRString values.
             * @return bool
             */
            bool equal(std::shared_ptr<IRString> str);

            /**
             * @brief == operator for IRString, we have specific check to do.
             * @param type1: first type for comparison.
             * @param type2: second type for comparison
             * @return bool
             */
            friend bool operator==(IRString &, IRString &);

        private:
            //! string value, probably nothing more will be here
            std::string str_value;
        };

        class IRClass : public IRType
        {
        public:
            /**
             * @brief Constructor of IRClass, this represent the name of a class
             *        that is assigned as a type.
             * @param class_name: name of the class.
             * @param type_name: should be the same value than previous one.
             * @param type_size: should be 0.
             * @return void
             */
            IRClass(std::string class_name, std::string type_name, size_t type_size);

            /**
             * @brief Destructor of IRClass, nothing to be done here.
             * @return void
             */
            ~IRClass() = default;

            /**
             * @brief get the name of the class.
             * @return std::string
             */
            std::string get_class()
            {
                return class_name;
            }

            /**
             * @brief Get the name of the type as a string
             * @return std::string
             */
            std::string get_type_str()
            {
                return ""Class"";
            }

            /**
             * @brief Get type of access in this case NONE.
             * @return mem_access_t
             */
            mem_access_t get_access()
            {
                return NONE_ACCESS;
            }

            /**
             * @brief Return a string representing the IRClass.
             * @return std::string
             */
            std::string to_string();

            /**
             * @brief Compare two IRClass with smart pointers
             * @return bool
             */
            bool equal(std::shared_ptr<IRClass> class_);

            /**
             * @brief Operator == of IRClass we will compare name of classes.
             * @param type1: first class to compare.
             * @param type2: second class to compare.
             * @return bool
             */
            friend bool operator==(IRClass &, IRClass &);

        private:
            //! class name including path, used for instructions
            //! of type const-class
            std::string class_name;
        };

        class IRCallee : public IRType
        {
        public:
            /**
             * @brief Constructor of IRCallee this represent any function/method called by a caller!
             * @param addr: address of the function/method called (if available).
             * @param name: name of the function/method called (if available).
             * @param class_name: name of the class from the method called (if available).
             * @param n_of_params: number of the parameters for the function/method (if available).
             * @param description: description of the parameters from the function/method (if available).
             * @param type_name: some meaninful string name.
             * @param type_size: size of the type (probably here 0)
             * @return void
             */
            IRCallee(std::uint64_t addr,
                     std::string name,
                     std::string class_name,
                     int n_of_params,
                     std::string description,
                     std::string type_name,
                     size_t type_size);

            /**
             * @brief Destructor of IRCallee, nothing to be done.
             * @return void
             */
            ~IRCallee() = default;

            /**
             * @brief Get address of function/method
             * @return std::uint64_t
             */
            std::uint64_t get_addr()
            {
                return addr;
            }
            /**
             * @brief Get name of the called function/method.
             * @return std::string
             */
            std::string get_name()
            {
                return name;
            }

            /**
             * @brief Get the class name of the called method.
             * @return std::string
             */
            std::string get_class_name()
            {
                return class_name;
            }

            /**
             * @brief Get the number of parameters from the called function/method.
             * @return int
             */
            int get_number_of_params()
            {
                return n_of_params;
            }

            /**
             * @brief Get the description of the method if exists.
             * @return std::string
             */
            std::string get_description()
            {
                return description;
            }

            /**
             * @brief Get the type of IRCallee as string
             * @return std::string
             */
            std::string get_type_str()
            {
                return ""Callee"";
            }

            /**
             * @brief Get memory access NONE in this case.
             * @return mem_access_t
             */
            mem_access_t get_access()
            {
                return NONE_ACCESS;
            }

            /**
             * @brief Return a string representation of the IRCallee type.
             * @return std::string
             */
            std::string to_string();

            /**
             * @brief Check if two shared objects of Callee are the same.
             * @param callee: IRType instruction to compare.
             * @return bool
             */
            bool equal(std::shared_ptr<IRCallee> callee);

            /**
             * @brief == operator for IRCallee, we have specific check to do.
             * @param type1: first type for comparison.
             * @param type2: second type for comparison
             * @return bool
             */
            friend bool operator==(IRCallee &, IRCallee &);

        private:
            //! for those functions of binary formats we will mostly have the address
            //! only, these can be from a library, from the same binary, etc.
            std::uint64_t addr;
            //! name of the callee function or method, this can be resolved from the
            //! binary symbols if those exist or is given in case of other formats.
            std::string name;
            //! in case it is a method, probably we will need to know class name
            //! for possible analysis which requires to know about a calls.
            std::string class_name;
            //! there are cases where functions/methods can have the same name but
            //! different parameters, you can give the number of parameters (if recognized)
            //! or the string with the description of the method
            int n_of_params;
            std::string description;
        };

        class IRField : public IRType
        {
        public:
            enum field_t
            {
                CLASS_F,
                BOOLEAN_F,
                BYTE_F,
                CHAR_F,
                DOUBLE_F,
                FLOAT_F,
                INT_F,
                LONG_F,
                SHORT_F,
                VOID_F,
                ARRAY_F
            };

            /**
             * @brief Construct a new IRField::IRField object
             *
             * @param class_name: class name of the field
             * @param type: type from field_t
             * @param field_name: name of the field.
             * @param type_name: some meaninful string name.
             * @param type_size: size of the type (probably here 0)
             */
            IRField(std::string class_name,
                    field_t type,
                    std::string field_name,
                    std::string type_name,
                    size_t type_size);

            IRField(std::string class_name,
                    std::string type_class_name,
                    std::string field_name,
                    std::string type_name,
                    size_t type_size);

            /**
             * @brief Destroy the IRField::IRField object
             */
            ~IRField() = default;

            /**
             * @brief Getter for class name
             *
             * @return std::string
             */
            std::string get_class_name()
            {
                return class_name;
            }

            /**
             * @brief Getter for type name.
             *
             * @return field_t
             */
            field_t get_type()
            {
                return type;
            }

            /**
             * @brief Return if type == CLASS the class name.
             *
             * @return std::string
             */
            std::string get_type_class()
            {
                return type_class;
            }
            /**
             * @brief Getter for field name.
             *
             * @return std::string
             */
            std::string get_name()
            {
                return field_name;
            }
            /**
             * @brief Get a string representation of IRField
             *
             * @return std::string
             */
            std::string to_string();

            /**
             * @brief Function to check if two IRField are the same with shared_ptr.
             *
             * @param field
             * @return true
             * @return false
             */
            bool equal(std::shared_ptr<IRField> field);

            /**
             * @brief == operator for IRField.
             *
             * @param field1
             * @param field2
             * @return true
             * @return false
             */
            friend bool operator==(IRField &, IRField &);

        private:
            //! Class name of the field
            std::string class_name;
            //! Type of the field
            field_t type;
            //! if type is class set class name
            std::string type_class;
            //! Field name
            std::string field_name;
        };
    }
}",16157,True,3704.535428364381,median
"/*
Copyright (c) 2013, Ashley Mills.
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 THE COPYRIGHT HOLDERS AND CONTRIBUTORS ""AS IS"" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

// version, 2 bits
// type, 2 bits
	// 00 Confirmable
	// 01 Non-confirmable
	// 10 Acknowledgement
	// 11 Reset

// token length, 4 bits
// length of token in bytes (only 0 to 8 bytes allowed)
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include ""cantcoap.h""
#include ""sysdep.h""

/// Memory-managed constructor. Buffer for PDU is dynamically sized and allocated by the object.
/**
 * When using this constructor, the CoapPDU class will allocate space for the PDU.
 * Contrast this with the parameterized constructors, which allow the use of an external buffer.
 *
 * Note, the PDU container and space can be reused by issuing a CoapPDU::reset(). If the new PDU exceeds the
 * space of the previously allocated memory, then further memory will be dynamically allocated.
 *
 * Deleting the object will free the Object container and all dynamically allocated memory.
 *
 * \\note It would have been nice to use something like UDP_CORK or MSG_MORE, to allow separate buffers
 * for token, options, and payload but these FLAGS aren't implemented for UDP in LwIP so stuck with one buffer for now.
 *
 * CoAP version defaults to 1.
 *
 * \\sa CoapPDU::CoapPDU(uint8_t *pdu, int pduLength), CoapPDU::CoapPDU::(uint8_t *buffer, int bufferLength, int pduLength),
 * CoapPDU:CoapPDU()~
 *
 */
CoapPDU::CoapPDU() {
	// pdu
	_pdu = (uint8_t*)calloc(4,sizeof(uint8_t));
	_pduLength = 4;
	_bufferLength = _pduLength;

	//options
	_numOptions = 0;
	_maxAddedOptionNumber = 0;

	// payload
	_payloadPointer = NULL;
	_payloadLength = 0;

	_constructedFromBuffer = 0;

	setVersion(1);
}

/// Construct a PDU using an external buffer. No copy of the buffer is made.
/**
 * This constructor is normally used where a PDU has been received over the network, and it's length is known.
 * In this case the CoapPDU object is probably going to be used as a temporary container to access member values.
 *
 * It is assumed that \\b pduLength is the length of the actual CoAP PDU, and consequently the buffer will also be this size,
 * contrast this with CoapPDU::CoapPDU(uint8_t *buffer, int bufferLength, int pduLength) which allows the buffer to
 * be larger than the PDU.
 *
 * A PDU constructed in this manner must be validated with CoapPDU::validate() before the member variables will be accessible.
 *
 * \\warning The validation call parses the PDU structure to set some internal parameters. If you do
 * not validate the PDU, then the behaviour of member access functions will be undefined.
 *
 * The buffer can be reused by issuing a CoapPDU::reset() but the class will not change the size of the buffer. If the
 * newly constructed PDU exceeds the size of the buffer, the function called (for example CoapPDU::addOption) will fail.
 *
 * Deleting this object will only delete the Object container and will not delete the PDU buffer.
 *
 * @param pdu A pointer to an array of bytes which comprise the CoAP PDU
 * @param pduLength The length of the CoAP PDU pointed to by \\b pdu

 * \\sa CoapPDU::CoapPDU(), CoapPDU::CoapPDU(uint8_t *buffer, int bufferLength, int pduLength)
 */
CoapPDU::CoapPDU(uint8_t *pdu, int pduLength) : CoapPDU(pdu,pduLength,pduLength) {
	// delegated to CoapPDU::CoapPDU(uint8_t *buffer, int bufferLength, int pduLength)
}

/// Construct object from external buffer that may be larger than actual PDU.
/**
 * This differs from CoapPDU::CoapPDU(uint8_t *pdu, int pduLength) in that the buffer may be larger
 * than the actual CoAP PDU contained int the buffer. This is typically used when a large buffer is reused
 * multiple times. Note that \\b pduLength can be 0.
 *
 * If an actual CoAP PDU is passed in the buffer, \\b pduLength should match its length. CoapPDU::validate() must
 * be called to initiate the object before member functions can be used.
 *
 * A PDU constructed in this manner must be validated with CoapPDU::validate() before the member variables will be accessible.
 *
 * \\warning The validation call parses the PDU structure to set some internal parameters. If you do
 * not validate the PDU, then the behaviour of member access functions will be undefined.
 *
 * The buffer can be reused by issuing a CoapPDU::reset() but the class will not change the size of the buffer. If the
 * newly constructed PDU exceeds the size of the buffer, the function called (for example CoapPDU::addOption) will fail.
 *
 * Deleting this object will only delete the Object container and will not delete the PDU buffer.
 *
 * \\param buffer A buffer which either contains a CoAP PDU or is intended to be used to construct one.
 * \\param bufferLength The length of the buffer
 * \\param pduLength If the buffer contains a CoAP PDU, this specifies the length of the PDU within the buffer.
 *
 * \\sa CoapPDU::CoapPDU(), CoapPDU::CoapPDU(uint8_t *pdu, int pduLength)
 */
CoapPDU::CoapPDU(uint8_t *buffer, int bufferLength, int pduLength) {
	// sanity
	if(pduLength<4&&pduLength!=0) {
		DBG(""PDU cannot have a length less than 4"");
	}

	// pdu
	_pdu = buffer;
	_bufferLength = bufferLength;
	if(pduLength==0) {
		// this is actually a fresh pdu, header always exists
		_pduLength = 4;
		// make sure header is zeroed
		_pdu[0] = 0x00; _pdu[1] = 0x00; _pdu[2] = 0x00; _pdu[3] = 0x00;
		setVersion(1);
	} else {
		_pduLength = pduLength;
	}

	_constructedFromBuffer = 1;

	// options
	_numOptions = 0;
	_maxAddedOptionNumber = 0;

	// payload
	_payloadPointer = NULL;
	_payloadLength = 0;
}

/// Reset CoapPDU container so it can be reused to build a new PDU.
/**
 * This resets the CoapPDU container, setting the pdu length, option count, etc back to zero. The
 * PDU can then be populated as if it were newly constructed.
 *
 * Note that the space available will depend on how the CoapPDU was originally constructed:
 * -# CoapPDU::CoapPDU()
 *
 * 	Available space initially be \\b _pduLength. But further space will be allocated as needed on demand,
 *    limited only by the OS/environment.
 *
 * -# CoapPDU::CoapPDU(uint8_t *pdu, int pduLength)
 *
 *		Space is limited by the variable \\b pduLength. The PDU cannot exceed \\b pduLength bytes.
 *
 * -# CoapPDU::CoapPDU(uint8_t *buffer, int bufferLength, int pduLength)
 *
 *		Space is limited by the variable \\b bufferLength. The PDU cannot exceed \\b bufferLength bytes.
 *
 * \\return 0 on success, 1 on failure.
 */
int CoapPDU::reset() {
	// pdu
	memset(_pdu,0x00,_bufferLength);
	// packet always has at least a header
	_pduLength = 4;

	// options
	_numOptions = 0;
	_maxAddedOptionNumber = 0;
	// payload
	_payloadPointer = NULL;
	_payloadLength = 0;
	return 0;
}

/// Validates a PDU constructed using an external buffer.
/**
 * When a CoapPDU is constructed using an external buffer, the programmer must call this function to
 * check that the received PDU is a valid CoAP PDU.
 *
 * \\warning The validation call parses the PDU structure to set some internal parameters. If you do
 * not validate the PDU, then the behaviour of member access functions will be undefined.
 *
 * \\return 1 if the PDU validates correctly, 0 if not. XXX maybe add some error codes
 */
int CoapPDU::validate() {
	if(_pduLength<4) {
		DBG(""PDU has to be a minimum of 4 bytes. This: %d bytes"",_pduLength);
		return 0;
	}

	// check header
	//   0                   1                   2                   3
   //  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
   // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   // |Ver| T |  TKL  |      Code     |          Message ID           |
   // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   // |   Token (if any, TKL bytes) ...
   // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   // |   Options (if any) ...
   // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   // |1 1 1 1 1 1 1 1|    Payload (if any) ...
   // +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

	// version must be 1
	int version = getVersion();
	if (version != 1) {
		DBG(""Invalid version: %d"", version);
		return 0;
	}
	DBG(""Version: %d"", version);
	DBG(""Type: %d"", getType());

	// token length must be between 0 and 8
	int tokenLength = getTokenLength();
	if(tokenLength<0||tokenLength>8) {
		DBG(""Invalid token length: %d"",tokenLength);
		return 0;
	}
	DBG(""Token length: %d"",tokenLength);
	// check total length
	if((COAP_HDR_SIZE+tokenLength)>_pduLength) {
		DBG(""Token length would make pdu longer than actual length."");
		return 0;
	}

	// check that code is valid
	CoapPDU::Code code = getCode();
	if(code<COAP_EMPTY ||
		(code>COAP_LASTMETHOD&&code<COAP_CREATED) ||
		(code>COAP_CONTENT&&code<COAP_BAD_REQUEST) ||
		(code>COAP_NOT_ACCEPTABLE&&code<COAP_PRECONDITION_FAILED) ||
		(code==0x8E) ||
		(code>COAP_UNSUPPORTED_CONTENT_FORMAT&&code<COAP_INTERNAL_SERVER_ERROR) ||
		(code>COAP_PROXYING_NOT_SUPPORTED) ) {
		DBG(""Invalid CoAP code: %d"",code);
		return 0;
	}
	DBG(""CoAP code: %d"",code);

	// token can be anything so nothing to check

	// check that options all make sense
	uint16_t optionDelta =0, optionNumber = 0, optionValueLength = 0;
	int totalLength = 0;

	// first option occurs after token
	int optionPos = COAP_HDR_SIZE + getTokenLength();

	// may be 0 options
	if(optionPos==_pduLength) {
		DBG(""No options. No payload."");
		_numOptions = 0;
		_payloadLength = 0;
		return 1;
	}

	int bytesRemaining = _pduLength-optionPos;
	int numOptions = 0;
	uint8_t upperNibble = 0x00, lowerNibble = 0x00;

	// walk over options and record information
	while(1) {
		// check for payload marker
		if(bytesRemaining>0) {
			uint8_t optionHeader = _pdu[optionPos];
			if(optionHeader==0xFF) {
				// payload
				if(bytesRemaining>1) {
					_payloadPointer = &_pdu[optionPos+1];
					_payloadLength = (bytesRemaining-1);
					_numOptions = numOptions;
					DBG(""Payload found, length: %d"",_payloadLength);
					return 1;
				}
				// payload marker but no payload
				_payloadPointer = NULL;
				_payloadLength = 0;
				DBG(""Payload marker but no payload."");
				return 0;
			}

			// check that option delta and option length are valid values
			upperNibble = (optionHeader & 0xF0) >> 4;
			lowerNibble = (optionHeader & 0x0F);
			if(upperNibble==0x0F||lowerNibble==0x0F) {
				DBG(""Expected option header or payload marker, got: 0x%x%x"",upperNibble,lowerNibble);
				return 0;
			}
			DBG(""Option header byte appears sane: 0x%x%x"",upperNibble,lowerNibble);
		} else {
			DBG(""No more data. No payload."");
			_payloadPointer = NULL;
			_payloadLength = 0;
			_numOptions = numOptions;
			return 1;
		}

		// skip over option header byte
		bytesRemaining--;

		// check that there is enough space for the extended delta and length bytes (if any)
		int headerBytesNeeded = computeExtraBytes(upperNibble);
		DBG(""%d extra bytes needed for extended delta"",headerBytesNeeded);
		if(headerBytesNeeded>bytesRemaining) {
			DBG(""Not enough space for extended option delta, needed %d, have %d."",headerBytesNeeded,bytesRemaining);
			return 0;
		}
		headerBytesNeeded += computeExtraBytes(lowerNibble);
		if(headerBytesNeeded>bytesRemaining) {
			DBG(""Not enough space for extended option length, needed %d, have %d."",
				(headerBytesNeeded-computeExtraBytes(upperNibble)),bytesRemaining);
			return 0;
		}
		DBG(""Enough space for extended delta and length: %d, continuing."",headerBytesNeeded);

		// extract option details
		optionDelta = getOptionDelta(&_pdu[optionPos]);
		optionNumber += optionDelta;
		optionValueLength = getOptionValueLength(&_pdu[optionPos]);
		DBG(""Got option: %d with length %d"",optionNumber,optionValueLength);
		// compute total length
		totalLength = 1; // mandatory header
		totalLength += computeExtraBytes(optionDelta);
		totalLength += computeExtraBytes(optionValueLength);
		totalLength += optionValueLength;
		// check there is enough space
		if(optionPos+totalLength>_pduLength) {
			DBG(""Not enough space for option payload, needed %d, have %d."",(totalLength-headerBytesNeeded-1),_pduLength-optionPos);
			return 0;
		}
		DBG(""Enough space for option payload: %d %d"",optionValueLength,(totalLength-headerBytesNeeded-1));

		// recompute bytesRemaining
		bytesRemaining -= totalLength;
		bytesRemaining++; // correct for previous --

		// move to next option
		optionPos += totalLength;

		// inc number of options XXX
		numOptions++;
	}

	return 1;
}

/// Destructor. Does not free buffer if constructor passed an external buffer.
/**
 * The destructor acts differently, depending on how the object was initially constructed (from buffer or not):
 *
 * -# CoapPDU::CoapPDU()
 *
 * 	Complete object is destroyed.
 *
 * -# CoapPDU::CoapPDU(uint8_t *pdu, int pduLength)
 *
 *		Only object container is destroyed. \\b pdu is left intact.
 *
 * -# CoapPDU::CoapPDU(uint8_t *buffer, int bufferLength, int pduLength)
 *
 *		Only object container is destroyed. \\b pdu is left intact.
 *
 */
CoapPDU::~CoapPDU() {
	if(!_constructedFromBuffer) {
		free(_pdu);
	}
}

/// Returns a pointer to the internal buffer.
uint8_t* CoapPDU::getPDUPointer() {
	return _pdu;
}

/// Set the PDU length to the length specified.
/**
 * This is used when re-using a PDU container before calling CoapPDU::validate() as it
 * is not possible to deduce the length of a PDU since the payload has no length marker.
 * \\param len The length of the PDU
 */
void CoapPDU::setPDULength(int len) {
	_pduLength = len;
}

/// Shorthand function for setting a resource URI.
/**
 * Calls CoapPDU::setURI(uri,strlen(uri).
 */
int CoapPDU::setURI(char *uri) {
	return setURI(uri,strlen(uri));
}

/// Shorthand function for setting a resource URI.
/**
 * This will parse the supplied \\b uri and construct enough URI_PATH and URI_QUERY options to encode it.
 * The options are added to the PDU.
 *
 * At present only simple URI formatting is handled, only '/','?', and '&' separators, and no port or protocol specificaiton.
 *
 * The function will split on '/' and create URI_PATH elements until it either reaches the end of the string
 * in which case it will stop or if it reaches '?' it will start splitting on '&' and create URI_QUERY elements
 * until it reaches the end of the string.
 *
 * Here is an example:
 *
 * /a/b/c/d?x=1&y=2&z=3
 *
 * Will be broken into four URI_PATH elements ""a"", ""b"", ""c"", ""d"", and three URI_QUERY elements ""x=1"", ""y=2"", ""z=3""
 *
 * TODO: Add protocol extraction, port extraction, and some malformity checking.
 *
 * \\param uri The uri to parse.
 * \\param urilen The length of the uri to parse.
 *
 * \\return 1 on success, 0 on failure.
 */
int CoapPDU::setURI(char *uri, int urilen) {
	// only '/', '?', '&' and ascii chars allowed

	// sanitation
	if(urilen<=0||uri==NULL) {
		DBG(""Null or zero-length uri passed."");
		return 1;
	}

	// single character URI path (including '/' case)
	if(urilen==1) {
		addOption(COAP_OPTION_URI_PATH,1,(uint8_t*)uri);
		return 0;
	}

	// TODO, queries
	// extract ? to mark where to stop processing path components
	// and then process the query params

	// local vars
	char *startP=uri,*endP=NULL;
	int oLen = 0;
	char splitChar = '/';
	int queryStageTriggered = 0;
	uint16_t optionType = COAP_OPTION_URI_PATH;
	while(1) {
		// stop at end of string or query
		if(*startP==0x00||*(startP+1)==0x00) {
			break;
		}

		// ignore leading slash
		if(*startP==splitChar) {
			DBG(""Skipping leading slash"");
			startP++;
		}

		// find next split point
		endP = strchr(startP,splitChar);

		// might not be another slash
		if(endP==NULL) {
			DBG(""Ending out of slash"");
			// check if there is a ?
			endP = strchr(startP,'?');
			// done if no queries
			if(endP==NULL) {
				endP = uri+urilen;
			} else {
				queryStageTriggered = 1;
			}
		}

		// get length of segment
		oLen = endP-startP;

		#ifdef DEBUG
		char *b = (char*)malloc(oLen+1);
		memcpy(b,startP,oLen);
		b[oLen] = 0x00;
		DBG(""Adding URI_PATH %s"",b);
		free(b);
		#endif

		// add option
		if(addOption(optionType,oLen,(uint8_t*)startP)!=0) {
			DBG(""Error adding option"");
			return 1;
		}
		startP = endP;

		if(queryStageTriggered) {
			splitChar = '&';
			optionType = COAP_OPTION_URI_QUERY;
			startP++;
			queryStageTriggered = false;
		}
	}

	return 0;
}

/// Shorthand for adding a URI QUERY to the option list.
/**
 * Adds a new option to the CoAP PDU that encodes a URI_QUERY.
 *
 * \\param query The uri query to encode.
 * \\return 0 on success, 1 on failure.
 */
int CoapPDU::addURIQuery(char *query) {
	return addOption(COAP_OPTION_URI_QUERY,strlen(query),(uint8_t*)query);
}

/// Concatenates any URI_PATH elements and URI_QUERY elements into a single string.
/**
 * Parses the PDU options and extracts all URI_PATH and URI_QUERY elements,
 * concatenating them into a single string with slash and amphersand separators accordingly.
 *
 * The produced string will be NULL terminated.
 *
 * \\param dst Buffer into which to copy the concatenated path elements.
 * \\param dstlen Length of buffer.
 * \\param outLen Pointer to integer, into which URI length will be placed.
 *
 * \\return 0 on success, 1 on failure. \\b outLen will contain the length of the concatenated elements.
 */
int CoapPDU::getURI(char *dst, int dstlen, int *outLen) {
	if(outLen==NULL) {
		DBG(""Output length pointer is NULL"");
		return 1;
	}

	if(dst==NULL) {
		DBG(""NULL destination buffer"");
		*outLen = 0;
		return 1;
	}

	// check destination space
	if(dstlen<=0) {
		*dst = 0x00;
		*outLen = 0;
		DBG(""Destination buffer too small (0)!"");
		return 1;
	}
	// check option count
	if(_numOptions==0) {
		*dst = 0x00;
		*outLen = 0;
		return 0;
	}
	// get options
	CoapPDU::CoapOption *options = getOptions();
	if(options==NULL) {
		*dst = 0x00;
		*outLen = 0;
		return 0;
	}
	// iterate over options to construct URI
	CoapOption *o = NULL;
	int bytesLeft = dstlen-1; // space for 0x00
	int oLen = 0;
	// add slash at beggining
	if(bytesLeft>=1) {
		*dst = '/';
		dst++;
		bytesLeft--;
	} else {
		DBG(""No space for initial slash needed 1, got %d"",bytesLeft);
		free(options);
		return 1;
	}

	char separator = '/';
	int firstQuery = 1;

	for(int i=0; i<_numOptions; i++) {
		o = &options[i];
		oLen = o->optionValueLength;
		if(o->optionNumber==COAP_OPTION_URI_PATH||o->optionNumber==COAP_OPTION_URI_QUERY) {
			// if the option is a query, change the separator to &
			if(o->optionNumber==COAP_OPTION_URI_QUERY) {
				if(firstQuery) {
					// change previous '/' to a '?'
					*(dst-1) = '?';
					firstQuery = 0;
				}
				separator = '&';
			}

			// check space
			if(oLen>bytesLeft) {
				DBG(""Destination buffer too small, needed %d, got %d"",oLen,bytesLeft);
				free(options);
				return 1;
			}

			// case where single '/' exists
			if(oLen==1&&o->optionValuePointer[0]=='/') {
				*dst = 0x00;
				*outLen = 1;
				free(options);
				return 0;
			}

			// copy URI path or query component
			memcpy(dst,o->optionValuePointer,oLen);

			// adjust counters
			dst += oLen;
			bytesLeft -= oLen;

			// add separator following (don't know at this point if another option is coming)
			if(bytesLeft>=1) {
				*dst = separator;
				dst++;
				bytesLeft--;
			} else {
				DBG(""Ran out of space after processing option"");
				free(options);
				return 1;
			}
		}
	}

	// remove terminating separator
	dst--;
	bytesLeft++;
	// add null terminating byte (always space since reserved)
	*dst = 0x00;
	*outLen = (dstlen-1)-bytesLeft;
	free(options);
	return 0;
}

/// Sets the CoAP version.
/**
 * \\param version CoAP version between 0 and 3.
 * \\return 0 on success, 1 on failure.
 */
int CoapPDU::setVersion(uint8_t version) {
	if(version>3) {
		return 0;
	}

	_pdu[0] &= 0x3F;
	_pdu[0] |= (version << 6);
	return 1;
}

/**
 * Gets the CoAP Version.
 * @return The CoAP version between 0 and 3.
 */
uint8_t CoapPDU::getVersion() {
	return (_pdu[0]&0xC0)>>6;
}

/**
 * Sets the type of this CoAP PDU.
 * \\param mt The type, one of:
 * - COAP_CONFIRMABLE
 * - COAP_NON_CONFIRMABLE
 * - COAP_ACKNOWLEDGEMENT
 * - COAP_RESET.
 */
void CoapPDU::setType(CoapPDU::Type mt) {
	_pdu[0] &= 0xCF;
	_pdu[0] |= mt;
}

/// Returns the type of the PDU.
CoapPDU::Type CoapPDU::getType() {
	return (CoapPDU::Type)(_pdu[0]&0x30);
}


/// Set the token length.
/**
 * \\param tokenLength The length of the token in bytes, between 0 and 8.
 * \\return 0 on success, 1 on failure.
 */
int CoapPDU::setTokenLength(uint8_t tokenLength) {
	if(tokenLength>8)
		return 1;

	_pdu[0] &= 0xF0;
	_pdu[0] |= tokenLength;
	return 0;
}

/// Returns the token length.
int CoapPDU::getTokenLength() {
	return _pdu[0] & 0x0F;
}

/// Returns a pointer to the PDU token.
uint8_t* CoapPDU::getTokenPointer() {
	if(getTokenLength()==0) {
		return NULL;
	}
	return &_pdu[4];
}

/// Set the PDU token to the supplied byte sequence.
/**
 * This sets the PDU token to \\b token and sets the token length to \\b tokenLength.
 * \\param token A sequence of bytes representing the token.
 * \\param tokenLength The length of the byte sequence.
 * \\return 0 on success, 1 on failure.
 */
int CoapPDU::setToken(uint8_t *token, uint8_t tokenLength) {
	DBG(""Setting token"");
	if(token==NULL) {
		DBG(""NULL pointer passed as token reference"");
		return 1;
	}

	if(tokenLength==0) {
		DBG(""Token has zero length"");
		return 1;
	}

	// if tokenLength has not changed, just copy the new value
	uint8_t oldTokenLength = getTokenLength();
	if(tokenLength==oldTokenLength) {
		memcpy((void*)&_pdu[4],token,tokenLength);
		return 0;
	}

	// otherwise compute new length of PDU
	uint8_t oldPDULength = _pduLength;
	_pduLength -= oldTokenLength;
	_pduLength += tokenLength;

	// now, have to shift old memory around, but shift direction depends
	// whether pdu is now bigger or smaller
	if(_pduLength>oldPDULength) {
		// new PDU is bigger, need to allocate space for new PDU
		if(!_constructedFromBuffer) {
			uint8_t *newMemory = (uint8_t*)realloc(_pdu,_pduLength);
			if(newMemory==NULL) {
				// malloc failed
				DBG(""Failed to allocate memory for token"");
				_pduLength = oldPDULength;
				return 1;
			}
			_pdu = newMemory;
			_bufferLength = _pduLength;
		} else {
			// constructed from buffer, check space
			if(_pduLength>_bufferLength) {
				DBG(""Buffer too small to contain token, needed %d, got %d."",_pduLength-oldPDULength,_bufferLength-oldPDULength);
				_pduLength = oldPDULength;
				return 1;
			}
		}

		// and then shift everything after token up to end of new PDU
		// memory overlaps so do this manually so to avoid additional mallocs
		int shiftOffset = _pduLength-oldPDULength;
		int shiftAmount = _pduLength-tokenLength-COAP_HDR_SIZE; // everything after token
		shiftPDUUp(shiftOffset,shiftAmount);

		// now copy the token into the new space and set official token length
		memcpy((void*)&_pdu[4],token,tokenLength);
		setTokenLength(tokenLength);

		// and return success
		return 0;
	}

	// new PDU is smaller, copy the new token value over the old one
	memcpy((void*)&_pdu[4],token,tokenLength);
	// and shift everything after the new token down
	int startLocation = COAP_HDR_SIZE+tokenLength;
	int shiftOffset = oldPDULength-_pduLength;
	int shiftAmount = oldPDULength-oldTokenLength-COAP_HDR_SIZE;
	shiftPDUDown(startLocation,shiftOffset,shiftAmount);
	// then reduce size of buffer
	if(!_constructedFromBuffer) {
		uint8_t *newMemory = (uint8_t*)realloc(_pdu,_pduLength);
		if(newMemory==NULL) {
			// malloc failed, PDU in inconsistent state
			DBG(""Failed to shrink PDU for new token. PDU probably broken"");
			return 1;
		}
		_pdu = newMemory;
		_bufferLength = _pduLength;
	}

	// and officially set the new tokenLength
	setTokenLength(tokenLength);
	return 0;
}

/// Sets the CoAP response code
void CoapPDU::setCode(CoapPDU::Code code) {
	_pdu[1] = code;
	// there is a limited set of response codes
}

/// Gets the CoAP response code
CoapPDU::Code CoapPDU::getCode() {
	return (CoapPDU::Code)_pdu[1];
}


/// Converts a http status code as an integer, to a CoAP code.
/**
 * \\param httpStatus the HTTP status code as an integer (e.g 200)
 * \\return The correct corresponding CoapPDU::Code on success,
 * CoapPDU::COAP_UNDEFINED_CODE on failure.
 */
CoapPDU::Code CoapPDU::httpStatusToCode(int httpStatus) {
	switch(httpStatus) {
		case 1:
			return CoapPDU::COAP_GET;
		case 2:
			return CoapPDU::COAP_POST;
		case 3:
			return CoapPDU::COAP_PUT;
		case 4:
			return CoapPDU::COAP_DELETE;
		case 201:
			return CoapPDU::COAP_CREATED;
		case 202:
			return CoapPDU::COAP_DELETED;
		case 203:
			return CoapPDU::COAP_VALID;
		case 204:
			return CoapPDU::COAP_CHANGED;
		case 205:
			return CoapPDU::COAP_CONTENT;
		case 400:
			return CoapPDU::COAP_BAD_REQUEST;
		case 401:
			return CoapPDU::COAP_UNAUTHORIZED;
		case 402:
			return CoapPDU::COAP_BAD_OPTION;
		case 403:
			return CoapPDU::COAP_FORBIDDEN;
		case 404:
			return CoapPDU::COAP_NOT_FOUND;
		case 405:
			return CoapPDU::COAP_METHOD_NOT_ALLOWED;
		case 406:
			return CoapPDU::COAP_NOT_ACCEPTABLE;
		case 412:
			return CoapPDU::COAP_PRECONDITION_FAILED;
		case 413:
			return CoapPDU::COAP_REQUEST_ENTITY_TOO_LARGE;
		case 415:
			return CoapPDU::COAP_UNSUPPORTED_CONTENT_FORMAT;
		case 500:
			return CoapPDU::COAP_INTERNAL_SERVER_ERROR;
		case 501:
			return CoapPDU::COAP_NOT_IMPLEMENTED;
		case 502:
			return CoapPDU::COAP_BAD_GATEWAY;
		case 503:
			return CoapPDU::COAP_SERVICE_UNAVAILABLE;
		case 504:
			return CoapPDU::COAP_GATEWAY_TIMEOUT;
		case 505:
			return CoapPDU::COAP_PROXYING_NOT_SUPPORTED;
		default:
			return CoapPDU::COAP_UNDEFINED_CODE;
	}
}

/// Set messageID to the supplied value.
/**
 * \\param messageID A 16bit message id.
 * \\return 0 on success, 1 on failure.
 */
int CoapPDU::setMessageID(uint16_t messageID) {
	// message ID is stored in network byte order
	uint8_t *to = &_pdu[2];
	endian_store16(to, messageID);
	return 0;
}

/// Returns the 16 bit message ID of the PDU.
uint16_t CoapPDU::getMessageID() {
	// mesasge ID is stored in network byteorder
	uint8_t *from = &_pdu[2];
	uint16_t messageID = endian_load16(uint16_t, from);
	return messageID;
}

/// Returns the length of the PDU.
int CoapPDU::getPDULength() {
	return _pduLength;
}

/// Return the number of options that the PDU has.
int CoapPDU::getNumOptions() {
	return _numOptions;
}


/**
 * This returns the options as a sequence of structs.
 */
CoapPDU::CoapOption* CoapPDU::getOptions() {
	DBG(""getOptions() called, %d options."",_numOptions);

	uint16_t optionDelta =0, optionNumber = 0, optionValueLength = 0;
	int totalLength = 0;

	if(_numOptions==0) {
		return NULL;
	}

	// malloc space for options
	CoapOption *options = (CoapOption*)malloc(_numOptions*sizeof(CoapOption));
	if(options==NULL) {
		DBG(""Failed to allocate memory for options."");
		return NULL;
	}

	// first option occurs after token
	int optionPos = COAP_HDR_SIZE + getTokenLength();

	// walk over options and record information
	for(int i=0; i<_numOptions; i++) {
		// extract option details
		optionDelta = getOptionDelta(&_pdu[optionPos]);
		optionNumber += optionDelta;
		optionValueLength = getOptionValueLength(&_pdu[optionPos]);
		// compute total length
		totalLength = 1; // mandatory header
		totalLength += computeExtraBytes(optionDelta);
		totalLength += computeExtraBytes(optionValueLength);
		totalLength += optionValueLength;
		// record option details
		options[i].optionNumber = optionNumber;
		options[i].optionDelta = optionDelta;
		options[i].optionValueLength = optionValueLength;
		options[i].totalLength = totalLength;
		options[i].optionPointer = &_pdu[optionPos];
		options[i].optionValuePointer = &_pdu[optionPos+totalLength-optionValueLength];
		// move to next option
		optionPos += totalLength;
	}

	return options;
}

/// Add an option to the PDU.
/**
 * Unlike other implementations, options can be added in any order, and in-memory manipulation will be
 * performed to ensure the correct ordering of options (they use a delta encoding of option numbers).
 * Re-ordering memory like this incurs a small performance cost, so if you care about this, then you
 * might want to add options in ascending order of option number.
 * \\param optionNumber The number of the option, see the enum CoapPDU::Option for shorthand notations.
 * \\param optionLength The length of the option payload in bytes.
 * \\param optionValue A pointer to the byte sequence that is the option payload (bytes will be copied).
 * \\return 0 on success, 1 on failure.
 */
int CoapPDU::addOption(uint16_t insertedOptionNumber, uint16_t optionValueLength, uint8_t *optionValue) {
	// this inserts the option in memory, and re-computes the deltas accordingly
	// prevOption <-- insertionPosition
	// nextOption

	// find insertion location and previous option number
	uint16_t prevOptionNumber = 0; // option number of option before insertion point
	int insertionPosition = findInsertionPosition(insertedOptionNumber,&prevOptionNumber);
	DBG(""inserting option at position %d, after option with number: %hu"",insertionPosition,prevOptionNumber);

	// compute option delta length
	uint16_t optionDelta = insertedOptionNumber-prevOptionNumber;
	uint8_t extraDeltaBytes = computeExtraBytes(optionDelta);

	// compute option length length
	uint16_t extraLengthBytes = computeExtraBytes(optionValueLength);

	// compute total length of option
	uint16_t optionLength = COAP_OPTION_HDR_BYTE + extraDeltaBytes + extraLengthBytes + optionValueLength;

	// if this is at the end of the PDU, job is done, just malloc and insert
	if(insertionPosition==_pduLength) {
		DBG(""Inserting at end of PDU"");
		// optionNumber must be biggest added
		_maxAddedOptionNumber = insertedOptionNumber;

		// set new PDU length and allocate space for extra option
		int oldPDULength = _pduLength;
		_pduLength += optionLength;
		if(!_constructedFromBuffer) {
			uint8_t *newMemory = (uint8_t*)realloc(_pdu,_pduLength);
			if(newMemory==NULL) {
				DBG(""Failed to allocate memory for option."");
				_pduLength = oldPDULength;
				// malloc failed
				return 1;
			}
			_pdu = newMemory;
			_bufferLength = _pduLength;
		} else {
			// constructed from buffer, check space
			if(_pduLength>_bufferLength) {
				DBG(""Buffer too small for new option: needed %d, got %d."",_pduLength-oldPDULength,_bufferLength-oldPDULength);
				_pduLength = oldPDULength;
				return 1;
			}
		}

		// insert option at position
		insertOption(insertionPosition,optionDelta,optionValueLength,optionValue);
		_numOptions++;
		return 0;
	}
	// XXX could do 0xFF pdu payload case for changing of dynamically allocated application space SDUs < yeah, if you're insane

	// the next option might (probably) needs it's delta changing
	// I want to take this into account when allocating space for the new
	// option, to avoid having to do two mallocs, first get info about this option
	int nextOptionDelta = getOptionDelta(&_pdu[insertionPosition]);
	int nextOptionNumber = prevOptionNumber + nextOptionDelta;
	int nextOptionDeltaBytes = computeExtraBytes(nextOptionDelta);
	DBG(""nextOptionDeltaBytes: %d"",nextOptionDeltaBytes);
	// recompute option delta, relative to inserted option
	int newNextOptionDelta = nextOptionNumber-insertedOptionNumber;
	int newNextOptionDeltaBytes = computeExtraBytes(newNextOptionDelta);
	DBG(""newNextOptionDeltaBytes: %d"",newNextOptionDeltaBytes);
	// determine adjustment
	int optionDeltaAdjustment = newNextOptionDeltaBytes-nextOptionDeltaBytes;

	// create space for new option, including adjustment space for option delta
	DBG_PDU();
	DBG(""Creating space"");
	int mallocLength = optionLength+optionDeltaAdjustment;
	int oldPDULength = _pduLength;
	_pduLength += mallocLength;

	if(!_constructedFromBuffer) {
		uint8_t *newMemory = (uint8_t*)realloc(_pdu,_pduLength);
		if(newMemory==NULL) {
			DBG(""Failed to allocate memory for option"");
			_pduLength = oldPDULength;
			return 1;
		}
		_pdu = newMemory;
		_bufferLength = _pduLength;
	} else {
		// constructed from buffer, check space
		if(_pduLength>_bufferLength) {
			DBG(""Buffer too small to contain option, needed %d, got %d."",_pduLength-oldPDULength,_bufferLength-oldPDULength);
			_pduLength = oldPDULength;
			return 1;
		}
	}

	// move remainder of PDU data up to create hole for new option
	DBG_PDU();
	DBG(""Shifting PDU."");
	shiftPDUUp(mallocLength,_pduLength-(insertionPosition+mallocLength));
	DBG_PDU();

	// adjust option delta bytes of following option
	// move the option header to the correct position
	int nextHeaderPos = insertionPosition+mallocLength;
	_pdu[nextHeaderPos-optionDeltaAdjustment] = _pdu[nextHeaderPos];
	nextHeaderPos -= optionDeltaAdjustment;
	// and set the new value
	setOptionDelta(nextHeaderPos, newNextOptionDelta);

	// new option shorter
	// p p n n x x x x x
	// p p n n x x x x x -
	// p p - n n x x x x x
	// p p - - n x x x x x
	// p p o o n x x x x x

	// new option longer
	// p p n n x x x x x
	// p p n n x x x x x - - -
	// p p - - - n n x x x x x
	// p p - - n n n x x x x x
	// p p o o n n n x x x x x

	// note, it can only ever be shorter or the same since if an option was inserted the delta got smaller
	// but I'll leave that little comment in, just to show that it would work even if the delta got bigger

	// now insert the new option into the gap
	DBGLX(""Inserting new option..."");
	insertOption(insertionPosition,optionDelta,optionValueLength,optionValue);
	DBGX(""done\\r\\n"");
	DBG_PDU();

	// done, mark it with B!
	_numOptions++;
	return 0;
}

/// Allocate space for a payload.
/**
 * For dynamically constructed PDUs, this will allocate space for a payload in the object
 * and return a pointer to it. If the PDU was constructed from a buffer, this doesn't
 * malloc anything, it just changes the _pduLength and returns the payload pointer.
 *
 * \\note The pointer returned points into the PDU buffer.
 * \\param len The length of the payload buffer to allocate.
 * \\return Either a pointer to the payload buffer, or NULL if there wasn't enough space / allocation failed.
 */
uint8_t* CoapPDU::mallocPayload(int len) {
	DBG(""Entering mallocPayload"");
	// sanity checks
	if(len==0) {
		DBG(""Cannot allocate a zero length payload"");
		return NULL;
	}

	// further sanity
	if(len==_payloadLength) {
		DBG(""Space for payload of specified length already exists"");
		if(_payloadPointer==NULL) {
			DBG(""Garbage PDU. Payload length is %d, but existing _payloadPointer NULL"",_payloadLength);
			return NULL;
		}
		return _payloadPointer;
	}

	DBG(""_bufferLength: %d, _pduLength: %d, _payloadLength: %d"",_bufferLength,_pduLength,_payloadLength);

	// might be making payload bigger (including bigger than 0) or smaller
	int markerSpace = 1;
	int payloadSpace = len;
	// is this a resizing?
	if(_payloadLength!=0) {
		// marker already exists
		markerSpace = 0;
		// compute new payload length (can be negative if shrinking payload)
		payloadSpace = len-_payloadLength;
	}

	// make space for payload (and payload marker if necessary)
	int newLen = _pduLength+payloadSpace+markerSpace;
	if(!_constructedFromBuffer) {
		uint8_t* newPDU = (uint8_t*)realloc(_pdu,newLen);
		if(newPDU==NULL) {
			DBG(""Cannot allocate (or shrink) space for payload"");
			return NULL;
		}
		_pdu = newPDU;
		_bufferLength = newLen;
	} else {
		// constructed from buffer, check space
		DBG(""newLen: %d, _bufferLength: %d"",newLen,_bufferLength);
		if(newLen>_bufferLength) {
			DBG(""Buffer too small to contain desired payload, needed %d, got %d."",newLen-_pduLength,_bufferLength-_pduLength);
			return NULL;
		}
	}

	// deal with fresh allocation case separately
	if(_payloadPointer==NULL) {
		// set payload marker
		_pdu[_pduLength] = 0xFF;
		// payload at end of old PDU
		_payloadPointer = &_pdu[_pduLength+1];
		_pduLength = newLen;
		_payloadLength = len;
		return _payloadPointer;
	}

	// otherwise, just adjust length of PDU
	_pduLength = newLen;
	_payloadLength = len;
	DBG(""Leaving mallocPayload"");
	return _payloadPointer;
}

/// Set the payload to the byte sequence specified. Allocates memory in dynamic PDU if necessary.
/**
 * This will set the payload to \\b payload. It will allocate memory in the case where the PDU was
 * constructed without an external buffer.
 *
 * This will fail either if the fixed buffer isn't big enough, or if memory could not be allocated
 * in the non-external-buffer case.
 *
 * \\param payload Pointer to payload byte sequence.
 * \\param len Length of payload byte sequence.
 * \\return 0 on success, 1 on failure.
 */
int CoapPDU::setPayload(uint8_t *payload, int len) {
	if(payload==NULL) {
		DBG(""NULL payload pointer."");
		return 1;
	}

	uint8_t *payloadPointer = mallocPayload(len);
	if(payloadPointer==NULL) {
		DBG(""Allocation of payload failed"");
		return 1;
	}

	// copy payload contents
	memcpy(payloadPointer,payload,len);

	return 0;
}

/// Returns a pointer to the payload buffer.
uint8_t* CoapPDU::getPayloadPointer() {
	return _payloadPointer;
}

/// Gets the length of the payload buffer.
int CoapPDU::getPayloadLength() {
	return _payloadLength;
}

/// Returns a pointer to a buffer which is a copy of the payload buffer (dynamically allocated).
uint8_t* CoapPDU::getPayloadCopy() {
	if(_payloadLength==0) {
		return NULL;
	}

	// malloc space for copy
	uint8_t *payload = (uint8_t*)malloc(_payloadLength);
	if(payload==NULL) {
		DBG(""Unable to allocate memory for payload"");
		return NULL;
	}

	// copy and return
	memcpy(payload,_payloadPointer,_payloadLength);
	return payload;
}

/// Shorthand for setting the content-format option.
/**
 * Sets the content-format to the specified value (adds an option).
 * \\param format The content format, one of:
 *
 * - COAP_CONTENT_FORMAT_TEXT_PLAIN
 * - COAP_CONTENT_FORMAT_APP_LINK
 * - COAP_CONTENT_FORMAT_APP_XML
 * - COAP_CONTENT_FORMAT_APP_OCTET
 * - COAP_CONTENT_FORMAT_APP_EXI
 * - COAP_CONTENT_FORMAT_APP_JSON
 *
 * \\return 0 on success, 1 on failure.
 */
int CoapPDU::setContentFormat(CoapPDU::ContentFormat format) {
	if(format==0) {
		// minimal representation means null option value
		if(addOption(CoapPDU::COAP_OPTION_CONTENT_FORMAT,0,NULL)!=0) {
			DBG(""Error setting content format"");
			return 1;
		}
		return 0;
	}

	uint8_t c[2];

	// just use 1 byte if can do it
	if((uint16_t)format <= 0xffu) {
		c[0] = format;
		if(addOption(CoapPDU::COAP_OPTION_CONTENT_FORMAT,1,c)!=0) {
			DBG(""Error setting content format"");
			return 1;
		}
		return 0;
	}

	uint8_t *to = c;
	endian_store16(to, format);
	if(addOption(CoapPDU::COAP_OPTION_CONTENT_FORMAT,2,c)!=0) {
		DBG(""Error setting content format"");
		return 1;
	}
	return 0;
}

// PRIVATE PRIVATE PRIVATE PRIVATE PRIVATE PRIVATE PRIVATE
// PRIVATE PRIVATE PRIVATE PRIVATE PRIVATE PRIVATE PRIVATE

/// Moves a block of bytes to end of PDU from given offset.
/**
 * This moves the block of bytes _pdu[_pduLength-1-shiftOffset-shiftAmount] ... _pdu[_pduLength-1-shiftOffset]
 * to the end of the PDU.
 * \\param shiftOffset End of block to move, relative to end of PDU (-1).
 * \\param shiftAmount Length of block to move.
 */
void CoapPDU::shiftPDUUp(int shiftOffset, int shiftAmount) {
	DBG(""shiftOffset: %d, shiftAmount: %d"",shiftOffset,shiftAmount);
	int destPointer = _pduLength-1;
	int srcPointer  = destPointer-shiftOffset;
	while(shiftAmount--) {
		_pdu[destPointer] = _pdu[srcPointer];
		destPointer--;
		srcPointer--;
	}
}

/// Moves a block of bytes down a specified number of steps.
/**
 * Moves the block of bytes _pdu[startLocation+shiftOffset] ... _pdu[startLocation+shiftOffset+shiftAmount]
 * down to \\b startLocation.
 * \\param startLocation Index where to shift the block to.
 * \\param shiftOffset Where the block starts, relative to start index.
 * \\param shiftAmount Length of block to shift.
 */
void CoapPDU::shiftPDUDown(int startLocation, int shiftOffset, int shiftAmount) {
	DBG(""startLocation: %d, shiftOffset: %d, shiftAmount: %d"",startLocation,shiftOffset,shiftAmount);
	int srcPointer = startLocation+shiftOffset;
	while(shiftAmount--) {
		_pdu[startLocation] = _pdu[srcPointer];
		startLocation++;
		srcPointer++;
	}
}

/// Gets the payload length of an option.
/**
 * \\param option Pointer to location of option in PDU.
 * \\return The 16 bit option-payload length.
 */
uint16_t CoapPDU::getOptionValueLength(uint8_t *option) {
	uint16_t delta = (option[0] & 0xF0) >> 4;
	uint16_t length = (option[0] & 0x0F);
	// no extra bytes
	if(length<13) {
		return length;
	}

	// extra bytes skip header
	int offset = 1;
	// skip extra option delta bytes
	if(delta==13) {
		offset++;
	} else if(delta==14) {
		offset+=2;
	}

	// process length
	if(length==13) {
		return (option[offset]+13);
	} else {
		uint8_t *from = &option[offset];
		uint16_t value = endian_load16(uint16_t, from);
		return value+269;
	}

}

/// Gets the delta of an option.
/**
 * \\param option Pointer to location of option in PDU.
 * \\return The 16 bit delta.
 */
uint16_t CoapPDU::getOptionDelta(uint8_t *option) {
	uint16_t delta = (option[0] & 0xF0) >> 4;
	if(delta<13) {
		return delta;
	} else if(delta==13) {
		// single byte option delta
		return (option[1]+13);
	} else if(delta==14) {
		uint8_t *from = &option[1];
		uint16_t value = endian_load16(uint16_t, from);
		return value+269;
	} else {
		// should only ever occur in payload marker
		return delta;
	}
}

/// Finds the insertion position in the current list of options for the specified option.
/**
 * \\param optionNumber The option's number.
 * \\param prevOptionNumber A pointer to a uint16_t which will store the option number of the option previous
 * to the insertion point.
 * \\return 0 on success, 1 on failure. \\b prevOptionNumber will contain the option number of the option
 * before the insertion position (for example 0 if no options have been inserted).
 */
int CoapPDU::findInsertionPosition(uint16_t optionNumber, uint16_t *prevOptionNumber) {
	// zero this for safety
	*prevOptionNumber = 0x00;

	DBG(""_pduLength: %d"",_pduLength);

	// if option is bigger than any currently stored, it goes at the end
	// this includes the case that no option has yet been added
	if( (optionNumber >= _maxAddedOptionNumber) || (_pduLength == (COAP_HDR_SIZE+getTokenLength())) ) {
		*prevOptionNumber = _maxAddedOptionNumber;
		return _pduLength;
	}

	// otherwise walk over the options
	int optionPos = COAP_HDR_SIZE + getTokenLength();
	uint16_t optionDelta = 0, optionValueLength = 0;
	uint16_t currentOptionNumber = 0;
	while(optionPos<_pduLength && _pdu[optionPos]!=0xFF) {
		optionDelta = getOptionDelta(&_pdu[optionPos]);
		currentOptionNumber += optionDelta;
		optionValueLength = getOptionValueLength(&_pdu[optionPos]);
		// test if this is insertion position
		if(currentOptionNumber>optionNumber) {
			return optionPos;
		}
		// keep track of the last valid option number
		*prevOptionNumber = currentOptionNumber;
		// move onto next option
		optionPos += computeExtraBytes(optionDelta);
		optionPos += computeExtraBytes(optionValueLength);
		optionPos += optionValueLength;
		optionPos++; // (for mandatory option header byte)
	}
	return optionPos;

}

/// CoAP uses a minimal-byte representation for length fields. This returns the number of bytes needed to represent a given length.
int CoapPDU::computeExtraBytes(uint16_t n) {
	if(n<13) {
		return 0;
	}

	if(n<269) {
		return 1;
	}

	return 2;
}

/// Set the option delta to the specified value.
/**
 * This assumes space has been made for the option delta.
 * \\param optionPosition The index of the option in the PDU.
 * \\param optionDelta The option delta value to set.
 */
void CoapPDU::setOptionDelta(int optionPosition, uint16_t optionDelta) {
	int headerStart = optionPosition;
	// clear the old option delta bytes
	_pdu[headerStart] &= 0x0F;

	// set the option delta bytes
	if(optionDelta<13) {
		_pdu[headerStart] |= (optionDelta << 4);
	} else if(optionDelta<269) {
	   // 1 extra byte
		_pdu[headerStart] |= 0xD0; // 13 in first nibble
		_pdu[++optionPosition] &= 0x00;
		_pdu[optionPosition] |= (optionDelta-13);
	} else {
		// 2 extra bytes, network byte order uint16_t
		_pdu[headerStart] |= 0xE0; // 14 in first nibble
		optionDelta -= 269;
		uint8_t *to = &_pdu[++optionPosition];
		endian_store16(to, optionDelta);
	}
}

/// Insert an option in-memory at the specified location.
/**
 * This assumes that there is enough space at the location specified.
 * \\param insertionPosition Position in the PDU where the option should be placed.
 * \\param optionDelta The delta value for the option.
 * \\param optionValueLength The length of the option value.
 * \\param optionValue A pointer to the sequence of bytes representing the option value.
 * \\return 0 on success, 1 on failure.
 */
int CoapPDU::insertOption(
	int insertionPosition,
	uint16_t optionDelta,
	uint16_t optionValueLength,
	uint8_t *optionValue) {

	int headerStart = insertionPosition;

	// clear old option header start
	_pdu[headerStart] &= 0x00;

	// set the option delta bytes
	if(optionDelta<13) {
		_pdu[headerStart] |= (optionDelta << 4);
	} else if(optionDelta<269) {
	   // 1 extra byte
		_pdu[headerStart] |= 0xD0; // 13 in first nibble
		_pdu[++insertionPosition] &= 0x00;
		_pdu[insertionPosition] |= (optionDelta-13);
	} else {
		// 2 extra bytes, network byte order uint16_t
		_pdu[headerStart] |= 0xE0; // 14 in first nibble
		optionDelta -= 269;
		uint8_t *to = &_pdu[++insertionPosition];
		endian_store16(to, optionDelta);
		insertionPosition += 1;
	}

	// set the option value length bytes
	if(optionValueLength<13) {
		_pdu[headerStart] |= (optionValueLength & 0x000F);
	} else if(optionValueLength<269) {
		_pdu[headerStart] |= 0x0D; // 13 in second nibble
		_pdu[++insertionPosition] &= 0x00;
		_pdu[insertionPosition] |= (optionValueLength-13);
	} else {
		_pdu[headerStart] |= 0x0E; // 14 in second nibble
		// this is in network byte order
		DBG(""optionValueLength: %u"",optionValueLength);
		uint8_t *to = &_pdu[++insertionPosition];
		optionValueLength -= 269;
		endian_store16(to, optionValueLength);
		insertionPosition += 1;
	}

	// and finally copy the option value itself
	memcpy(&_pdu[++insertionPosition],optionValue,optionValueLength);

	return 0;
}

// DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG
// DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG DEBUG

/// Prints the PDU in human-readable format.
void CoapPDU::printHuman() {
	INFO(""__________________"");
	if(_constructedFromBuffer) {
		INFO(""PDU was constructed from buffer of %d bytes"",_bufferLength);
	}
	INFO(""PDU is %d bytes long"",_pduLength);
	INFO(""CoAP Version: %d"",getVersion());
	INFOX(""Message Type: "");
	switch(getType()) {
		case COAP_CONFIRMABLE:
			INFO(""Confirmable"");
		break;

		case COAP_NON_CONFIRMABLE:
			INFO(""Non-Confirmable"");
		break;

		case COAP_ACKNOWLEDGEMENT:
			INFO(""Acknowledgement"");
		break;

		case COAP_RESET:
			INFO(""Reset"");
		break;
	}
	INFO(""Token length: %d"",getTokenLength());
	INFOX(""Code: "");
	switch(getCode()) {
		case COAP_EMPTY:
			INFO(""0.00 Empty"");
		break;
		case COAP_GET:
			INFO(""0.01 GET"");
		break;
		case COAP_POST:
			INFO(""0.02 POST"");
		break;
		case COAP_PUT:
			INFO(""0.03 PUT"");
		break;
		case COAP_DELETE:
			INFO(""0.04 DELETE"");
		break;
		case COAP_CREATED:
			INFO(""2.01 Created"");
		break;
		case COAP_DELETED:
			INFO(""2.02 Deleted"");
		break;
		case COAP_VALID:
			INFO(""2.03 Valid"");
		break;
		case COAP_CHANGED:
			INFO(""2.04 Changed"");
		break;
		case COAP_CONTENT:
			INFO(""2.05 Content"");
		break;
		case COAP_BAD_REQUEST:
			INFO(""4.00 Bad Request"");
		break;
		case COAP_UNAUTHORIZED:
			INFO(""4.01 Unauthorized"");
		break;
		case COAP_BAD_OPTION:
			INFO(""4.02 Bad Option"");
		break;
		case COAP_FORBIDDEN:
			INFO(""4.03 Forbidden"");
		break;
		case COAP_NOT_FOUND:
			INFO(""4.04 Not Found"");
		break;
		case COAP_METHOD_NOT_ALLOWED:
			INFO(""4.05 Method Not Allowed"");
		break;
		case COAP_NOT_ACCEPTABLE:
			INFO(""4.06 Not Acceptable"");
		break;
		case COAP_PRECONDITION_FAILED:
			INFO(""4.12 Precondition Failed"");
		break;
		case COAP_REQUEST_ENTITY_TOO_LARGE:
			INFO(""4.13 Request Entity Too Large"");
		break;
		case COAP_UNSUPPORTED_CONTENT_FORMAT:
			INFO(""4.15 Unsupported Content-Format"");
		break;
		case COAP_INTERNAL_SERVER_ERROR:
			INFO(""5.00 Internal Server Error"");
		break;
		case COAP_NOT_IMPLEMENTED:
			INFO(""5.01 Not Implemented"");
		break;
		case COAP_BAD_GATEWAY:
			INFO(""5.02 Bad Gateway"");
		break;
		case COAP_SERVICE_UNAVAILABLE:
			INFO(""5.03 Service Unavailable"");
		break;
		case COAP_GATEWAY_TIMEOUT:
			INFO(""5.04 Gateway Timeout"");
		break;
		case COAP_PROXYING_NOT_SUPPORTED:
			INFO(""5.05 Proxying Not Supported"");
		break;
		default:
			INFO(""Undefined Code %u"",(unsigned)(getCode()));
	}

	// print message ID
	INFO(""Message ID: %u"",getMessageID());

	// print token value
	int tokenLength = getTokenLength();
	uint8_t *tokenPointer = getPDUPointer()+COAP_HDR_SIZE;
	if(tokenLength==0) {
		INFO(""No token."");
	} else {
		INFO(""Token of %d bytes."",tokenLength);
		INFOX(""   Value: 0x"");
		for(int j=0; j<tokenLength; j++) {
			INFOX(""%.2x"",tokenPointer[j]);
		}
		INFO("" "");
	}

	// print options
	CoapPDU::CoapOption* options = getOptions();
	if(options==NULL) {
		INFO(""NO options"");
	} else {
		INFO(""%d options:"",_numOptions);
	}
	
	for(int i=0; i<_numOptions; i++) {
		INFO(""OPTION (%d/%d)"",i + 1,_numOptions);
		INFO(""   Option number (delta): %hu (%hu)"",options[i].optionNumber,options[i].optionDelta);
		INFOX(""   Name: "");
		switch(options[i].optionNumber) {
			case COAP_OPTION_IF_MATCH:
				INFO(""IF_MATCH"");
			break;
			case COAP_OPTION_URI_HOST:
				INFO(""URI_HOST"");
			break;
			case COAP_OPTION_ETAG:
				INFO(""ETAG"");
			break;
			case COAP_OPTION_IF_NONE_MATCH:
				INFO(""IF_NONE_MATCH"");
			break;
			case COAP_OPTION_OBSERVE:
				INFO(""OBSERVE"");
			break;
			case COAP_OPTION_URI_PORT:
				INFO(""URI_PORT"");
			break;
			case COAP_OPTION_LOCATION_PATH:
				INFO(""LOCATION_PATH"");
			break;
			case COAP_OPTION_URI_PATH:
				INFO(""URI_PATH"");
			break;
			case COAP_OPTION_CONTENT_FORMAT:
				INFO(""CONTENT_FORMAT"");
			break;
			case COAP_OPTION_MAX_AGE:
				INFO(""MAX_AGE"");
			break;
			case COAP_OPTION_URI_QUERY:
				INFO(""URI_QUERY"");
			break;
			case COAP_OPTION_ACCEPT:
				INFO(""ACCEPT"");
			break;
			case COAP_OPTION_LOCATION_QUERY:
				INFO(""LOCATION_QUERY"");
			break;
			case COAP_OPTION_PROXY_URI:
				INFO(""PROXY_URI"");
			break;
			case COAP_OPTION_PROXY_SCHEME:
				INFO(""PROXY_SCHEME"");
			break;
			case COAP_OPTION_BLOCK1:
				INFO(""BLOCK1"");
			break;
			case COAP_OPTION_BLOCK2:
				INFO(""BLOCK2"");
			break;
			case COAP_OPTION_SIZE1:
				INFO(""SIZE1"");
			break;
			case COAP_OPTION_SIZE2:
				INFO(""SIZE2"");
			break;
			default:
				INFO(""Unknown option %u"",(unsigned)options[i].optionNumber);
			break;
		}
		INFO(""   Value length: %u"",options[i].optionValueLength);
		INFOX(""   Value: \\"""");
		for(int j=0; j<options[i].optionValueLength; j++) {
			char c = options[i].optionValuePointer[j];
			if((c>='!'&&c<='~')||c==' ') {
				INFOX(""%c"",c);
			} else {
				INFOX(""\\\\%.2d"",c);
			}
		}
		INFO(""\\"""");
	}

	// print payload
	if(_payloadLength==0) {
		INFO(""No payload."");
	} else {
		INFO(""Payload of %d bytes"",_payloadLength);
		INFOX(""   Value: \\"""");
		for(int j=0; j<_payloadLength; j++) {
			char c = _payloadPointer[j];
			if((c>='!'&&c<='~')||c==' ') {
				INFOX(""%c"",c);
			} else {
				INFOX(""\\\\%.2x"",c);
			}
		}
		INFO(""\\"""");
	}
	free(options);
	INFO(""__________________"");
}

/// Prints the PDU as a c array (useful for debugging or hardcoding PDUs)
void CoapPDU::printPDUAsCArray() {
	printf(""const uint8_t array[] = {\\r\\n   "");
	for(int i=0; i<_pduLength; i++) {
		printf(""0x%.2x, "",_pdu[i]);
	}
	printf(""\\r\\n};\\r\\n"");
}

/// A routine for printing an option in human-readable format.
/**
 * \\param option This is a pointer to where the option begins in the PDU.
 */
void CoapPDU::printOptionHuman(uint8_t *option) {
	// compute some useful stuff
	uint16_t optionDelta = getOptionDelta(option);
	uint16_t optionValueLength = getOptionValueLength(option);
	int extraDeltaBytes = computeExtraBytes(optionDelta);
	int extraValueLengthBytes = computeExtraBytes(optionValueLength);
	int totalLength = 1+extraDeltaBytes+extraValueLengthBytes+optionValueLength;

	if(totalLength>_pduLength) {
		totalLength = &_pdu[_pduLength-1]-option;
		DBG(""New length: %u"",totalLength);
	}

	// print summary
	DBG(""~~~~~~ Option ~~~~~~"");
	DBG(""Delta: %u, Value length: %u"",optionDelta,optionValueLength);

	// print all bytes
	DBG(""All bytes (%d):"",totalLength);
	for(int i=0; i<totalLength; i++) {
		if(i%4==0) {
			DBG("" "");
			DBGX(""   %.2d "",i);
		}
		CoapPDU::printBinary(option[i]); DBGX("" "");
	}
	DBG("" ""); DBG("" "");

	// print header byte
	DBG(""Header byte:"");
	DBGX(""   "");
	CoapPDU::printBinary(*option++);
	DBG("" ""); DBG("" "");

	// print extended delta bytes
	if(extraDeltaBytes) {
		DBG(""Extended delta bytes (%d) in network order: "",extraDeltaBytes);
		DBGX(""   "");
		while(extraDeltaBytes--) {
			CoapPDU::printBinary(*option++); DBGX("" "");
		}
	} else {
		DBG(""No extended delta bytes"");
	}
	DBG("" ""); DBG("" "");

	// print extended value length bytes
	if(extraValueLengthBytes) {
		DBG(""Extended value length bytes (%d) in network order: "",extraValueLengthBytes);
		DBGX(""   "");
		while(extraValueLengthBytes--) {
			CoapPDU::printBinary(*option++); DBGX("" "");
		}
	} else {
		DBG(""No extended value length bytes"");
	}
	DBG("" "");

	// print option value
	DBG(""Option value bytes:"");
	for(int i=0; i<optionValueLength; i++) {
		if(i%4==0) {
			DBG("" "");
			DBGX(""   %.2d "",i);
		}
		CoapPDU::printBinary(*option++);
		DBGX("" "");
	}
	DBG("" "");
}

/// Dumps the PDU header in hex.
void CoapPDU::printHex() {
	printf(""Hexd dump of PDU len:%d\\r\\n"",_pduLength);
	for(int i=0; i<_pduLength; i++) {
		if(i%4==0) {
			printf(""\\r\\n"");
			printf(""%.2d: "",i);
		}
		printf(""%.2x "",_pdu[i]);
	}
	printf(""\\r\\n"");
}

/// Dumps the entire PDU in binary.
void CoapPDU::printBin() {
	printf(""Bin dump of PDU len:%d\\r\\n"",_pduLength);
	for(int i=0; i<_pduLength; i++) {
		if(i%4==0) {
			printf(""\\r\\n"");
			printf(""%.2d: "",i);
		}
		CoapPDU::printBinary(_pdu[i]); printf("" "");
	}
	printf(""\\r\\n"");
}

/// Prints a single byte in binary.
void CoapPDU::printBinary(uint8_t b) {
	printf(""%d%d%d%d%d%d%d%d"",
		((b & 0x80) != 0 ? 1 : 0),
		((b & 0x40) != 0 ? 1 : 0),
		((b & 0x20) != 0 ? 1 : 0),
		((b & 0x10) != 0 ? 1 : 0),
		((b & 0x08) != 0 ? 1 : 0),
		((b & 0x04) != 0 ? 1 : 0),
		((b & 0x02) != 0 ? 1 : 0),
		((b & 0x01) != 0 ? 1 : 0));
}

/// Dumps the PDU as a byte sequence to stdout.
void CoapPDU::print() {
	fwrite(_pdu,1,_pduLength,stdout);
}
",16173,True,2682.523869562016,median
"// I2C device class (I2Cdev) Arduino library for MPU6050 class using DMP (MotionApps v2.0)
// 6/21/2012 by Jeff Rowberg <jeff@rowberg.net>
// Updates should (hopefully) always be available at https://github.com/jrowberg/i2cdevlib
/*
I2Cdev device library code is placed under the MIT license
Copyright (c) 2012 Jeff Rowberg

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.
===============================================
*/

/*
This sketch provides an interface for a Arduino Lenardo to 
drive a L298 Dual Motor Control Board and a 16x2 LCD/Keypad SAINSMART Shield.
The Code is also setup to read dmp data from a MPU6050 digital gyro.
The prime purpose of this code is to control a two wheeled balance-bot type car
The PID constants have been optimized for 'N20' gear motors, powered by 8 AA NiMh rechargable batteries. 
The LCD Display/Keypad provides a limited user interface. [Select Aout Balance Point ON/OFF & Twirl or Stationary Modes]
This code also includes for the use of an IR Distance Detector
When an object, such as a wall is within the detection range (~8""), the code
shifts the pitch effective set-point backwards, until the object is beyond
the range of detection. This in-turn fools the PID into the balance point is behind
the true balance point and as a result the car move backwards trying to maintain its
equilibrium.
*******************************************************************************************
* This code was written to work with a car whose components are arranged as described in: * 
* BalanceBotWiringDiagram.pdf                                                             * 
* and a L298N Break-Out Board configured as shown in:                                     *
* L298NdualHbridge.JPG                                                                    *
*******************************************************************************************
*/

//#include <string.h>
#include <LiquidCrystal.h>
//#include <LCDKeypad.h>
#include ""LCDKeypadR1.h""
//#include <LCD4Bit_mod.h> 

// I2Cdev and MPU6050 must be installed as libraries, or else the .cpp/.h files
// for both classes must be in the include path of your project
#include ""I2Cdev.h""

#include ""MPU6050_6Axis_MotionApps20.h""
// Arduino Wire library is required if I2Cdev I2CDEV_ARDUINO_WIRE implementation
// is used in I2Cdev.h
#if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
    #include ""Wire.h""
#endif

// class default I2C address is 0x68
// specific I2C addresses may be passed as a parameter here
// AD0 low = 0x68 (default for SparkFun breakout and InvenSense evaluation board)
// AD0 high = 0x69
MPU6050 mpu;


//#define OutPut_READABLE_YAWPITCHROLL
#define LED_PIN 12 

#define FORWARD false //true
#define REVERSE true //false
#define RIGHTWHEEL 0
#define LEFTWHEEL 1  //Right Wheel Handle
#define IRSig 1

byte error;

byte address = 0x68;
bool blinkState = false;

// MPU control/status vars
uint8_t mpuIntStatus;   // holds actual interrupt status byte from MPU
uint8_t devStatus;      // return status after each device operation (0 = success, !0 = error)
uint16_t packetSize;    // expected DMP packet size (default is 42 bytes)
uint16_t fifoCount;     // count of all bytes currently in FIFO
uint8_t fifoBuffer[64]; // FIFO storage buffer

// orientation/motion vars
Quaternion q;           // [w, x, y, z]         quaternion container
VectorFloat gravity;    // [x, y, z]            gravity vector
float ypr[3];           // [yaw, pitch, roll]   yaw/pitch/roll container and gravity vector



//create object to control an LCD.  
// select the pins used on the LCD panel
LiquidCrystal lcd(8, 9, 4, 5, 6, 7);
LCDKeypad Keypad;

// Pin 13 has an LED connected on most Arduino boards.
// When the pin is HIGH value, the LED is on, when the pin is LOW, it's off.
// give it a name:
//int led = 13;
int In1 = A5;//1;      // L298 Left Motor Dir Control In1 connected to Arduino digital pin 1
int In2 = A2;//3;      // L298 Left Motor Dir Control In2 connected to Arduino Analog pin 2
int In3 = A4;//0;      // L298 Right Motor Dir Control In3 connected to Arduino digital pin 0
int In4 = A3;//3;      // L298 Right Motor Dir Control In4 connected to Arduino Analog pin 3

int EnA = 11; //11;     // L298 Left Motor Control EnA connected to Digital PWM pin 11
int EnB = 13; //13;     // L298 Right Motor Control EnB connected to Digital PWM pin 13; Note also controls On-Board LED

int SpeedL = 0;         // PWM Value for Motor A (Left Wheel)
int SpeedR = 0;         // PWM Value for Motor B (Right Wheel)
int Speed;
int LastSpeed =0;
int Steer = 0;
double RunningErr = 0.0;
double LastRunningErr = 0.0;
double RunningSpd = 0.0;// Used as part of auto Speed based Balance Correction
double LastRunningSpd = 0.0;// Used as part of auto Speed based Balance Correction
double BPtDif = 0.0;// Used as part of auto Speed based Balance Correction
int loopCnt = 0;
int loopCnt2 = 1;
int loopCnt1 = 0; // auto yaw zero
int loopCnt3 = 0; // auto pitch zero
int loopCnt4 = 0; // auto Speed based Balance Correction
boolean LoopComplete = true;
boolean Gud2Go = false;
boolean Fgr8Mode = false;
boolean LCD_On = false;
boolean SkipUpdate = false;
boolean Rpt_IR = true;
boolean AutoBalPt = true;

unsigned long LastShw = millis();


int buttonPressed;

// IR Distance Detector GP2D15 related Variables
int val = 0; 
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// PID variables
/*working variables*/
unsigned long lastTime;
double InputP, Setpoint;
double ITerm, lastInput;
double kp, ki, kd;
double Kp = 0.32;//0.36; //0.3; 0.0;//
double Ki = 5.4; //3.6;
double Kd = 0.052; //0.042;
double OS = 18;
double BrkPt = 22;
double X = 0.0;
//double gain = 1.0;
double PIDOut = 0.0;
double DeadBnd = 45.0; //62;; DeadBnd = OffSet Lower Limit; used in AplyOffSet routine 
                         // to eliminate Motor deadband throttle values
unsigned long lastTimeS;
double InputY, SetpointS;
double ITermS, lastInputS;
double kpS, kiS, kdS;
double KpS = 1.0;//0.2;
double KiS = 0.3;//0.02;
double KdS = 0.022;//0.022;
double PIDOutS = 0.0;
double DeltaStPt = 10.0; //fixed steering incremental change 
int SampleTime = 25; //1 sec
int IdealSmplTm = SampleTime;
unsigned long SampleTimeP, SampleTimeY;
double Min = -254.0;
double Max = 254.0;
double outMin, outMax;
double PitchBalancePt = 2.29;//2.22;//2.45 A larger positive number makes the car lean further forward
double PtchBalPtRef = PitchBalancePt;
double BackAngleRef = 0.1;
double BackAngle = 0.0;
boolean BackAway = false;
double YawBalancePt = 0.0;
//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
// LCD message
char msgs[9][17] = {""FORWARD Spd"", 
                    ""IR Dect"", 
                    ""BAL PT     "", 
                    ""TURN RIGHT   "", 
                    ""TWIRL 360    "",
                    ""STRAIGHT LINE"",
                    ""PRESS SELECT"",
                    ""AUTO-BAL PT ON "",
                    ""AUTO-BAL PT OFF""};

//++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++




// ================================================================
// ===                      INITIAL SETUP                       ===
// ================================================================

void setup()
{
  //setup PWM frequency to ~60Hz for OutPut pins 13 & 11
  TCCR4B = TCCR4B & 0b11111000 | 0x06; //Set Digital pin 13 Right Wheel PWM period @ ~2ms
  digitalWrite(A1, HIGH);  // set pullup on analog pin 1 
  // initialize the Arduino digital pins as an OutPuts.
  pinMode(In1, OUTPUT);
  pinMode(In2, OUTPUT);
  pinMode(In3, OUTPUT);
  pinMode(In4, OUTPUT);
  lcd.begin(16, 2); 
  ConfigRunMode(); 
    // join I2C bus (I2Cdev library doesn't do this automatically)
    #if I2CDEV_IMPLEMENTATION == I2CDEV_ARDUINO_WIRE
        Wire.begin();
        TWBR = 24; // 400kHz I2C clock (200kHz if CPU is 8MHz)
    #endif
      LCD_On = true;
      lcd.clear();
      lcd.print(""Init MPU6050.."");
      mpu.initialize();
      Serial.begin(9600);
    
    devStatus = mpu.dmpInitialize();

    // supply your own gyro offsets here, scaled for min sensitivity
    //Sensor readings with offsets:	4	4	16380	1	0	0
    //Your offsets:	-1200	-2080	1288	35	-28	-39
    //Data is printed as: acelX acelY acelZ giroX giroY giroZ
    //Check that your sensor readings are close to 0 0 16384 0 0 0

    mpu.setXGyroOffset(35);
    mpu.setYGyroOffset(-28);
    mpu.setZGyroOffset(-39);

    mpu.setXAccelOffset(-1200);
    mpu.setYAccelOffset(-2080);
    mpu.setZAccelOffset(1288);

    if (devStatus == 0) 
     {
          lcd.clear();
        mpu.setDMPEnabled(true);

        mpuIntStatus = mpu.getIntStatus();
        // get expected DMP packet size for later comparison
        packetSize = mpu.dmpGetFIFOPacketSize();
    }

    // configure LED for OutPut
    pinMode(LED_PIN, OUTPUT);
    //initialize PID
    X =  16.0/BrkPt+(OS/(Kp*16.0));
    Setpoint = 0.00; // Robot heading [0 = straight ahead]
    SetTunings(Kp, Ki, Kd);
    SetTuningsS(KpS, KiS, KdS);
    SampleTimeY = (unsigned long)SampleTime;
    SampleTimeP = (unsigned long)SampleTime;
    PIDOut = 0.0;
    PIDOutS = 0.0;
    PitchBalancePt = (M_PI/180)*PitchBalancePt;
    PtchBalPtRef = PitchBalancePt;
    BackAngleRef = (M_PI/180)*BackAngleRef;
    BackAngle = BackAngleRef;
    
    
}
// End Setup


// ================================================================
// ===                    MAIN PROGRAM LOOP                     ===
// ================================================================

void loop() {
     
    // if programming failed, don't try to do anything
    // check for blocking object
    
    val = analogRead(IRSig); // take a distance reading
    //val = 0; //Disable IR detector 
    if (val > 500)
    {
     if(!BackAway)
     {
       BackAway = !BackAway;
     }
    }
    else 
    {
     if(BackAway)
     {
       RunningSpd = 0.0;
       ITerm = 0.0;
       RunningErr = -150.05;
       BackAway = !BackAway;
     }
    }
    
    do // test to see if the MPU answers back [with its address]
    {
     Wire.beginTransmission(address);
     error = Wire.endTransmission();

     if (error != 0)
     {
      //Serial.print(""I2C Addr Pole Returned Error "");
      //Serial.println(error,HEX);
      //ShowMessage(""I2C Err"" ,(int) error, 1, 0);
     }
    }
    while  (error != 0);
    fifoCount = 0;
    while (fifoCount < packetSize)
    {
      fifoCount = mpu.getFIFOCount();
    }
    // get INT_STATUS byte
    mpuIntStatus = mpu.getIntStatus();
    //digitalWrite(LED_PIN, true);
    fifoCount = mpu.getFIFOCount();
    //digitalWrite(LED_PIN, false);
    // check for overflow (this should never happen unless our code is too inefficient)
    // sometimes quits before getting here
    if ((mpuIntStatus & 0x10) || fifoCount == 1024) { //  || fifoCount > 2*packetSize
        // reset so we can continue cleanly
        //lcd.clear();
        //lcd.printIn(""FIFO overflow!"");
        //ShowMessage(""FIFO!"", fifoCount, 1, 0);
        mpu.resetFIFO();

    // otherwise, check for DMP data ready interrupt (this should happen frequently)
    } else if (mpuIntStatus & 0x02) { // never gets here
        // wait for correct available data length, should be a VERY short wait
        while (fifoCount < packetSize)
        {
         fifoCount = mpu.getFIFOCount();
        }
        //Serial.print(fifoCount);
        //Serial.print(""\\t"");
        //Serial.println(packetSize);
        
        
        // read a packet from FIFO
        mpu.getFIFOBytes(fifoBuffer, packetSize);
        //digitalWrite(LED_PIN, false);
        // track FIFO count here in case there is > 1 packet available
        // (this lets us immediately read more without waiting for an interrupt)
        fifoCount -= packetSize;
        if (fifoCount ==0)
        {
            
              // display Euler angles in degrees
              mpu.dmpGetQuaternion(&q, fifoBuffer);
              mpu.dmpGetGravity(&gravity, &q);
              mpu.dmpGetYawPitchRoll(ypr, &q, &gravity);
              InputP = (ypr[2])-PitchBalancePt+BPtDif; // Remember here Pitch reading is in Radians, not Degrees
              // if we're running in ""normal"" mode, build an average reading of the car's pitch speed
              //using the next 30 reported values
             if(loopCnt4 >= 30) //Based on a sample period of 25ms, a loopCnt4 of 40 is ~1 second; note - loopCnt4 gets incremented in the Pitch PID 
              {
                RunningSpd = RunningSpd/loopCnt4;//; note - RunningSpd gets accumulated in the Pitch PID
                double oldBP = PitchBalancePt;
                InputP = InputP+PitchBalancePt-BPtDif; //remove old Balance Pt offset
                //Be aware, positive speed numbers actually causes the car to move backwards.
                // While a larger Positive Balance Point number will make the car lean further forward
                 
                 //calc the current proportional correction component of the Balance point 
                double SpdDif = RunningSpd-LastRunningSpd;
                RunningErr += RunningSpd; 
                if(AutoBalPt)
                 {
                  double BPtCor = 0.0;
                  if (Fgr8Mode) //if (abs(SpdDif)>25) //
                  {
                    BPtDif = -0.00019*SpdDif;
                    BPtCor = 1.9*(1.2*RunningSpd+0.25*RunningErr)/20000;
                  
                  }
                  else
                  {
                    BPtDif = -0.00004*SpdDif;// last used
                    BPtCor = (1.2*RunningSpd+0.25*RunningErr)/40000;;// last used
                  }
                 //Now calculate the new diferential component in the Balance point correction factor
                  LastRunningSpd = RunningSpd;
                // if true, user selected, run in Autobal Pt mode
                  PitchBalancePt += (BPtCor- (0.5*BPtDif));
                  PitchBalancePt = (PitchBalancePt+oldBP)/2.0;
                   //lcd.cursorTo(1, 0);
                   //lcd.printIn(msgs[2]);
                 }      
                 if(!SkipUpdate)
                   {
                     ShowMessage(""SPD"" ,(int) (RunningSpd), 0, 0); //(Line 0, Pos =0)
                     ShowMessage(""Err"" ,(int) (RunningErr), 0, 8); //(Line 0, Pos =0)
                     //ShowMessage(""TPD"" ,(int) (TotPtchDif*10), 0, 8);
                     //ShowMessage(""ITm"" ,(int) ITerm, 0, 8);
                     //ShowMessage(""Her"" ,(int) (100*HomErr * 180/M_PI), 0, 8);
                     //ShowMessage(""Dif"" ,(int) SpdDif, 0, 8);
                     //ShowMessage(""Dif"" ,(int) (RunningErr-LastRunningErr), 0, 8);
                     ShowMessage(""Bpt"" ,(int) (100*PitchBalancePt * 180/M_PI), 1, 0); // Ist charater pos; 2nd row
                     SkipUpdate = true;
                   }
                InputP = InputP-PitchBalancePt+BPtDif; // now add the new improved Bal Pt back in
                RunningSpd = 0.0;
                loopCnt4 = 0;
                
              }

              InputY= (ypr[0] * 180/M_PI); // convert Yaw Radian value to Degrees
              //Serial.println(ypr[2] * 180/M_PI);
              if (abs((int) InputP* 180/M_PI) < 1)// If BalanceBot is within 1 degree of vertical, then recallibrate Yaw offset
               { 
                 loopCnt1 += 1;
                 if (loopCnt1 == 900)// its vertical long enough re-zero the yaw heading 
                 {
                   loopCnt1 = 0;
                   if(!Gud2Go)
                    {
                     // lock in initial [current] heading 
                     YawBalancePt = InputY; 
                     //Reset any residual integral PID values 
                     ITerm = 0.0;
                     ITermS = 0.0;
                     BPtDif = 0.0;
                     LastRunningSpd = 0.0;
                    } 
                   Gud2Go = true;
                 }
               }
              else
               {
                 loopCnt1 = 0; 
               }
               unsigned long CurTm = millis();
               int DeltaT = (CurTm - LastShw);
               if(DeltaT>=250)
               {
               loopCnt2 -=1;
               if (loopCnt2==0) // if true; One second has elapsed since the last diaplay update
                 {
                   loopCnt2 +=4;
                   if (Fgr8Mode && (abs((int)RunningErr)<30 || !AutoBalPt)) // <20
                    {
                     YawBalancePt = YawBalancePt - DeltaStPt;
                     if(YawBalancePt <= -180.0 || YawBalancePt > +180.0)
                      {
                       DeltaStPt = - DeltaStPt; 
                       YawBalancePt = YawBalancePt - DeltaStPt;
                      }
                    }
                   ShowMessage(""Yaw"" ,(int) (InputY), 1, 8); 
                   if(!SkipUpdate)
                    { 
                    ShowMessage(""P"" ,(int) (InputP* 180/M_PI), 1, 0);
                    }
                    
                   else SkipUpdate = false;
                   // now, if Speed Signal is small, then its probably safe to take the time to Update the Yaw Display reading 
                   Rpt_IR = true; //reset IR Flag to enable new report
                 }
                LastShw = CurTm;
               }
              Speed = CalcPtchPID(InputP);//ComputePID(InputP-HomErr);// Calculate new PID Balancing value
              // the Yaw Output ranges from -180 deg to +180 deg.
              // Test for yaw corrections trying to negotiating this +/- crossing point, &
              // as needed, temporarily extend  the yaw range to bridge the gap
              if (InputY-YawBalancePt < -180.0) InputY = InputY + 360.0;
              if (InputY-YawBalancePt > +180.0) InputY = InputY - 360.0;        
              Steer = ComputePIDS(InputY-YawBalancePt);
              //ShowMessage(""STR"" ,(int) (Steer), 0, 8);
              
//              Serial.print(""Pitch\\t"");
//              Serial.print(InputY* 180/M_PI); 
              SpeedL= AplyOffSet(Speed - Steer, SpeedL);
              SpeedR= AplyOffSet(Speed + Steer, SpeedR);
              //ShowMessage(""Lft"" ,(int) (SpeedL), 0, 8);
//              Serial.print(""\\tSpeedL\\t"");
//              Serial.println(SpeedL);
              if (Gud2Go)
               {
                SetMotorSpeed(RIGHTWHEEL, SpeedR);
                SetMotorSpeed(LEFTWHEEL, SpeedL);
               }
  
              SampleTime =IdealSmplTm;
              SampleTimeY = (unsigned long)SampleTime;
              SampleTimeP = (unsigned long)SampleTime; 
              SetTunings(Kp, Ki, Kd);
              SetTuningsS(KpS, KiS, KdS);
          // blink LED to indicate activity
          blinkState = !blinkState;
          //digitalWrite(LED_PIN, blinkState);
        }
        else
        {
          mpu.resetFIFO();
        }
    }
 
}

//###########################################################################
void ConfigRunMode()
{
  lcd.clear();
  lcd.print(""SELECT RUN MODE"");
  // Wait 4 seconds before starting Main Loop
  bool ShwBpMode = true; 
  do
    {
     if (ShwBpMode)
     {
       ShwBpMode = !ShwBpMode;
       lcd.setCursor(0,1);
        if (AutoBalPt)
         {
           lcd.print(msgs[7]);
         }
        else
         {
           lcd.print(msgs[8]);
         }
         delay(300);
     }
      buttonPressed=waitButton();
      if(buttonPressed==KEYPAD_SELECT)
      {
        AutoBalPt =!AutoBalPt;
        ShwBpMode = true;
      }  
    }
   while(!(buttonPressed==KEYPAD_UP || buttonPressed==KEYPAD_DOWN || buttonPressed==KEYPAD_LEFT || buttonPressed==KEYPAD_RIGHT)); 
  if (buttonPressed==KEYPAD_UP || buttonPressed==KEYPAD_DOWN)
   {
     Fgr8Mode = false;
   }
  else
   {
     Fgr8Mode = true;
   }
  lcd.clear();
  lcd.setCursor(0,1);
  if (Fgr8Mode)
  {
   lcd.print(msgs[4]);
  }
  else
  {
   lcd.print(msgs[5]);
  } 
  char buf [16];
  int downCnt = 4;
  do
  {
  sprintf (buf, ""ROBY STARTS IN %i"",downCnt);
  lcd.setCursor(0,0); 
  lcd.print(buf); 
  delay(1000);
  downCnt = downCnt-1;
  }
  while (downCnt>0);
}
// &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&
double SqrVal(double x)
{
  double sign = 1.0; 
  if(x<1) sign = -1.0;
  if (x!=0) x = x/20.0;
  x = sign*x*x;
  return x;
}
// &&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&

//###########################################################################
// Begin PID computations
int CalcPtchPID(float Input)
{
   unsigned long now = millis();
   int timeChange = (now - lastTime);
   if(timeChange>=SampleTimeP)
   {
      SetSampleTime(timeChange);
      /*Compute all the working error variables*/
      if (BackAway)
       {
        if (Rpt_IR)
       { 
        lcd.setCursor(0,0); //(pos,line)
        lcd.print(msgs[1]);
        Rpt_IR = !Rpt_IR;
       } 
        Input = Input+ BackAngle;
        BackAngle += 0.1*BackAngleRef;
        if (BackAngle>0.08) BackAngle = 0.04; //limit reversing anlge to a Max of 2.5deg (note 0.08 Radians = ~5 deg
       }
      else BackAngle = BackAngleRef;
      Input = 1530.0*sin(Input);// 255.0*6*sin(Input);
      double error = Setpoint - Input;
      double dInput = (Input - lastInput);
      /*
      Angle: 0.1 Error: 2.6703523998244125
      Angle: 0.2 Error: 5.3406966652923105
      Angle: 0.3 Error: 8.011024662071957
      Angle: 0.4 Error: 10.681328255881175
      Angle: 0.5 Error: 13.35159931251212
      Angle: 0.6 Error: 16.021829697856063
      Angle: 0.7 Error: 18.692011277928167
      Angle: 0.8 Error: 21.362135918892267
      Angle: 0.9 Error: 24.032195487085634
      Angle: 1.0 Error: 26.70218184904377
      Angle: 1.1 Error: 29.372086871525195
      Angle: 1.2 Error: 32.04190242153614
      Angle: 1.3 Error: 34.711620366355476
      Angle: 1.4 Error: 37.38123257355932
      Angle: 1.5 Error: 40.050730911045925
      Angle: 1.6 Error: 42.72010724706039
      Angle: 1.7 Error: 45.38935345021946
      Angle: 1.8 Error: 48.05846138953628
      Angle: 1.9 Error: 50.7274229344452
      Angle: 2.0 Error: 53.39622995482648
      */
      
      
     double offset = 0.0; 
     if(abs((int) error)>16)
      {
        // Square the error term
        double sign = 1.0;
        offset = OS;
        if(error<1)
        {
          sign = -1.0;
          offset = -OS;
        }
        if (error!=0) error = error/BrkPt;
        error = sign*BrkPt*error*error;
      }
     else
      {
        kp= kp*2.977;
      }
     error= error+offset;
     double DtI = ki*error;
     double Cap = 10.0;
     if (DtI >Cap) DtI = Cap;
     else if (DtI <-Cap) DtI = -Cap;
     ITerm+= DtI;


      /*Compute PID PIDOut*/
      PIDOut = kp*error + ITerm - kd * dInput;
//      Serial.print(""ITerm "");
//      Serial.println(ITerm);
//      Serial.print(""\\tPIDOut "");
//      Serial.println(PIDOut);
      SetPIDOutLimits(-Max, Max);
      if(Gud2Go && !BackAway)
      {
        RunningSpd += PIDOut;
        loopCnt4 += 1;
      }
       /*Remember some variables for next time*/
      lastInput = Input;
      lastTime = now;
   }
   return (int) PIDOut;
   
}   
 
void SetTunings(double Kp, double Ki, double Kd)
{
  double SampleTimeInSec = ((double)SampleTime)/1000;
   kp = Kp;
   ki = Ki * SampleTimeInSec;
   kd = Kd / SampleTimeInSec;
}
 
void SetSampleTime(int NewSampleTime)
{
   if (NewSampleTime > 0)
   {
      double ratio  = (double)NewSampleTime
                      / (double)SampleTime;
      ki *= ratio;
      kd /= ratio;
      SampleTimeP = (unsigned long)NewSampleTime;
   }
}

void SetPIDOutLimits(double Min, double Max)
{
   if(Min > Max) return;

   if (PIDOut > Max)
    {
      ITerm -= PIDOut - Max;
      PIDOut = Max;
    }
   else if (PIDOut < Min)
    {
      ITerm  -=(PIDOut - Min);
      PIDOut = Min;
    }
}
 

// End PID computations
//#######################################################################

// Begin PID Steering computations
int ComputePIDS(float Input)
{
   unsigned long now = millis();
   int timeChange = (now - lastTimeS);
   if(timeChange>=SampleTimeY)
   {
      SetSampleTimeS(timeChange);
      /*Compute all the working error variables*/
      double error = Setpoint - Input;
      double dInput = (Input - lastInputS);
      double outMax = 255;
      double outMin = -255;
      ITermS+= (kiS * error);
      if(ITermS> outMax) ITermS= outMax;
      else if(ITermS< outMin) ITermS= outMin;
      
 
      /*Compute PID PIDOut*/
      PIDOutS = kpS * error + ITermS - kdS * dInput;
      if(PIDOutS > outMax)
      {
        PIDOutS = outMax;
      }
      else if(PIDOutS < outMin)
      {
        PIDOutS = outMin;
      }
       /*Remember some variables for next time*/
      lastInputS = Input;
      lastTimeS = now;
//      Serial.print(""PIDOutS\\t"");
//      Serial.print(PIDOutS);
   }
   
//   Serial.print(""\\tYAW"");
//   Serial.println(Input);
   return (int) PIDOutS;
   
}   
 
void SetTuningsS(double Kp, double Ki, double Kd)
{
  double SampleTimeInSec = ((double)SampleTime)/1000;
   kpS = Kp;
   kiS = Ki * SampleTimeInSec;
   kdS = Kd / SampleTimeInSec;
}
 
void SetSampleTimeS(int NewSampleTime)
{
   if (NewSampleTime > 0)
   {
      double ratio  = (double)NewSampleTime
                      / (double)SampleTime;
      kiS *= ratio;
      kdS /= ratio;
      SampleTimeY = (unsigned long)NewSampleTime;
   }
}
 


// End PID Steer computations
//#######################################################################

int AplyOffSet( int SpdSgnl, int LastSpeed)
{
 if (SpdSgnl <= LastSpeed && SpdSgnl >0) 
   {
    return SpdSgnl;
   } 
 else if (SpdSgnl >= LastSpeed && SpdSgnl <0) 
   {
    return SpdSgnl;
   }
 else if (SpdSgnl ==0)
   {
    return SpdSgnl;
   }  
   
 if (SpdSgnl <0)
   {
    SpdSgnl = -DeadBnd + SpdSgnl;
   }
 else SpdSgnl = +DeadBnd + SpdSgnl;
 
 if(SpdSgnl > Max) SpdSgnl = Max;
   else if(SpdSgnl < -Max) SpdSgnl = -Max;
 return SpdSgnl;   
}
//#######################################################################
// normally called by the SetMotorSpeed routine [see below] 
void SetMotorDir(int Motor , boolean Dir)
{
  int InPin;
  int InPin_;
  if( Motor == LEFTWHEEL)
   {
    InPin = In1;
    InPin_ = In2;
   }
  else
   {
    InPin = In3;
    InPin_ = In4;
   } 
  if( Dir) // if true set up forward; Note as the car is currently wired the forward command actually makes the car move backwards 
   {
    digitalWrite(InPin, HIGH);
    digitalWrite(InPin_, LOW);

   }
  else
   {
    digitalWrite(InPin, LOW);
    digitalWrite(InPin_, HIGH);
   }
}

void SetMotorSpeed(int Motor,int Speed)
{
  int PWMpin;
  boolean Dir;
  if (Speed > 0)
   {
     Dir = FORWARD;
   }
  else
   {
     Dir = REVERSE;
     Speed = - Speed;
   }
  SetMotorDir(Motor , Dir); 
  if (Motor == LEFTWHEEL)
  {
   PWMpin = EnA;
  }
  else
  {
   PWMpin = EnB;
  }
  analogWrite(PWMpin, Speed);
//  Serial.print(PWMpin);
//  Serial.print(""\\t"");
//  Serial.print(Speed);
//  Serial.print(""\\t"");
//  Serial.println(Steer);
}  

//########################################################################
void ShowMessage(char* text, int value, int line, int pos)
{
  char buf [16];
  sprintf (buf, ""%s %03i "", text, value); // Concatenate text message with interger speed value 
  lcd.setCursor(pos,line);
  lcd.print(buf); 
} 
//########################################################################
int waitButton()
{
  int buttonPressed; 
  waitReleaseButton;
  Keypad.blink();
  while((buttonPressed=Keypad.button())==KEYPAD_NONE)
  {
  }
  delay(50);  
  Keypad.noBlink();
  return buttonPressed;
}

void waitReleaseButton()
{
  delay(50);
  while(Keypad.button()!=KEYPAD_NONE)
  {
  }
  delay(50);
}

",8291,False,1406.129870822971,median
"// Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2012 The Mithril 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));

        // Mithril 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;
}
",16160,False,2392.2714330398558,median
"/*
  Firmata is a generic protocol for communicating with microcontrollers
  from software on a host computer. It is intended to work with
  any host computer software package.

  To download a host software package, please clink on the following link
  to open the list of Firmata client libraries your default browser.

  https://github.com/firmata/arduino#firmata-client-libraries

  Copyright (C) 2006-2008 Hans-Christoph Steiner.  All rights reserved.
  Copyright (C) 2010-2011 Paul Stoffregen.  All rights reserved.
  Copyright (C) 2009 Shigeru Kobayashi.  All rights reserved.
  Copyright (C) 2009-2015 Jeff Hoefs.  All rights reserved.

  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.

  See file LICENSE.txt for further informations on licensing terms.

  Last updated by Jeff Hoefs: November 7th, 2015
*/

/*
  README

  To use StandardFirmataEthernet you will need to have one of the following
  boards or shields:

  - Arduino Ethernet shield (or clone)
  - Arduino Ethernet board (or clone)
  - Arduino Yun

  Follow the instructions in the NETWORK CONFIGURATION section below to
  configure your particular hardware.

  NOTE: If you are using an Arduino Ethernet shield you cannot use the following pins on
  the following boards. Firmata will ignore any requests to use these pins:

  - Arduino Uno or other ATMega328 boards: (D4, D10, D11, D12, D13)
  - Arduino Mega: (D4, D10, D50, D51, D52, D53)
  - Arduino Leonardo: (D4, D10)
  - Arduino Due: (D4, D10)

  If you are using an ArduinoEthernet board, the following pins cannot be used (same as Uno):
  - D4, D10, D11, D12, D13
*/

#include <Servo.h>
#include <Wire.h>
#include <Firmata.h>

//#define SERIAL_DEBUG
#include ""utility/firmataDebug.h""

#define I2C_WRITE                   B00000000
#define I2C_READ                    B00001000
#define I2C_READ_CONTINUOUSLY       B00010000
#define I2C_STOP_READING            B00011000
#define I2C_READ_WRITE_MODE_MASK    B00011000
#define I2C_10BIT_ADDRESS_MODE_MASK B00100000
#define I2C_MAX_QUERIES             8
#define I2C_REGISTER_NOT_SPECIFIED  -1

// the minimum interval for sampling analog input
#define MINIMUM_SAMPLING_INTERVAL   1


/*==============================================================================
 * NETWORK CONFIGURATION
 *
 * You must configure your particular hardware. Follow the steps below.
 *============================================================================*/

// STEP 1 [REQUIRED]
// Uncomment / comment the appropriate set of includes for your hardware (OPTION A or B)
// Option A is enabled by default.

/*
 * OPTION A: Configure for Arduino Ethernet board or shield
 *
 * To configure StandardFirmataEthernet to use the original WIZ5100-based
 * ethernet shield or Arduino Ethernet uncomment the includes of 'SPI.h' and 'Ethernet.h':
 */

#include <SPI.h>
#include <Ethernet.h>

/*
 * OPTION B: Configure for Arduin Yun
 *
 * To execute StandardFirmataEthernet on Yun uncomment Bridge.h and YunClient.h.
 * Do not include Ethernet.h or SPI.h above in this case.
 * On Yun there's no need to configure local_ip and mac in the sketch
 * as this is configured on the linux-side of Yun.
 */

// #include <Bridge.h>
// #include <YunClient.h>


// STEP 2 [REQUIRED for all boards and shields]
// replace with IP of the server you want to connect to, comment out if using 'remote_host'
#define remote_ip IPAddress(10, 0, 0, 3)
// *** REMOTE HOST IS NOT YET WORKING ***
// replace with hostname of server you want to connect to, comment out if using 'remote_ip'
// #define remote_host ""server.local""

// STEP 3 [REQUIRED unless using Arduin Yun]
// Replace with the port that your server is listening on
#define remote_port 3030

// STEP 4 [REQUIRED unless using Arduino Yun OR if not using DHCP]
// Replace with your board or ethernet shield's IP address
// Comment out if you want to use DHCP
#define local_ip IPAddress(10, 0, 0, 15)

// STEP 5 [REQUIRED unless using Arduino Yun]
// replace with ethernet shield mac. Must be unique for your network
const byte mac[] = {0x90, 0xA2, 0xDA, 0x00, 0x53, 0xE5};

// Since Arduino 1.6.6 ethernet_h is not recognized, even when Ethernet.h is included so this
// always throws the error. Commenting out until the issue introduced in Arduino 1.6.6 is resolved.
// #if !defined ethernet_h && !defined _YUN_CLIENT_H_
// #error ""you must uncomment the includes for your board configuration. See OPTIONS A and B in the NETWORK CONFIGURATION SECTION""
// #endif

#if defined remote_ip && defined remote_host
#error ""cannot define both remote_ip and remote_host at the same time!""
#endif


/*==============================================================================
 * GLOBAL VARIABLES
 *============================================================================*/

/* network */

#include ""utility/EthernetClientStream.h""

#ifdef _YUN_CLIENT_H_
YunClient client;
#else
EthernetClient client;
#endif

#if defined remote_ip && !defined remote_host
#ifdef local_ip
EthernetClientStream stream(client, local_ip, remote_ip, NULL, remote_port);
#else
EthernetClientStream stream(client, IPAddress(0, 0, 0, 0), remote_ip, NULL, remote_port);
#endif
#endif

#if !defined remote_ip && defined remote_host
#ifdef local_ip
EthernetClientStream stream(client, local_ip, IPAddress(0, 0, 0, 0), remote_host, remote_port);
#else
EthernetClientStream stream(client, IPAddress(0, 0, 0, 0), IPAddress(0, 0, 0, 0), remote_host, remote_port);
#endif
#endif

/* analog inputs */
int analogInputsToReport = 0;      // bitwise array to store pin reporting

/* digital input ports */
byte reportPINs[TOTAL_PORTS];       // 1 = report this port, 0 = silence
byte previousPINs[TOTAL_PORTS];     // previous 8 bits sent

/* pins configuration */
byte pinConfig[TOTAL_PINS];         // configuration of every pin
byte portConfigInputs[TOTAL_PORTS]; // each bit: 1 = pin in INPUT, 0 = anything else
int pinState[TOTAL_PINS];           // any value that has been written

/* timer variables */
unsigned long currentMillis;        // store the current value from millis()
unsigned long previousMillis;       // for comparison with currentMillis
unsigned int samplingInterval = 19; // how often to sample analog inputs (in ms)

/* i2c data */
struct i2c_device_info {
  byte addr;
  int reg;
  byte bytes;
};

/* for i2c read continuous mode */
i2c_device_info query[I2C_MAX_QUERIES];

byte i2cRxData[32];
boolean isI2CEnabled = false;
signed char queryIndex = -1;
// default delay time between i2c read request and Wire.requestFrom()
unsigned int i2cReadDelayTime = 0;

Servo servos[MAX_SERVOS];
byte servoPinMap[TOTAL_PINS];
byte detachedServos[MAX_SERVOS];
byte detachedServoCount = 0;
byte servoCount = 0;

boolean isResetting = false;

/* utility functions */
void wireWrite(byte data)
{
#if ARDUINO >= 100
  Wire.write((byte)data);
#else
  Wire.send(data);
#endif
}

byte wireRead(void)
{
#if ARDUINO >= 100
  return Wire.read();
#else
  return Wire.receive();
#endif
}

/*==============================================================================
 * FUNCTIONS
 *============================================================================*/

void attachServo(byte pin, int minPulse, int maxPulse)
{
  if (servoCount < MAX_SERVOS) {
    // reuse indexes of detached servos until all have been reallocated
    if (detachedServoCount > 0) {
      servoPinMap[pin] = detachedServos[detachedServoCount - 1];
      if (detachedServoCount > 0) detachedServoCount--;
    } else {
      servoPinMap[pin] = servoCount;
      servoCount++;
    }
    if (minPulse > 0 && maxPulse > 0) {
      servos[servoPinMap[pin]].attach(PIN_TO_DIGITAL(pin), minPulse, maxPulse);
    } else {
      servos[servoPinMap[pin]].attach(PIN_TO_DIGITAL(pin));
    }
  } else {
    Firmata.sendString(""Max servos attached"");
  }
}

void detachServo(byte pin)
{
  servos[servoPinMap[pin]].detach();
  // if we're detaching the last servo, decrement the count
  // otherwise store the index of the detached servo
  if (servoPinMap[pin] == servoCount && servoCount > 0) {
    servoCount--;
  } else if (servoCount > 0) {
    // keep track of detached servos because we want to reuse their indexes
    // before incrementing the count of attached servos
    detachedServoCount++;
    detachedServos[detachedServoCount - 1] = servoPinMap[pin];
  }

  servoPinMap[pin] = 255;
}

void readAndReportData(byte address, int theRegister, byte numBytes) {
  // allow I2C requests that don't require a register read
  // for example, some devices using an interrupt pin to signify new data available
  // do not always require the register read so upon interrupt you call Wire.requestFrom()
  if (theRegister != I2C_REGISTER_NOT_SPECIFIED) {
    Wire.beginTransmission(address);
    wireWrite((byte)theRegister);
    Wire.endTransmission();
    // do not set a value of 0
    if (i2cReadDelayTime > 0) {
      // delay is necessary for some devices such as WiiNunchuck
      delayMicroseconds(i2cReadDelayTime);
    }
  } else {
    theRegister = 0;  // fill the register with a dummy value
  }

  Wire.requestFrom(address, numBytes);  // all bytes are returned in requestFrom

  // check to be sure correct number of bytes were returned by slave
  if (numBytes < Wire.available()) {
    Firmata.sendString(""I2C: Too many bytes received"");
  } else if (numBytes > Wire.available()) {
    Firmata.sendString(""I2C: Too few bytes received"");
  }

  i2cRxData[0] = address;
  i2cRxData[1] = theRegister;

  for (int i = 0; i < numBytes && Wire.available(); i++) {
    i2cRxData[2 + i] = wireRead();
  }

  // send slave address, register and received bytes
  Firmata.sendSysex(SYSEX_I2C_REPLY, numBytes + 2, i2cRxData);
}

void outputPort(byte portNumber, byte portValue, byte forceSend)
{
  // pins not configured as INPUT are cleared to zeros
  portValue = portValue & portConfigInputs[portNumber];
  // only send if the value is different than previously sent
  if (forceSend || previousPINs[portNumber] != portValue) {
    Firmata.sendDigitalPort(portNumber, portValue);
    previousPINs[portNumber] = portValue;
  }
}

/* -----------------------------------------------------------------------------
 * check all the active digital inputs for change of state, then add any events
 * to the Stream output queue using Stream.write() */
void checkDigitalInputs(void)
{
  /* Using non-looping code allows constants to be given to readPort().
   * The compiler will apply substantial optimizations if the inputs
   * to readPort() are compile-time constants. */
  if (TOTAL_PORTS > 0 && reportPINs[0]) outputPort(0, readPort(0, portConfigInputs[0]), false);
  if (TOTAL_PORTS > 1 && reportPINs[1]) outputPort(1, readPort(1, portConfigInputs[1]), false);
  if (TOTAL_PORTS > 2 && reportPINs[2]) outputPort(2, readPort(2, portConfigInputs[2]), false);
  if (TOTAL_PORTS > 3 && reportPINs[3]) outputPort(3, readPort(3, portConfigInputs[3]), false);
  if (TOTAL_PORTS > 4 && reportPINs[4]) outputPort(4, readPort(4, portConfigInputs[4]), false);
  if (TOTAL_PORTS > 5 && reportPINs[5]) outputPort(5, readPort(5, portConfigInputs[5]), false);
  if (TOTAL_PORTS > 6 && reportPINs[6]) outputPort(6, readPort(6, portConfigInputs[6]), false);
  if (TOTAL_PORTS > 7 && reportPINs[7]) outputPort(7, readPort(7, portConfigInputs[7]), false);
  if (TOTAL_PORTS > 8 && reportPINs[8]) outputPort(8, readPort(8, portConfigInputs[8]), false);
  if (TOTAL_PORTS > 9 && reportPINs[9]) outputPort(9, readPort(9, portConfigInputs[9]), false);
  if (TOTAL_PORTS > 10 && reportPINs[10]) outputPort(10, readPort(10, portConfigInputs[10]), false);
  if (TOTAL_PORTS > 11 && reportPINs[11]) outputPort(11, readPort(11, portConfigInputs[11]), false);
  if (TOTAL_PORTS > 12 && reportPINs[12]) outputPort(12, readPort(12, portConfigInputs[12]), false);
  if (TOTAL_PORTS > 13 && reportPINs[13]) outputPort(13, readPort(13, portConfigInputs[13]), false);
  if (TOTAL_PORTS > 14 && reportPINs[14]) outputPort(14, readPort(14, portConfigInputs[14]), false);
  if (TOTAL_PORTS > 15 && reportPINs[15]) outputPort(15, readPort(15, portConfigInputs[15]), false);
}

// -----------------------------------------------------------------------------
/* sets the pin mode to the correct state and sets the relevant bits in the
 * two bit-arrays that track Digital I/O and PWM status
 */
void setPinModeCallback(byte pin, int mode)
{
  if (pinConfig[pin] == PIN_MODE_IGNORE)
    return;

  if (pinConfig[pin] == PIN_MODE_I2C && isI2CEnabled && mode != PIN_MODE_I2C) {
    // disable i2c so pins can be used for other functions
    // the following if statements should reconfigure the pins properly
    disableI2CPins();
  }
  if (IS_PIN_DIGITAL(pin) && mode != PIN_MODE_SERVO) {
    if (servoPinMap[pin] < MAX_SERVOS && servos[servoPinMap[pin]].attached()) {
      detachServo(pin);
    }
  }
  if (IS_PIN_ANALOG(pin)) {
    reportAnalogCallback(PIN_TO_ANALOG(pin), mode == PIN_MODE_ANALOG ? 1 : 0); // turn on/off reporting
  }
  if (IS_PIN_DIGITAL(pin)) {
    if (mode == INPUT || mode == PIN_MODE_PULLUP) {
      portConfigInputs[pin / 8] |= (1 << (pin & 7));
    } else {
      portConfigInputs[pin / 8] &= ~(1 << (pin & 7));
    }
  }
  pinState[pin] = 0;
  switch (mode) {
    case PIN_MODE_ANALOG:
      if (IS_PIN_ANALOG(pin)) {
        if (IS_PIN_DIGITAL(pin)) {
          pinMode(PIN_TO_DIGITAL(pin), INPUT);    // disable output driver
#if ARDUINO <= 100
          // deprecated since Arduino 1.0.1 - TODO: drop support in Firmata 2.6
          digitalWrite(PIN_TO_DIGITAL(pin), LOW); // disable internal pull-ups
#endif
        }
        pinConfig[pin] = PIN_MODE_ANALOG;
      }
      break;
    case INPUT:
      if (IS_PIN_DIGITAL(pin)) {
        pinMode(PIN_TO_DIGITAL(pin), INPUT);    // disable output driver
#if ARDUINO <= 100
        // deprecated since Arduino 1.0.1 - TODO: drop support in Firmata 2.6
        digitalWrite(PIN_TO_DIGITAL(pin), LOW); // disable internal pull-ups
#endif
        pinConfig[pin] = INPUT;
      }
      break;
    case PIN_MODE_PULLUP:
      if (IS_PIN_DIGITAL(pin)) {
        pinMode(PIN_TO_DIGITAL(pin), INPUT_PULLUP);
        pinConfig[pin] = PIN_MODE_PULLUP;
        pinState[pin] = 1;
      }
      break;
    case OUTPUT:
      if (IS_PIN_DIGITAL(pin)) {
        digitalWrite(PIN_TO_DIGITAL(pin), LOW); // disable PWM
        pinMode(PIN_TO_DIGITAL(pin), OUTPUT);
        pinConfig[pin] = OUTPUT;
      }
      break;
    case PIN_MODE_PWM:
      if (IS_PIN_PWM(pin)) {
        pinMode(PIN_TO_PWM(pin), OUTPUT);
        analogWrite(PIN_TO_PWM(pin), 0);
        pinConfig[pin] = PIN_MODE_PWM;
      }
      break;
    case PIN_MODE_SERVO:
      if (IS_PIN_DIGITAL(pin)) {
        pinConfig[pin] = PIN_MODE_SERVO;
        if (servoPinMap[pin] == 255 || !servos[servoPinMap[pin]].attached()) {
          // pass -1 for min and max pulse values to use default values set
          // by Servo library
          attachServo(pin, -1, -1);
        }
      }
      break;
    case PIN_MODE_I2C:
      if (IS_PIN_I2C(pin)) {
        // mark the pin as i2c
        // the user must call I2C_CONFIG to enable I2C for a device
        pinConfig[pin] = PIN_MODE_I2C;
      }
      break;
    default:
      Firmata.sendString(""Unknown pin mode""); // TODO: put error msgs in EEPROM
  }
  // TODO: save status to EEPROM here, if changed
}

/*
 * Sets the value of an individual pin. Useful if you want to set a pin value but
 * are not tracking the digital port state.
 * Can only be used on pins configured as OUTPUT.
 * Cannot be used to enable pull-ups on Digital INPUT pins.
 */
void setPinValueCallback(byte pin, int value)
{
  if (pin < TOTAL_PINS && IS_PIN_DIGITAL(pin)) {
    if (pinConfig[pin] == OUTPUT) {
      pinState[pin] = value;
      digitalWrite(PIN_TO_DIGITAL(pin), value);
    }
  }
}

void analogWriteCallback(byte pin, int value)
{
  if (pin < TOTAL_PINS) {
    switch (pinConfig[pin]) {
      case PIN_MODE_SERVO:
        if (IS_PIN_DIGITAL(pin))
          servos[servoPinMap[pin]].write(value);
        pinState[pin] = value;
        break;
      case PIN_MODE_PWM:
        if (IS_PIN_PWM(pin))
          analogWrite(PIN_TO_PWM(pin), value);
        pinState[pin] = value;
        break;
    }
  }
}

void digitalWriteCallback(byte port, int value)
{
  byte pin, lastPin, pinValue, mask = 1, pinWriteMask = 0;

  if (port < TOTAL_PORTS) {
    // create a mask of the pins on this port that are writable.
    lastPin = port * 8 + 8;
    if (lastPin > TOTAL_PINS) lastPin = TOTAL_PINS;
    for (pin = port * 8; pin < lastPin; pin++) {
      // do not disturb non-digital pins (eg, Rx & Tx)
      if (IS_PIN_DIGITAL(pin)) {
        // do not touch pins in PWM, ANALOG, SERVO or other modes
        if (pinConfig[pin] == OUTPUT || pinConfig[pin] == INPUT) {
          pinValue = ((byte)value & mask) ? 1 : 0;
          if (pinConfig[pin] == OUTPUT) {
            pinWriteMask |= mask;
          } else if (pinConfig[pin] == INPUT && pinValue == 1 && pinState[pin] != 1) {
            // only handle INPUT here for backwards compatibility
#if ARDUINO > 100
            pinMode(pin, INPUT_PULLUP);
#else
            // only write to the INPUT pin to enable pullups if Arduino v1.0.0 or earlier
            pinWriteMask |= mask;
#endif
          }
          pinState[pin] = pinValue;
        }
      }
      mask = mask << 1;
    }
    writePort(port, (byte)value, pinWriteMask);
  }
}


// -----------------------------------------------------------------------------
/* sets bits in a bit array (int) to toggle the reporting of the analogIns
 */
//void FirmataClass::setAnalogPinReporting(byte pin, byte state) {
//}
void reportAnalogCallback(byte analogPin, int value)
{
  if (analogPin < TOTAL_ANALOG_PINS) {
    if (value == 0) {
      analogInputsToReport = analogInputsToReport & ~ (1 << analogPin);
    } else {
      analogInputsToReport = analogInputsToReport | (1 << analogPin);
      // prevent during system reset or all analog pin values will be reported
      // which may report noise for unconnected analog pins
      if (!isResetting) {
        // Send pin value immediately. This is helpful when connected via
        // ethernet, wi-fi or bluetooth so pin states can be known upon
        // reconnecting.
        Firmata.sendAnalog(analogPin, analogRead(analogPin));
      }
    }
  }
  // TODO: save status to EEPROM here, if changed
}

void reportDigitalCallback(byte port, int value)
{
  if (port < TOTAL_PORTS) {
    reportPINs[port] = (byte)value;
    // Send port value immediately. This is helpful when connected via
    // ethernet, wi-fi or bluetooth so pin states can be known upon
    // reconnecting.
    if (value) outputPort(port, readPort(port, portConfigInputs[port]), true);
  }
  // do not disable analog reporting on these 8 pins, to allow some
  // pins used for digital, others analog.  Instead, allow both types
  // of reporting to be enabled, but check if the pin is configured
  // as analog when sampling the analog inputs.  Likewise, while
  // scanning digital pins, portConfigInputs will mask off values from any
  // pins configured as analog
}

/*==============================================================================
 * SYSEX-BASED commands
 *============================================================================*/

void sysexCallback(byte command, byte argc, byte *argv)
{
  byte mode;
  byte slaveAddress;
  byte data;
  int slaveRegister;
  unsigned int delayTime;

  switch (command) {
    case I2C_REQUEST:
      mode = argv[1] & I2C_READ_WRITE_MODE_MASK;
      if (argv[1] & I2C_10BIT_ADDRESS_MODE_MASK) {
        Firmata.sendString(""10-bit addressing not supported"");
        return;
      }
      else {
        slaveAddress = argv[0];
      }

      switch (mode) {
        case I2C_WRITE:
          Wire.beginTransmission(slaveAddress);
          for (byte i = 2; i < argc; i += 2) {
            data = argv[i] + (argv[i + 1] << 7);
            wireWrite(data);
          }
          Wire.endTransmission();
          delayMicroseconds(70);
          break;
        case I2C_READ:
          if (argc == 6) {
            // a slave register is specified
            slaveRegister = argv[2] + (argv[3] << 7);
            data = argv[4] + (argv[5] << 7);  // bytes to read
          }
          else {
            // a slave register is NOT specified
            slaveRegister = I2C_REGISTER_NOT_SPECIFIED;
            data = argv[2] + (argv[3] << 7);  // bytes to read
          }
          readAndReportData(slaveAddress, (int)slaveRegister, data);
          break;
        case I2C_READ_CONTINUOUSLY:
          if ((queryIndex + 1) >= I2C_MAX_QUERIES) {
            // too many queries, just ignore
            Firmata.sendString(""too many I2C queries"");
            break;
          }
          if (argc == 6) {
            // a slave register is specified
            slaveRegister = argv[2] + (argv[3] << 7);
            data = argv[4] + (argv[5] << 7);  // bytes to read
          }
          else {
            // a slave register is NOT specified
            slaveRegister = (int)I2C_REGISTER_NOT_SPECIFIED;
            data = argv[2] + (argv[3] << 7);  // bytes to read
          }
          queryIndex++;
          query[queryIndex].addr = slaveAddress;
          query[queryIndex].reg = slaveRegister;
          query[queryIndex].bytes = data;
          break;
        case I2C_STOP_READING:
          byte queryIndexToSkip;
          // if read continuous mode is enabled for only 1 i2c device, disable
          // read continuous reporting for that device
          if (queryIndex <= 0) {
            queryIndex = -1;
          } else {
            // if read continuous mode is enabled for multiple devices,
            // determine which device to stop reading and remove it's data from
            // the array, shifiting other array data to fill the space
            for (byte i = 0; i < queryIndex + 1; i++) {
              if (query[i].addr == slaveAddress) {
                queryIndexToSkip = i;
                break;
              }
            }

            for (byte i = queryIndexToSkip; i < queryIndex + 1; i++) {
              if (i < I2C_MAX_QUERIES) {
                query[i].addr = query[i + 1].addr;
                query[i].reg = query[i + 1].reg;
                query[i].bytes = query[i + 1].bytes;
              }
            }
            queryIndex--;
          }
          break;
        default:
          break;
      }
      break;
    case I2C_CONFIG:
      delayTime = (argv[0] + (argv[1] << 7));

      if (delayTime > 0) {
        i2cReadDelayTime = delayTime;
      }

      if (!isI2CEnabled) {
        enableI2CPins();
      }

      break;
    case SERVO_CONFIG:
      if (argc > 4) {
        // these vars are here for clarity, they'll optimized away by the compiler
        byte pin = argv[0];
        int minPulse = argv[1] + (argv[2] << 7);
        int maxPulse = argv[3] + (argv[4] << 7);

        if (IS_PIN_DIGITAL(pin)) {
          if (servoPinMap[pin] < MAX_SERVOS && servos[servoPinMap[pin]].attached()) {
            detachServo(pin);
          }
          attachServo(pin, minPulse, maxPulse);
          setPinModeCallback(pin, PIN_MODE_SERVO);
        }
      }
      break;
    case SAMPLING_INTERVAL:
      if (argc > 1) {
        samplingInterval = argv[0] + (argv[1] << 7);
        if (samplingInterval < MINIMUM_SAMPLING_INTERVAL) {
          samplingInterval = MINIMUM_SAMPLING_INTERVAL;
        }
      } else {
        //Firmata.sendString(""Not enough data"");
      }
      break;
    case EXTENDED_ANALOG:
      if (argc > 1) {
        int val = argv[1];
        if (argc > 2) val |= (argv[2] << 7);
        if (argc > 3) val |= (argv[3] << 14);
        analogWriteCallback(argv[0], val);
      }
      break;
    case CAPABILITY_QUERY:
      Firmata.write(START_SYSEX);
      Firmata.write(CAPABILITY_RESPONSE);
      for (byte pin = 0; pin < TOTAL_PINS; pin++) {
        if (IS_PIN_DIGITAL(pin)) {
          Firmata.write((byte)INPUT);
          Firmata.write(1);
          Firmata.write((byte)PIN_MODE_PULLUP);
          Firmata.write(1);
          Firmata.write((byte)OUTPUT);
          Firmata.write(1);
        }
        if (IS_PIN_ANALOG(pin)) {
          Firmata.write(PIN_MODE_ANALOG);
          Firmata.write(10); // 10 = 10-bit resolution
        }
        if (IS_PIN_PWM(pin)) {
          Firmata.write(PIN_MODE_PWM);
          Firmata.write(8); // 8 = 8-bit resolution
        }
        if (IS_PIN_DIGITAL(pin)) {
          Firmata.write(PIN_MODE_SERVO);
          Firmata.write(14);
        }
        if (IS_PIN_I2C(pin)) {
          Firmata.write(PIN_MODE_I2C);
          Firmata.write(1);  // TODO: could assign a number to map to SCL or SDA
        }
        Firmata.write(127);
      }
      Firmata.write(END_SYSEX);
      break;
    case PIN_STATE_QUERY:
      if (argc > 0) {
        byte pin = argv[0];
        Firmata.write(START_SYSEX);
        Firmata.write(PIN_STATE_RESPONSE);
        Firmata.write(pin);
        if (pin < TOTAL_PINS) {
          Firmata.write((byte)pinConfig[pin]);
          Firmata.write((byte)pinState[pin] & 0x7F);
          if (pinState[pin] & 0xFF80) Firmata.write((byte)(pinState[pin] >> 7) & 0x7F);
          if (pinState[pin] & 0xC000) Firmata.write((byte)(pinState[pin] >> 14) & 0x7F);
        }
        Firmata.write(END_SYSEX);
      }
      break;
    case ANALOG_MAPPING_QUERY:
      Firmata.write(START_SYSEX);
      Firmata.write(ANALOG_MAPPING_RESPONSE);
      for (byte pin = 0; pin < TOTAL_PINS; pin++) {
        Firmata.write(IS_PIN_ANALOG(pin) ? PIN_TO_ANALOG(pin) : 127);
      }
      Firmata.write(END_SYSEX);
      break;
  }
}

void enableI2CPins()
{
  byte i;
  // is there a faster way to do this? would probaby require importing
  // Arduino.h to get SCL and SDA pins
  for (i = 0; i < TOTAL_PINS; i++) {
    if (IS_PIN_I2C(i)) {
      // mark pins as i2c so they are ignore in non i2c data requests
      setPinModeCallback(i, PIN_MODE_I2C);
    }
  }

  isI2CEnabled = true;

  Wire.begin();
}

/* disable the i2c pins so they can be used for other functions */
void disableI2CPins() {
  isI2CEnabled = false;
  // disable read continuous mode for all devices
  queryIndex = -1;
}

/*==============================================================================
 * SETUP()
 *============================================================================*/

void systemResetCallback()
{
  isResetting = true;

  // initialize a defalt state
  // TODO: option to load config from EEPROM instead of default

  if (isI2CEnabled) {
    disableI2CPins();
  }

  for (byte i = 0; i < TOTAL_PORTS; i++) {
    reportPINs[i] = false;    // by default, reporting off
    portConfigInputs[i] = 0;  // until activated
    previousPINs[i] = 0;
  }

  for (byte i = 0; i < TOTAL_PINS; i++) {
    // pins with analog capability default to analog input
    // otherwise, pins default to digital output
    if (IS_PIN_ANALOG(i)) {
      // turns off pullup, configures everything
      setPinModeCallback(i, PIN_MODE_ANALOG);
    } else if (IS_PIN_DIGITAL(i)) {
      // sets the output to 0, configures portConfigInputs
      setPinModeCallback(i, OUTPUT);
    }

    servoPinMap[i] = 255;
  }
  // by default, do not report any analog inputs
  analogInputsToReport = 0;

  detachedServoCount = 0;
  servoCount = 0;

  /* send digital inputs to set the initial state on the host computer,
   * since once in the loop(), this firmware will only send on change */
  /*
  TODO: this can never execute, since no pins default to digital input
        but it will be needed when/if we support EEPROM stored config
  for (byte i=0; i < TOTAL_PORTS; i++) {
    outputPort(i, readPort(i, portConfigInputs[i]), true);
  }
  */
  isResetting = false;
}

void setup()
{
  DEBUG_BEGIN(9600);

#ifdef _YUN_CLIENT_H_
  Bridge.begin();
#else
#ifdef local_ip
  Ethernet.begin((uint8_t *)mac, local_ip); //start ethernet
#else
  Ethernet.begin((uint8_t *)mac);           //start ethernet using dhcp
#endif
#endif

  DEBUG_PRINTLN(""connecting..."");

  Firmata.setFirmwareVersion(FIRMATA_MAJOR_VERSION, FIRMATA_MINOR_VERSION);

  Firmata.attach(ANALOG_MESSAGE, analogWriteCallback);
  Firmata.attach(DIGITAL_MESSAGE, digitalWriteCallback);
  Firmata.attach(REPORT_ANALOG, reportAnalogCallback);
  Firmata.attach(REPORT_DIGITAL, reportDigitalCallback);
  Firmata.attach(SET_PIN_MODE, setPinModeCallback);
  Firmata.attach(SET_DIGITAL_PIN_VALUE, setPinValueCallback);
  Firmata.attach(START_SYSEX, sysexCallback);
  Firmata.attach(SYSTEM_RESET, systemResetCallback);

  // StandardFirmataEthernet communicates with Ethernet shields over SPI. Therefor all
  // SPI pins must be set to IGNORE. Otherwise Firmata would break SPI communication.
  // add Pin 10 and configure pin 53 as output if using a MEGA with an Ethernet shield.

  // ignore SPI and pin 4 that is SS for SD-Card on Ethernet-shield
  for (byte i = 0; i < TOTAL_PINS; i++) {
    if (IS_PIN_SPI(i)
        || 4 == i  // SD-Card on Ethernet-shiedl uses pin 4 for SS
        || 10 == i // Ethernet-shield uses pin 10 for SS
#if defined(__AVR_ATmega32U4__)
        || 24 == i // On Leonardo, pin 24 maps to D4 and pin 28 maps to D10
        || 28 == i
#endif
       ) {
      pinConfig[i] = PIN_MODE_IGNORE;
    }
  }

  // Arduino Ethernet, Arduino EthernetShield and Arduino Yun all have SD SS wired to D4
  pinMode(PIN_TO_DIGITAL(4), OUTPUT);    // switch off SD card bypassing Firmata
  digitalWrite(PIN_TO_DIGITAL(4), HIGH); // SS is active low;

#if defined(__AVR_ATmega1280__) || defined(__AVR_ATmega2560__)
  pinMode(PIN_TO_DIGITAL(53), OUTPUT); // configure hardware SS as output on MEGA
#endif

  // start up Network Firmata:
  Firmata.begin(stream);
  systemResetCallback();  // reset to default config
}

/*==============================================================================
 * LOOP()
 *============================================================================*/
void loop()
{
  byte pin, analogPin;

  /* DIGITALREAD - as fast as possible, check for changes and output them to the
   * Stream buffer using Stream.write()  */
  checkDigitalInputs();

  /* STREAMREAD - processing incoming messagse as soon as possible, while still
   * checking digital inputs.  */
  while (Firmata.available())
    Firmata.processInput();

  // TODO - ensure that Stream buffer doesn't go over 60 bytes

  currentMillis = millis();
  if (currentMillis - previousMillis > samplingInterval) {
    previousMillis += samplingInterval;
    /* ANALOGREAD - do all analogReads() at the configured sampling interval */
    for (pin = 0; pin < TOTAL_PINS; pin++) {
      if (IS_PIN_ANALOG(pin) && pinConfig[pin] == PIN_MODE_ANALOG) {
        analogPin = PIN_TO_ANALOG(pin);
        if (analogInputsToReport & (1 << analogPin)) {
          Firmata.sendAnalog(analogPin, analogRead(analogPin));
        }
      }
    }
    // report i2c data for all device with read continuous mode enabled
    if (queryIndex > -1) {
      for (byte i = 0; i < queryIndex + 1; i++) {
        readAndReportData(query[i].addr, query[i].reg, query[i].bytes);
      }
    }
  }

#if !defined local_ip && !defined _YUN_CLIENT_H_
  if (Ethernet.maintain())
  {
    stream.maintain(Ethernet.localIP());
  }
#endif

}
",8422,False,1528.7163599606356,median
"[[production-ready]]
= Spring Boot Actuator: Production-ready features

[partintro]
--
Spring Boot includes a number of additional features to help you monitor and manage your
application when it's pushed to production. You can choose to manage and monitor your
application using HTTP endpoints or with JMX. Auditing, health and metrics gathering can
be automatically applied to your application.

Actuator HTTP endpoints are only available with a Spring MVC-based application. In
particular, it will not work with Jersey <<howto.adoc#howto-use-actuator-with-jersey,
unless you enable Spring MVC as well.>>
--



[[production-ready-enabling]]
== Enabling production-ready features
The {github-code}/spring-boot-actuator[`spring-boot-actuator`] module provides all of
Spring Boot's production-ready features. The simplest way to enable the features is to add
a dependency to the `spring-boot-starter-actuator` '`Starter`'.

.Definition of Actuator
****
An actuator is a manufacturing term, referring to a mechanical device for moving or
controlling something. Actuators can generate a large amount of motion from a small
change.
****

To add the actuator to a Maven based project, add the following '`Starter`'
dependency:

[source,xml,indent=0]
----
	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-actuator</artifactId>
		</dependency>
	</dependencies>
----

For Gradle, use the declaration:

[source,groovy,indent=0]
----
	dependencies {
		compile(""org.springframework.boot:spring-boot-starter-actuator"")
	}
----



[[production-ready-endpoints]]
== Endpoints
Actuator endpoints allow you to monitor and interact with your application. Spring Boot
includes a number of built-in endpoints and you can also add your own. For example the
`health` endpoint provides basic application health information.

The way that endpoints are exposed will depend on the type of technology that you choose.
Most applications choose HTTP monitoring, where the ID of the endpoint along with a prefix of
`/application` is mapped to a URL. For example, by default, the `health` endpoint will be mapped
to `/application/health`.

The following technology agnostic endpoints are available:

[cols=""2,5""]
|===
| ID | Description

|`auditevents`
|Exposes audit events information for the current application.

|`autoconfig`
|Displays an auto-configuration report showing all auto-configuration candidates and the
 reason why they '`were`' or '`were not`' applied.

|`beans`
|Displays a complete list of all the Spring beans in your application.

|`configprops`
|Displays a collated list of all `@ConfigurationProperties`.

|`env`
|Exposes properties from Spring's `ConfigurableEnvironment`.

|`flyway`
|Shows any Flyway database migrations that have been applied.

|`health`
|Shows application health information.

|`info`
|Displays arbitrary application info.

|`loggers`
|Shows and modifies the configuration of loggers in the application.

|`liquibase`
|Shows any Liquibase database migrations that have been applied.

|`metrics`
|Shows '`metrics`' information for the current application.

|`mappings`
|Displays a collated list of all `@RequestMapping` paths.

|`shutdown`
|Allows the application to be gracefully shutdown (not enabled by default).

|`status`
|Show application status information (i.e. `health` status with no additional details)

|`threaddump`
|Performs a thread dump.

|`trace`
|Displays trace information (by default the last 100 HTTP requests).
|===

If your application is a web application (Spring MVC, Spring WebFlux, or Jersey), the
following additional endpoints can also be used:

[cols=""2,5""]
|===
| ID | Description

|`heapdump`
|Returns a GZip compressed `hprof` heap dump file.

|`logfile`
|Returns the contents of the logfile (if `logging.file` or `logging.path` properties have
been set). Supports the use of the HTTP `Range` header to retrieve part of the log file's
content.
|===

[[production-ready-endpoints-security]]
=== Securing endpoints
By default all HTTP endpoints are secured such that only users that have an `ACTUATOR`
role may access them. Security is enforced using the standard
`HttpServletRequest.isUserInRole` method.

TIP: Use the `management.security.roles` property if you want something different to
`ACTUATOR`.

If you are deploying applications behind a firewall, you may prefer that all your actuator
endpoints can be accessed without requiring authentication. You can do this by changing
the `management.security.enabled` property:

.application.properties
[source,properties,indent=0]
----
	management.security.enabled=false
----

NOTE: By default, actuator endpoints are exposed on the same port that serves regular
HTTP traffic. Take care not to accidentally expose sensitive information if you change
the `management.security.enabled` property.

If you're deploying applications publicly, you may want to add '`Spring Security`' to
handle user authentication. When '`Spring Security`' is added, by default '`basic`'
authentication will be used with the username `user` and a generated password (which is
printed on the console when the application starts).

TIP: Generated passwords are logged as the application starts. Search for '`Using default
security password`'.

You can use Spring properties to change the username and password and to change the
security role(s) required to access the endpoints. For example, you might set the following
in your `application.properties`:

[source,properties,indent=0]
----
	security.user.name=admin
	security.user.password=secret
	management.security.roles=SUPERUSER
----

If your application has custom security configuration and you want all your actuator
endpoints to be accessible without authentication, you need to explicitly configure that
in your security configuration. Along with that, you need to change the
`management.security.enabled` property to `false`.

If your custom security configuration secures your actuator endpoints, you also need to
ensure that the authenticated user has the roles specified under
`management.security.roles`.

TIP: If you don't have a use case for exposing basic health information to unauthenticated
users, and you have secured the actuator endpoints with custom security, you can set
`management.security.enabled` to `false`. This will inform Spring Boot to skip the
additional role check.



[[production-ready-customizing-endpoints]]
=== Customizing endpoints
Endpoints can be customized using Spring properties. You can change if an endpoint is
`enabled` and its `id`.

For example, here is an `application.properties` that changes the id of the `beans`
endpoint and also enables `shutdown`.

[source,properties,indent=0]
----
	endpoints.beans.id=springbeans
	endpoints.shutdown.enabled=true
----

NOTE: The prefix ‟`endpoints` + `.` + `name`” is used to uniquely identify the endpoint
that is being configured.

By default, all endpoints except for `shutdown` are enabled. If you prefer to
specifically ""`opt-in`"" endpoint enablement you can use the `endpoints.default.enabled`
property. For example, the following will disable _all_ endpoints except for `info`:

[source,properties,indent=0]
----
	endpoints.default.enabled=false
	endpoints.info.enabled=true
----



[[production-ready-endpoint-hypermedia]]
=== Hypermedia for actuator MVC endpoints
A ""`discovery page`"" is added with links to all the endpoints. The ""`discovery page`"" is
available on `/application` by default.

When a custom management context path is configured, the ""`discovery page`"" will
automatically move from `/application` to the root of the management context. For example,
if the management context path is `/management` then the discovery page will be available
from `/management`.



[[production-ready-endpoint-cors]]
=== CORS support
http://en.wikipedia.org/wiki/Cross-origin_resource_sharing[Cross-origin resource sharing]
(CORS) is a http://www.w3.org/TR/cors/[W3C specification] that allows you to specify in a
flexible way what kind of cross domain requests are authorized. If you are using Spring
MVC or Spring WebFlux, Actuator's web endpoints can be configured to support such
scenarios.

CORS support is disabled by default and is only enabled once the
`management.endpoints.cors.allowed-origins` property has been set. The configuration below
permits `GET` and `POST` calls from the `example.com` domain:

[source,properties,indent=0]
----
	management.endpoints.cors.allowed-origins=http://example.com
	management.endpoints.cors.allowed-methods=GET,POST
----

TIP: Check {sc-spring-boot-actuator}/autoconfigure/EndpointCorsProperties.{sc-ext}[EndpointCorsProperties]
for a complete list of options.



[[production-ready-customizing-endpoints-programmatically]]
=== Adding custom endpoints
If you add a `@Bean` annotated with `@Endpoint`, any methods annotated with
`@ReadOperation` or `@WriteOperation` will automatically be exposed over JMX and, in a web
application, over HTTP as well.

TIP: If you are doing this as a library feature consider adding a configuration class
annotated with `@ManagementContextConfiguration` to `/META-INF/spring.factories` under the
key `org.springframework.boot.actuate.autoconfigure.ManagementContextConfiguration`. If
you do that then the endpoint will move to a child context with all the other web
endpoints endpoints if your users ask for a separate management port or address.



[[production-ready-health]]
=== Health information
Health information can be used to check the status of your running application. It is
often used by monitoring software to alert someone if a production system goes down.
The default information exposed by the `health` endpoint depends on how it is accessed.
For an unauthenticated connection in a secure application a simple '`status`' message is
returned, and for an authenticated connection additional details are also displayed (see
<<production-ready-health-access-restrictions>> for HTTP details).

Health information is collected from all
{sc-spring-boot-actuator}/health/HealthIndicator.{sc-ext}[`HealthIndicator`] beans defined
in your `ApplicationContext`. Spring Boot includes a number of auto-configured
`HealthIndicators` and you can also write your own. By default, the final system state is
derived by the `HealthAggregator` which sorts the statuses from each `HealthIndicator`
based on an ordered list of statuses. The first status in the sorted list is used as the
overall health status. If no `HealthIndicator` returns a status that is known to the
`HealthAggregator`, an `UNKNOWN` status is used.



==== Auto-configured HealthIndicators
The following `HealthIndicators` are auto-configured by Spring Boot when appropriate:

[cols=""1,4""]
|===
|Name |Description

|{sc-spring-boot-actuator}/health/CassandraHealthIndicator.{sc-ext}[`CassandraHealthIndicator`]
|Checks that a Cassandra database is up.

|{sc-spring-boot-actuator}/health/DiskSpaceHealthIndicator.{sc-ext}[`DiskSpaceHealthIndicator`]
|Checks for low disk space.

|{sc-spring-boot-actuator}/health/DataSourceHealthIndicator.{sc-ext}[`DataSourceHealthIndicator`]
|Checks that a connection to `DataSource` can be obtained.

|{sc-spring-boot-actuator}/health/ElasticsearchHealthIndicator.{sc-ext}[`ElasticsearchHealthIndicator`]
|Checks that an Elasticsearch cluster is up.

|{sc-spring-boot-actuator}/health/JmsHealthIndicator.{sc-ext}[`JmsHealthIndicator`]
|Checks that a JMS broker is up.

|{sc-spring-boot-actuator}/health/MailHealthIndicator.{sc-ext}[`MailHealthIndicator`]
|Checks that a mail server is up.

|{sc-spring-boot-actuator}/health/MongoHealthIndicator.{sc-ext}[`MongoHealthIndicator`]
|Checks that a Mongo database is up.

|{sc-spring-boot-actuator}/health/RabbitHealthIndicator.{sc-ext}[`RabbitHealthIndicator`]
|Checks that a Rabbit server is up.

|{sc-spring-boot-actuator}/health/RedisHealthIndicator.{sc-ext}[`RedisHealthIndicator`]
|Checks that a Redis server is up.

|{sc-spring-boot-actuator}/health/SolrHealthIndicator.{sc-ext}[`SolrHealthIndicator`]
|Checks that a Solr server is up.
|===

TIP: It is possible to disable them all using the `management.health.defaults.enabled`
property.


==== Writing custom HealthIndicators
To provide custom health information you can register Spring beans that implement the
{sc-spring-boot-actuator}/health/HealthIndicator.{sc-ext}[`HealthIndicator`] interface.
You need to provide an implementation of the `health()` method and return a `Health`
response. The `Health` response should include a status and can optionally include
additional details to be displayed.

[source,java,indent=0]
----
	import org.springframework.boot.actuate.health.Health;
	import org.springframework.boot.actuate.health.HealthIndicator;
	import org.springframework.stereotype.Component;

	@Component
	public class MyHealthIndicator implements HealthIndicator {

		@Override
		public Health health() {
			int errorCode = check(); // perform some specific health check
			if (errorCode != 0) {
				return Health.down().withDetail(""Error Code"", errorCode).build();
			}
			return Health.up().build();
		}

	}
----

NOTE: The identifier for a given `HealthIndicator` is the name of the bean without the
`HealthIndicator` suffix if it exists. In the example above, the health information will
be available in an entry named `my`.

In addition to Spring Boot's predefined {sc-spring-boot-actuator}/health/Status.{sc-ext}[`Status`]
types, it is also possible for `Health` to return a custom `Status` that represents a
new system state. In such cases a custom implementation of the
{sc-spring-boot-actuator}/health/HealthAggregator.{sc-ext}[`HealthAggregator`]
interface also needs to be provided, or the default implementation has to be configured
using the `management.health.status.order` configuration property.

For example, assuming a new `Status` with code `FATAL` is being used in one of your
`HealthIndicator` implementations. To configure the severity order add the following
to your application properties:

[source,properties,indent=0]
----
	management.health.status.order=FATAL, DOWN, OUT_OF_SERVICE, UNKNOWN, UP
----

The HTTP status code in the response reflects the overall health status (e.g. `UP`
maps to 200, `OUT_OF_SERVICE` or `DOWN` to 503). You might also want to register custom
status mappings if you access the health endpoint over HTTP. For example, the following
maps `FATAL` to `HttpStatus.SERVICE_UNAVAILABLE`:

[source,properties,indent=0]
----
	management.health.status.http-mapping.FATAL=503
----

TIP: If you need more control you can define your own `HealthStatusHttpMapper` bean.

The default status mappings for the built-in statuses are:

[cols=""1,3""]
|===
|Status |Mapping

|DOWN
|SERVICE_UNAVAILABLE (503)

|OUT_OF_SERVICE
|SERVICE_UNAVAILABLE (503)

|UP
|No mapping by default, so http status is 200

|UNKNOWN
|No mapping by default, so http status is 200
|===



[[production-ready-application-info]]
=== Application information
Application information exposes various information collected from all
{sc-spring-boot-actuator}/info/InfoContributor.{sc-ext}[`InfoContributor`] beans defined
in your `ApplicationContext`. Spring Boot includes a number of auto-configured
`InfoContributors` and you can also write your own.

[[production-ready-application-info-autoconfigure]]
==== Auto-configured InfoContributors

The following `InfoContributors` are auto-configured by Spring Boot when appropriate:

[cols=""1,4""]
|===
|Name |Description

|{sc-spring-boot-actuator}/info/EnvironmentInfoContributor.{sc-ext}[`EnvironmentInfoContributor`]
|Expose any key from the `Environment` under the `info` key.

|{sc-spring-boot-actuator}/info/GitInfoContributor.{sc-ext}[`GitInfoContributor`]
|Expose git information if a `git.properties` file is available.

|{sc-spring-boot-actuator}/info/BuildInfoContributor.{sc-ext}[`BuildInfoContributor`]
|Expose build information if a `META-INF/build-info.properties` file is available.
|===

TIP: It is possible to disable them all using the `management.info.defaults.enabled`
property.

[[production-ready-application-info-env]]
==== Custom application info information
You can customize the data exposed by the `info` endpoint by setting `+info.*+` Spring
properties. All `Environment` properties under the info key will be automatically
exposed. For example, you could add the following to your `application.properties`:

[source,properties,indent=0]
----
	info.app.encoding=UTF-8
	info.app.java.source=1.8
	info.app.java.target=1.8
----

[TIP]
====
Rather than hardcoding those values you could also
<<howto.adoc#howto-automatic-expansion,expand info properties at build time>>.

Assuming you are using Maven, you could rewrite the example above as follows:

[source,properties,indent=0]
----
	info.app.encoding=@project.build.sourceEncoding@
	info.app.java.source=@java.version@
	info.app.java.target=@java.version@
----
====



[[production-ready-application-info-git]]
==== Git commit information
Another useful feature of the `info` endpoint is its ability to publish information
about the state of your `git` source code repository when the project was built. If a
`GitProperties` bean is available, the `git.branch`, `git.commit.id` and
`git.commit.time` properties will be exposed.

TIP: A `GitProperties` bean is auto-configured if a `git.properties` file is available
at the root of the classpath. See
<<howto.adoc#howto-git-info,Generate git information>> for more details.

If you want to display the full git information (i.e. the full content of
`git.properties`), use the `management.info.git.mode` property:

[source,properties,indent=0]
----
	management.info.git.mode=full
----



[[production-ready-application-info-build]]
==== Build information
The `info` endpoint can also publish information about your build if a `BuildProperties`
bean is available. This happens if a `META-INF/build-info.properties` file is available
in the classpath.

TIP: The Maven and Gradle plugins can both generate that file, see
<<howto.adoc#howto-build-info,Generate build information>> for more details.


[[production-ready-application-info-custom]]
==== Writing custom InfoContributors
To provide custom application information you can register Spring beans that implement
the {sc-spring-boot-actuator}/info/InfoContributor.{sc-ext}[`InfoContributor`] interface.

The example below contributes an `example` entry with a single value:

[source,java,indent=0]
----
	import java.util.Collections;

	import org.springframework.boot.actuate.info.Info;
	import org.springframework.boot.actuate.info.InfoContributor;
	import org.springframework.stereotype.Component;

	@Component
	public class ExampleInfoContributor implements InfoContributor {

		@Override
		public void contribute(Info.Builder builder) {
			builder.withDetail(""example"",
					Collections.singletonMap(""key"", ""value""));
		}

	}
----

If you hit the `info` endpoint you should see a response that contains the following
additional entry:

[source,json,indent=0]
----
	{
		""example"": {
			""key"" : ""value""
		}
	}
----



[[production-ready-monitoring]]
== Monitoring and management over HTTP
If you are developing a Spring MVC application, Spring Boot Actuator will auto-configure
all enabled endpoints to be exposed over HTTP. The default convention is to use the
`id` of the endpoint with a prefix of `/application` as the URL path. For example, `health`
is exposed as `/application/health`.



[[production-ready-customizing-management-server-context-path]]
=== Customizing the management endpoint paths
Sometimes it is useful to customize the prefix for the management endpoints.
For example, your application might already use `/application` for another purpose.
You can use the `management.context-path` property to change the prefix for your
management endpoint:

[source,properties,indent=0]
----
	management.context-path=/manage
----

The `application.properties` example above will change the endpoint from `/application/{id}` to
`/manage/{id}` (e.g. `/manage/info`).

NOTE: Even if an endpoint path is configured separately, it is still relative to the
`management.context-path`.



[[production-ready-customizing-management-server-port]]
=== Customizing the management server port
Exposing management endpoints using the default HTTP port is a sensible choice for cloud
based deployments. If, however, your application runs inside your own data center you
may prefer to expose endpoints using a different HTTP port.

The `management.port` property can be used to change the HTTP port.

[source,properties,indent=0]
----
	management.port=8081
----

Since your management port is often protected by a firewall, and not exposed to the public
you might not need security on the management endpoints, even if your main application is
secure. In that case you will have Spring Security on the classpath, and you can disable
management security like this:

[source,properties,indent=0]
----
	management.security.enabled=false
----

(If you don't have Spring Security on the classpath then there is no need to explicitly
disable the management security in this way, and it might even break the application.)



[[production-ready-management-specific-ssl]]
=== Configuring management-specific SSL
When configured to use a custom port, the management server can also be configured with
its own SSL using the various `management.ssl.*` properties. For example, this allows a
management server to be available via HTTP while the main application uses HTTPS:

[source,properties,indent=0]
----
	server.port=8443
	server.ssl.enabled=true
	server.ssl.key-store=classpath:store.jks
	server.ssl.key-password=secret
	management.port=8080
	management.ssl.enabled=false
----

Alternatively, both the main server and the management server can use SSL but with
different key stores:

[source,properties,indent=0]
----
	server.port=8443
	server.ssl.enabled=true
	server.ssl.key-store=classpath:main.jks
	server.ssl.key-password=secret
	management.port=8080
	management.ssl.enabled=true
	management.ssl.key-store=classpath:management.jks
	management.ssl.key-password=secret
----



[[production-ready-customizing-management-server-address]]
=== Customizing the management server address
You can customize the address that the management endpoints are available on by
setting the `management.address` property. This can be useful if you want to
listen only on an internal or ops-facing network, or to only listen for connections from
`localhost`.

NOTE: You can only listen on a different address if the port is different to the
main server port.

Here is an example `application.properties` that will not allow remote management
connections:

[source,properties,indent=0]
----
	management.port=8081
	management.address=127.0.0.1
----



[[production-ready-disabling-http-endpoints]]
=== Disabling HTTP endpoints
If you don't want to expose endpoints over HTTP you can set the management port to `-1`:

[source,properties,indent=0]
----
	management.port=-1
----


[[production-ready-health-access-restrictions]]
=== HTTP health endpoint format and access restrictions
The information exposed by the health endpoint varies depending on whether or not it's
accessed anonymously, and whether or not the enclosing application is secure.
By default, when accessed anonymously in a secure application, any details about the
server's health are hidden and the endpoint will simply indicate whether or not the server
is up or down.

Sample summarized HTTP response (default for anonymous request):

[source,indent=0]
----
	$ curl -i localhost:8080/health
	HTTP/1.1 200
	X-Application-Context: application
	Content-Type: application/vnd.spring-boot.actuator.v2+json;charset=UTF-8
	Content-Length: 15

	{""status"":""UP""}
----

Sample summarized HTTP response for status ""DOWN"" (notice the 503 status code):

[source,indent=0]
----
	$ curl -i localhost:8080/health
	HTTP/1.1 503
	X-Application-Context: application
	Content-Type: application/vnd.spring-boot.actuator.v2+json;charset=UTF-8
	Content-Length: 17

	{""status"":""DOWN""}
----

Sample detailed HTTP response:

[source,indent=0]
----
	$ curl -i localhost:8080/health
	HTTP/1.1 200 OK
	X-Application-Context: application
	Content-Type: application/vnd.spring-boot.actuator.v2+json;charset=UTF-8
	Content-Length: 221

	{
	  ""status"" : ""UP"",
	  ""diskSpace"" : {
	    ""status"" : ""UP"",
	    ""total"" : 63251804160,
	    ""free"" : 31316164608,
	    ""threshold"" : 10485760
	  },
	  ""db"" : {
	    ""status"" : ""UP"",
	    ""database"" : ""H2"",
	    ""hello"" : 1
	  }
	}
----



[[production-ready-jmx]]
== Monitoring and management over JMX
Java Management Extensions (JMX) provide a standard mechanism to monitor and manage
applications. By default Spring Boot will expose management endpoints as JMX MBeans
under the `org.springframework.boot` domain.



[[production-ready-custom-mbean-names]]
=== Customizing MBean names
The name of the MBean is usually generated from the `id` of the endpoint. For example
the `health` endpoint is exposed as `org.springframework.boot:type=Endpoint,name=Health`.

If your application contains more than one Spring `ApplicationContext` you may find that
names clash. To solve this problem you can set the `management.endpoints.jmx.unique-names`
property to `true` so that MBean names are always unique.

You can also customize the JMX domain under which endpoints are exposed. Here is an
example `application.properties`:

[source,properties,indent=0]
----
	management.endpoints.jmx.domain=com.example.myapp
	management.endpoints.jmx.unique-names=true
----



[[production-ready-disable-jmx-endpoints]]
=== Disabling JMX endpoints
If you don't want to expose endpoints over JMX you can set the `endpoints.default.jmx.enabled`
property to `false`:

[source,properties,indent=0]
----
	endpoints.default.jmx.enabled=false
----



[[production-ready-jolokia]]
=== Using Jolokia for JMX over HTTP
Jolokia is a JMX-HTTP bridge giving an alternative method of accessing JMX beans. To
use Jolokia, simply include a dependency to `org.jolokia:jolokia-core`. For example,
using Maven you would add the following:

[source,xml,indent=0]
----
	<dependency>
		<groupId>org.jolokia</groupId>
		<artifactId>jolokia-core</artifactId>
 	</dependency>
----

Jolokia can then be accessed using `/application/jolokia` on your management HTTP server.



[[production-ready-customizing-jolokia]]
==== Customizing Jolokia
Jolokia has a number of settings that you would traditionally configure using servlet
parameters. With Spring Boot you can use your `application.properties`, simply prefix the
parameter with `management.jolokia.config.`:

[source,properties,indent=0]
----
	management.jolokia.config.debug=true
----



[[production-ready-disabling-jolokia]]
==== Disabling Jolokia
If you are using Jolokia but you don't want Spring Boot to configure it, simply set the
`management.jolokia.enabled` property to `false`:

[source,properties,indent=0]
----
	management.jolokia.enabled=false
----



[[production-ready-loggers]]
== Loggers
Spring Boot Actuator includes the ability to view and configure the log levels of your
application at runtime.  You can view either the entire list or an individual logger's
configuration which is made up of both the explicitly configured logging level as well as
the effective logging level given to it by the logging framework.  These levels can be:

* `TRACE`
* `DEBUG`
* `INFO`
* `WARN`
* `ERROR`
* `FATAL`
* `OFF`
* `null`

with `null` indicating that there is no explicit configuration.



[[production-ready-logger-configuration]]
=== Configure a Logger
In order to configure a given logger, you `POST` a partial entity to the resource's URI:

[source,json,indent=0]
----
	{
		""configuredLevel"": ""DEBUG""
	}
----

TIP: You can also pass a `null` `configuredLevel` to ""reset"" the specific level of the
logger (and use the default configuration instead).



[[production-ready-metrics]]
== Metrics
Spring Boot Actuator includes a metrics service with '`gauge`' and '`counter`' support.
A '`gauge`' records a single value; and a '`counter`' records a delta (an increment or
decrement). Spring Boot Actuator also provides a
{sc-spring-boot-actuator}/endpoint/PublicMetrics.{sc-ext}[`PublicMetrics`] interface that
you can implement to expose metrics that you cannot record via one of those two
mechanisms. Look at {sc-spring-boot-actuator}/endpoint/SystemPublicMetrics.{sc-ext}[`SystemPublicMetrics`]
for an example.

Metrics for all HTTP requests are automatically recorded, so if you hit the `metrics`
endpoint you should see a response similar to this:

[source,json,indent=0]
----
	{
		""counter.status.200.root"": 20,
		""counter.status.200.metrics"": 3,
		""counter.status.200.star-star"": 5,
		""counter.status.401.root"": 4,
		""gauge.response.star-star"": 6,
		""gauge.response.root"": 2,
		""gauge.response.metrics"": 3,
		""classes"": 5808,
		""classes.loaded"": 5808,
		""classes.unloaded"": 0,
		""heap"": 3728384,
		""heap.committed"": 986624,
		""heap.init"": 262144,
		""heap.used"": 52765,
		""nonheap"": 0,
		""nonheap.committed"": 77568,
		""nonheap.init"": 2496,
		""nonheap.used"": 75826,
		""mem"": 986624,
		""mem.free"": 933858,
		""processors"": 8,
		""threads"": 15,
		""threads.daemon"": 11,
		""threads.peak"": 15,
		""threads.totalStarted"": 42,
		""uptime"": 494836,
		""instance.uptime"": 489782,
		""datasource.primary.active"": 5,
		""datasource.primary.usage"": 0.25
	}
----

Here we can see basic `memory`, `heap`, `class loading`, `processor` and `thread pool`
information along with some HTTP metrics. In this instance the `root` ('`/`') and `/metrics`
URLs have returned `HTTP 200` responses `20` and `3` times respectively. It also appears
that the `root` URL returned `HTTP 401` (unauthorized) `4` times. The double asterisks (`star-star`)
comes from a request matched by Spring MVC as `+/**+` (normally a static resource).

The `gauge` shows the last response time for a request. So the last request to `root` took
`2ms` to respond and the last to `/metrics` took `3ms`.

NOTE: In this example we are actually accessing the endpoint over HTTP using the
`/metrics` URL, this explains why `metrics` appears in the response.



[[production-ready-system-metrics]]
=== System metrics
The following system metrics are exposed by Spring Boot:

* The total system memory in KB (`mem`)
* The amount of free memory in KB (`mem.free`)
* The number of processors (`processors`)
* The system uptime in milliseconds (`uptime`)
* The application context uptime in milliseconds (`instance.uptime`)
* The average system load (`systemload.average`)
* Heap information in KB (`heap`, `heap.committed`, `heap.init`, `heap.used`)
* Thread information (`threads`, `thread.peak`, `thread.daemon`)
* Class load information (`classes`, `classes.loaded`, `classes.unloaded`)
* Garbage collection information (`gc.xxx.count`, `gc.xxx.time`)



[[production-ready-datasource-metrics]]
=== DataSource metrics
The following metrics are exposed for each supported `DataSource` defined in your
application:

* The number of active connections (`datasource.xxx.active`)
* The current usage of the connection pool (`datasource.xxx.usage`).

All data source metrics share the `datasource.` prefix. The prefix is further qualified
for each data source:

* If the data source is the primary data source (that is either the only available data
  source or the one flagged `@Primary` amongst the existing ones), the prefix is
  `datasource.primary`.
* If the data source bean name ends with `DataSource`, the prefix is the name of the bean
  without `DataSource` (i.e. `datasource.batch` for `batchDataSource`).
* In all other cases, the name of the bean is used.

It is possible to override part or all of those defaults by registering a bean with a
customized version of `DataSourcePublicMetrics`. By default, Spring Boot provides metadata
for all supported data sources; you can add additional `DataSourcePoolMetadataProvider`
beans if your favorite data source isn't supported out of the box. See
`DataSourcePoolMetadataProvidersConfiguration` for examples.



[[production-ready-datasource-cache]]
=== Cache metrics
The following metrics are exposed for each supported cache defined in your application:

* The current size of the cache (`cache.xxx.size`)
* Hit ratio (`cache.xxx.hit.ratio`)
* Miss ratio (`cache.xxx.miss.ratio`)

NOTE: Cache providers do not expose the hit/miss ratio in a consistent way. While some
expose an **aggregated** value (i.e. the hit ratio since the last time the stats were
cleared), others expose a **temporal** value (i.e. the hit ratio of the last second).
Check your caching provider documentation for more details.

If two different cache managers happen to define the same cache, the name of the cache
is prefixed by the name of the `CacheManager` bean.

It is possible to override part or all of those defaults by registering a bean with a
customized version of `CachePublicMetrics`. By default, Spring Boot provides cache
statistics for EhCache, Hazelcast, Infinispan, JCache and Caffeine. You can add additional
`CacheStatisticsProvider` beans if your favorite caching library isn't supported out of
the box. See `CacheStatisticsAutoConfiguration` for examples.


[[production-ready-session-metrics]]
=== Tomcat session metrics
If you are using Tomcat as your embedded servlet container, session metrics will
automatically be exposed. The `httpsessions.active` and `httpsessions.max` keys provide
the number of active and maximum sessions.



[[production-ready-recording-metrics]]
=== Recording your own metrics
To record your own metrics inject a
{sc-spring-boot-actuator}/metrics/CounterService.{sc-ext}[`CounterService`] and/or
{sc-spring-boot-actuator}/metrics/GaugeService.{sc-ext}[`GaugeService`] into
your bean. The `CounterService` exposes `increment`, `decrement` and `reset` methods; the
`GaugeService` provides a `submit` method.

Here is a simple example that counts the number of times that a method is invoked:

[source,java,indent=0]
----
	import org.springframework.beans.factory.annotation.Autowired;
	import org.springframework.boot.actuate.metrics.CounterService;
	import org.springframework.stereotype.Service;

	@Service
	public class MyService {

		private final CounterService counterService;

		@Autowired
		public MyService(CounterService counterService) {
			this.counterService = counterService;
		}

		public void exampleMethod() {
			this.counterService.increment(""services.system.myservice.invoked"");
		}

	}
----

TIP: You can use any string as a metric name but you should follow guidelines of your chosen
store/graphing technology. Some good guidelines for Graphite are available on
http://matt.aimonetti.net/posts/2013/06/26/practical-guide-to-graphite-monitoring/[Matt Aimonetti's Blog].



[[production-ready-public-metrics]]
=== Adding your own public metrics
To add additional metrics that are computed every time the metrics endpoint is invoked,
simply register additional `PublicMetrics` implementation bean(s). By default, all such
beans are gathered by the endpoint. You can easily change that by defining your own
`MetricsEndpoint`.



[[production-ready-metric-writers]]
=== Metric writers, exporters and aggregation
Spring Boot provides a couple of implementations of a marker interface called `Exporter`
which can be used to copy metric readings from the in-memory buffers to a place where they
can be analyzed and displayed. Indeed, if you provide a `@Bean` that implements the
`MetricWriter` interface (or `GaugeWriter` for simple use cases) and mark it
`@ExportMetricWriter`, then it will automatically be hooked up to an `Exporter` and fed
metric updates every 5 seconds (configured via `spring.metrics.export.delay-millis`).
In addition, any `MetricReader` that you define and mark as `@ExportMetricReader` will
have its values exported by the default exporter.

NOTE: This feature is enabling scheduling in your application (`@EnableScheduling`) which
can be a problem if you run an integration test as your own scheduled tasks will start.
You can disable this behaviour by setting `spring.metrics.export.enabled` to `false`.

The default exporter is a `MetricCopyExporter` which tries to optimize itself by not
copying values that haven't changed since it was last called (the optimization can be
switched off using a flag `spring.metrics.export.send-latest`). Note also that the
Dropwizard `MetricRegistry` has no support for timestamps, so the optimization is not
available if you are using Dropwizard metrics (all metrics will be copied on every tick).

The default values for the export trigger (`delay-millis`, `includes`, `excludes`
and `send-latest`) can be set as `spring.metrics.export.\\*`. Individual
values for specific `MetricWriters` can be set as
`spring.metrics.export.triggers.<name>.*` where `<name>` is a bean name (or pattern for
matching bean names).

WARNING: The automatic export of metrics is disabled if you switch off the default
`MetricRepository` (e.g. by using Dropwizard metrics). You can get back the same
functionality be declaring a bean of your own of type `MetricReader` and  declaring it to
be `@ExportMetricReader`.



[[production-ready-metric-writers-export-to-redis]]
==== Example: Export to Redis
If you provide a `@Bean` of type `RedisMetricRepository` and mark it `@ExportMetricWriter`
the metrics are exported to a Redis cache for aggregation. The `RedisMetricRepository` has
two important parameters to configure it for this purpose: `prefix` and `key` (passed into
its constructor). It is best to use a prefix that is unique to the application instance
(e.g. using a random value and maybe the logical name of the application to make it
possible to correlate with other instances of the same application).  The ""`key`"" is used
to keep a global index of all metric names, so it should be unique ""`globally`"", whatever
that means for your system (e.g. two instances of the same system could share a Redis cache
if they have distinct keys).

Example:

[source,java,indent=0]
----
	@Bean
	@ExportMetricWriter
	MetricWriter metricWriter(MetricExportProperties export) {
		return new RedisMetricRepository(connectionFactory,
			export.getRedis().getPrefix(), export.getRedis().getKey());
	}
----

.application.properties
[source,properties,indent=0]
----
	spring.metrics.export.redis.prefix: metrics.mysystem.${spring.application.name:application}.${random.value:0000}
	spring.metrics.export.redis.key: keys.metrics.mysystem
----

The prefix is constructed with the application name and id at the end, so it can easily be used
to identify a group of processes with the same logical name later.

NOTE: It's important to set both the `key` and the `prefix`. The key is used for all
repository operations, and can be shared by multiple repositories. If multiple
repositories share a key (like in the case where you need to aggregate across them), then
you normally have a read-only ""`master`"" repository that has a short, but identifiable,
prefix (like ""`metrics.mysystem`""), and many write-only repositories with prefixes that
start with the master prefix (like `metrics.mysystem.*` in the example above). It is
efficient to read all the keys from a ""`master`"" repository like that, but inefficient to
read a subset with a longer prefix (e.g. using one of the writing repositories).

TIP: The example above uses `MetricExportProperties` to inject and extract the key and
prefix. This is provided to you as a convenience by Spring Boot, configured with sensible
defaults. There is nothing to stop you using your own values as long as they follow the
recommendations.



[[production-ready-metric-writers-export-to-open-tsdb]]
==== Example: Export to Open TSDB
If you provide a `@Bean` of type `OpenTsdbGaugeWriter` and mark it
`@ExportMetricWriter` metrics are exported to http://opentsdb.net/[Open TSDB] for
aggregation. The `OpenTsdbGaugeWriter` has a `url` property that you need to set
to the Open TSDB ""`/put`"" endpoint, e.g. `http://localhost:4242/api/put`). It also has a
`namingStrategy` that you can customize or configure to make the metrics match the data
structure you need on the server. By default it just passes through the metric name as an
Open TSDB metric name, and adds the tags ""`domain`"" (with value
""`org.springframework.metrics`"") and ""`process`"" (with the value equal to the object hash
of the naming strategy). Thus, after running the application and generating some metrics
you can inspect the metrics in the TSD UI (http://localhost:4242 by default).

Example:

[source,indent=0]
----
	curl localhost:4242/api/query?start=1h-ago&m=max:counter.status.200.root
	[
		{
			""metric"": ""counter.status.200.root"",
			""tags"": {
				""domain"": ""org.springframework.metrics"",
				""process"": ""b968a76""
			},
			""aggregateTags"": [],
			""dps"": {
				""1430492872"": 2,
				""1430492875"": 6
			}
		}
	]
----



[[production-ready-metric-writers-export-to-statsd]]
==== Example: Export to Statsd
To export metrics to Statsd, make sure first that you have added
`com.timgroup:java-statsd-client` as a dependency of your project (Spring Boot
provides a dependency management for it). Then add a `spring.metrics.export.statsd.host`
value to your `application.properties` file. Connections will be opened to port `8125`
unless a `spring.metrics.export.statsd.port` override is provided. You can use
`spring.metrics.export.statsd.prefix` if you want a custom prefix.

Alternatively, you can provide a `@Bean` of type `StatsdMetricWriter` and mark it
`@ExportMetricWriter`:

[source,java,indent=0]
----
	@Value(""${spring.application.name:application}.${random.value:0000}"")
	private String prefix = ""metrics"";

	@Bean
	@ExportMetricWriter
	MetricWriter metricWriter() {
		return new StatsdMetricWriter(prefix, ""localhost"", 8125);
	}
----



[[production-ready-metric-writers-export-to-jmx]]
==== Example: Export to JMX
If you provide a `@Bean` of type `JmxMetricWriter` marked `@ExportMetricWriter` the metrics are exported as MBeans to
the local server (the `MBeanExporter` is provided by Spring Boot JMX auto-configuration as
long as it is switched on). Metrics can then be inspected, graphed, alerted etc. using any
tool that understands JMX (e.g. JConsole or JVisualVM).

Example:

[source,java,indent=0]
----
	@Bean
	@ExportMetricWriter
	MetricWriter metricWriter(MBeanExporter exporter) {
		return new JmxMetricWriter(exporter);
	}
----

Each metric is exported as an individual MBean. The format for the `ObjectNames` is given
by an `ObjectNamingStrategy` which can be injected into the `JmxMetricWriter` (the default
breaks up the metric name and tags the first two period-separated sections in a way that
should make the metrics group nicely in JVisualVM or JConsole).



[[production-ready-metric-aggregation]]
=== Aggregating metrics from multiple sources
There is an `AggregateMetricReader` that you can use to consolidate metrics from different
physical sources. Sources for the same logical metric just need to publish them with a
period-separated prefix, and the reader will aggregate (by truncating the metric names,
and dropping the prefix). Counters are summed and everything else (i.e. gauges) take their
most recent value.

This is very useful if multiple application instances are feeding to a central (e.g.
Redis) repository and you want to display the results. Particularly recommended in
conjunction with a `MetricReaderPublicMetrics` for hooking up to the results to the
""`/metrics`"" endpoint.

Example:

[source,java,indent=0]
----
	@Autowired
	private MetricExportProperties export;

	@Bean
	public PublicMetrics metricsAggregate() {
		return new MetricReaderPublicMetrics(aggregatesMetricReader());
	}

	private MetricReader globalMetricsForAggregation() {
		return new RedisMetricRepository(this.connectionFactory,
			this.export.getRedis().getAggregatePrefix(), this.export.getRedis().getKey());
	}

	private MetricReader aggregatesMetricReader() {
		AggregateMetricReader repository = new AggregateMetricReader(
			globalMetricsForAggregation());
		return repository;
	}
----

NOTE: The example above uses `MetricExportProperties` to inject and extract the key and
prefix. This is provided to you as a convenience by Spring Boot, and the defaults will be
sensible. They are set up in `MetricExportAutoConfiguration`.

NOTE: The `MetricReaders` above are not `@Beans` and are not marked as
`@ExportMetricReader` because they are just collecting and analyzing data from other
repositories, and don't want to export their values.



[[production-ready-dropwizard-metrics]]
=== Dropwizard Metrics
A default `MetricRegistry` Spring bean will be created when you declare a dependency to
the `io.dropwizard.metrics:metrics-core` library; you can also register you own `@Bean`
instance if you need customizations. Users of the
https://dropwizard.github.io/metrics/[Dropwizard '`Metrics`' library] will find that
Spring Boot metrics are automatically published to `com.codahale.metrics.MetricRegistry`.
Metrics from the `MetricRegistry` are also automatically exposed via the `/metrics`
endpoint

When Dropwizard metrics are in use, the default `CounterService` and `GaugeService` are
replaced with a `DropwizardMetricServices`, which is a wrapper around the `MetricRegistry`
(so you can `@Autowired` one of those services and use it as normal). You can also create
""`special`"" Dropwizard metrics by prefixing your metric names with the appropriate type
(i.e. `+timer.*+`, `+histogram.*+` for gauges, and `+meter.*+` for counters).



[[production-ready-metrics-message-channel-integration]]
=== Message channel integration
If a `MessageChannel` bean called `metricsChannel` exists, then a `MetricWriter` will be
created that writes metrics to that channel. Each message sent to the channel will contain
a {dc-spring-boot-actuator}/metrics/writer/Delta.{dc-ext}[`Delta`] or
{dc-spring-boot-actuator}/metrics/Metric.{dc-ext}[`Metric`] payload and have a `metricName`
header. The writer is automatically hooked up to an exporter (as for all writers), so all
metric values will appear on the channel, and additional analysis or actions can be taken
by subscribers (it's up to you to provide the channel and any subscribers you need).



[[production-ready-auditing]]
== Auditing
Spring Boot Actuator has a flexible audit framework that will publish events once Spring
Security is in play ('`authentication success`', '`failure`' and '`access denied`'
exceptions by default). This can be very useful for reporting, and also to implement a
lock-out policy based on authentication failures. To customize published security events
you can provide your own implementations of `AbstractAuthenticationAuditListener` and
`AbstractAuthorizationAuditListener`.

You can also choose to use the audit services for your own business events. To do that
you can either inject the existing `AuditEventRepository` into your own components and
use that directly, or you can simply publish `AuditApplicationEvent` via the Spring
`ApplicationEventPublisher` (using `ApplicationEventPublisherAware`).



[[production-ready-tracing]]
== Tracing
Tracing is automatically enabled for all HTTP requests. You can view the `trace` endpoint
and obtain basic information about the last 100 requests:

[source,json,indent=0]
----
	[{
		""timestamp"": 1394343677415,
		""info"": {
			""method"": ""GET"",
			""path"": ""/trace"",
			""headers"": {
				""request"": {
					""Accept"": ""text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8"",
					""Connection"": ""keep-alive"",
					""Accept-Encoding"": ""gzip, deflate"",
					""User-Agent"": ""Mozilla/5.0 Gecko/Firefox"",
					""Accept-Language"": ""en-US,en;q=0.5"",
					""Cookie"": ""_ga=GA1.1.827067509.1390890128; ...""
					""Authorization"": ""Basic ..."",
					""Host"": ""localhost:8080""
				},
				""response"": {
					""Strict-Transport-Security"": ""max-age=31536000 ; includeSubDomains"",
					""X-Application-Context"": ""application:8080"",
					""Content-Type"": ""application/json;charset=UTF-8"",
					""status"": ""200""
				}
			}
		}
	},{
		""timestamp"": 1394343684465,
		...
	}]
----

The following are included in the trace by default:

[cols=""1,2""]
|===
|Name |Description

|Request Headers
|Headers from the request.

|Response Headers
|Headers from the response.

|Cookies
|`Cookie` from request headers and `Set-Cookie` from response headers.

|Errors
|The error attributes (if any).

|Time Taken
|The time taken to service the request in milliseconds.
|===



[[production-ready-custom-tracing]]
=== Custom tracing
If you need to trace additional events you can inject a
{sc-spring-boot-actuator}/trace/TraceRepository.{sc-ext}[`TraceRepository`] into your
Spring beans. The `add` method accepts a single `Map` structure that will be converted to
JSON and logged.

By default an `InMemoryTraceRepository` will be used that stores the last 100 events. You
can define your own instance of the `InMemoryTraceRepository` bean if you need to expand
the capacity. You can also create your own alternative `TraceRepository` implementation
if needed.



[[production-ready-process-monitoring]]
== Process monitoring
In Spring Boot Actuator you can find a couple of classes to create files that are useful
for process monitoring:

* `ApplicationPidFileWriter` creates a file containing the application PID (by default in
  the application directory with the file name `application.pid`).
* `EmbeddedServerPortFileWriter` creates a file (or files) containing the ports of the
  embedded server (by default in the application directory with the file name
  `application.port`).

These writers are not activated by default, but you can enable them in one of the ways
described below.



[[production-ready-process-monitoring-configuration]]
=== Extend configuration
In `META-INF/spring.factories` file you can activate the listener(s) that
writes a PID file. Example:

[indent=0]
----
	org.springframework.context.ApplicationListener=\\
	org.springframework.boot.system.ApplicationPidFileWriter,\\
	org.springframework.boot.actuate.system.EmbeddedServerPortFileWriter
----



[[production-ready-process-monitoring-programmatically]]
=== Programmatically
You can also activate a listener by invoking the `SpringApplication.addListeners(...)`
method and passing the appropriate `Writer` object. This method also allows you to
customize the file name and path via the `Writer` constructor.



[[production-ready-cloudfoundry]]
== Cloud Foundry support
Spring Boot's actuator module includes additional support that is activated when you
deploy to a compatible Cloud Foundry instance. The `/cloudfoundryapplication` path
provides an alternative secured route to all `@Endpoint` beans.

The extended support allows Cloud Foundry management UIs (such as the web
application that you can use to view deployed applications) to be augmented with Spring
Boot actuator information. For example, an application status page may include full health
information instead of the typical ""`running`"" or ""`stopped`"" status.

NOTE: The `/cloudfoundryapplication` path is not directly accessible to regular users.
In order to use the endpoint a valid UAA token must be passed with the request.



[[production-ready-cloudfoundry-disable]]
=== Disabling extended Cloud Foundry actuator support
If you want to fully disable the `/cloudfoundryapplication` endpoints you can add the
following to your `application.properties` file:


.application.properties
[source,properties,indent=0]
----
	management.cloudfoundry.enabled=false
----



[[production-ready-cloudfoundry-ssl]]
=== Cloud Foundry self signed certificates
By default, the security verification for `/cloudfoundryapplication` endpoints makes SSL
calls to various Cloud Foundry services. If your Cloud Foundry UAA or Cloud Controller
services use self-signed certificates you will need to set the following property:

.application.properties
[source,properties,indent=0]
----
	management.cloudfoundry.skip-ssl-validation=true
----



[[production-ready-cloudfoundry-custom-security]]
=== Custom security configuration
If you define custom security configuration, and you want extended Cloud Foundry actuator
support, you'll should ensure that `/cloudfoundryapplication/**` paths are open. Without
a direct open route, your Cloud Foundry application manager will not be able to obtain
endpoint data.

For Spring Security, you'll typically include something like
`mvcMatchers(""/cloudfoundryapplication/**"").permitAll()` in your configuration:

[source,java,indent=0]
----
include::{code-examples}/cloudfoundry/CloudFoundryIgnorePathsExample.java[tag=security]
----



[[production-ready-whats-next]]
== What to read next
If you want to explore some of the concepts discussed in this chapter, you can take a
look at the actuator {github-code}/spring-boot-samples[sample applications]. You also
might want to read about graphing tools such as http://graphite.wikidot.com/[Graphite].

Otherwise, you can continue on, to read about <<deployment.adoc#deployment,
'`deployment options`'>> or jump ahead
for some in-depth information about Spring Boot's
_<<build-tool-plugins.adoc#build-tool-plugins, build tool plugins>>_.
",12460,False,2190.780297596957,median
"
////
This file is generated! See _meta/fields.yml and scripts/generate_field_docs.py
////

[[exported-fields]]
= Exported fields

[partintro]

--
This document describes the fields that are exported by Winlogbeat. They are
grouped in the following categories:

* <<exported-fields-beat>>
* <<exported-fields-cloud>>
* <<exported-fields-common>>
* <<exported-fields-docker-processor>>
* <<exported-fields-ecs>>
* <<exported-fields-eventlog>>
* <<exported-fields-host-processor>>
* <<exported-fields-kubernetes-processor>>

--
[[exported-fields-beat]]
== Beat fields

Contains common beat fields available in all event types.



*`beat.timezone`*::
+
--
type: alias

alias to: event.timezone

--

*`@timestamp`*::
+
--
type: date

example: August 26th 2016, 12:35:53.332

format: date

required: True

The timestamp when the event log record was generated.


--

*`tags`*::
+
--
Arbitrary tags that can be set per Beat and per transaction type.


--

*`fields`*::
+
--
type: object

Contains user configurable fields.


--

[float]
== error fields

Error fields containing additional info in case of errors.



*`error.type`*::
+
--
type: keyword

Error type.


--

[[exported-fields-cloud]]
== Cloud provider metadata fields

Metadata from cloud providers added by the add_cloud_metadata processor.



*`cloud.project.id`*::
+
--
example: project-x

Name of the project in Google Cloud.


--

*`meta.cloud.provider`*::
+
--
type: alias

alias to: cloud.provider

--

*`meta.cloud.instance_id`*::
+
--
type: alias

alias to: cloud.instance.id

--

*`meta.cloud.instance_name`*::
+
--
type: alias

alias to: cloud.instance.name

--

*`meta.cloud.machine_type`*::
+
--
type: alias

alias to: cloud.machine.type

--

*`meta.cloud.availability_zone`*::
+
--
type: alias

alias to: cloud.availability_zone

--

*`meta.cloud.project_id`*::
+
--
type: alias

alias to: cloud.project.id

--

*`meta.cloud.region`*::
+
--
type: alias

alias to: cloud.region

--

[[exported-fields-common]]
== Common Winlogbeat fields

Contains common fields available in all event types.



*`type`*::
+
--
required: True

The event log API type used to read the record. The possible values are ""wineventlog"" for the Windows Event Log API or ""eventlogging"" for the Event Logging API.
The Event Logging API was designed for Windows Server 2003 or Windows 2000 operating systems. In Windows Vista, the event logging infrastructure was redesigned. On Windows Vista or later operating systems, the Windows Event Log API is used. Winlogbeat automatically detects which API to use for reading event logs.


--

[[exported-fields-docker-processor]]
== Docker fields

Docker stats collected from Docker.




*`docker.container.id`*::
+
--
type: keyword

Unique container id.


--

*`docker.container.image`*::
+
--
type: keyword

Name of the image the container was built on.


--

*`docker.container.name`*::
+
--
type: keyword

Container name.


--

*`docker.container.labels`*::
+
--
type: object

Image labels.


--

[[exported-fields-ecs]]
== ECS fields

ECS fields.



[float]
== agent fields

The agent fields contain the data about the software entity, if any, that collects, detects, or observes events on a host, or takes measurements on a host. Examples include Beats. Agents may also run on observers. ECS agent.* fields shall be populated with details of the agent running on the host or observer where the event happened or the measurement was taken.



*`agent.version`*::
+
--
type: keyword

example: 6.0.0-rc2

Version of the agent.


--

*`agent.name`*::
+
--
type: keyword

example: foo

Name of the agent.
This is a name that can be given to an agent. This can be helpful if for example two Filebeat instances are running on the same host but a human readable separation is needed on which Filebeat instance data is coming from.
If no name is given, the name is often left empty.


--

*`agent.type`*::
+
--
type: keyword

example: filebeat

Type of the agent.
The agent type stays always the same and should be given by the agent used. In case of Filebeat the agent would always be Filebeat also if two Filebeat instances are run on the same machine.


--

*`agent.id`*::
+
--
type: keyword

example: 8a4f500d

Unique identifier of this agent (if one exists).
Example: For Beats this would be beat.id.


--

*`agent.ephemeral_id`*::
+
--
type: keyword

example: 8a4f500f

Ephemeral identifier of this agent (if one exists).
This id normally changes across restarts, but `agent.id` does not.


--

[float]
== base fields

The base set contains all fields which are on the top level. These fields are common across all types of events.



*`base.@timestamp`*::
+
--
type: date

example: 2016-05-23T08:05:34.853Z

required: True

Date/time when the event originated.
For log events this is the date/time when the event was generated, and not when it was read.
Required field for all events.


--

*`base.tags`*::
+
--
type: keyword

example: [""production"", ""env2""]

List of keywords used to tag each event.


--

*`base.labels`*::
+
--
type: object

example: {'application': 'foo-bar', 'env': 'production'}

Key/value pairs.
Can be used to add meta information to events. Should not contain nested objects. All values are stored as keyword.
Example: `docker` and `k8s` labels.


--

*`base.message`*::
+
--
type: text

example: Hello World

For log events the message field contains the log message.
In other use cases the message field can be used to concatenate different values which are then freely searchable. If multiple messages exist, they can be combined into one message.


--

[float]
== client fields

A client is defined as the initiator of a network connection for events regarding sessions, connections, or bidirectional flow records. For TCP events, the client is the initiator of the TCP connection that sends the SYN packet(s). For other protocols, the client is generally the initiator or requestor in the network transaction. Some systems use the term ""originator"" to refer the client in TCP connections. The client fields describe details about the system acting as the client in the network event. Client fields are usually populated in conjuction with server fields.  Client fields are generally not populated for packet-level events. 



*`client.ip`*::
+
--
type: ip

IP address of the client.
Can be one or multiple IPv4 or IPv6 addresses.


--

*`client.port`*::
+
--
type: long

Port of the client.


--

*`client.mac`*::
+
--
type: keyword

MAC address of the client.


--

*`client.domain`*::
+
--
type: keyword

Client domain.


--

*`client.bytes`*::
+
--
type: long

example: 184

Bytes sent from the client to the server.


--

*`client.packets`*::
+
--
type: long

example: 12

Packets sent from the client to the server.


--

[float]
== geo fields

Geo fields can carry data about a specific location related to an event or geo information derived from an IP field.



*`client.geo.location`*::
+
--
type: geo_point

example: { ""lon"": -73.614830, ""lat"": 45.505918 }

Longitude and latitude.


--

*`client.geo.continent_name`*::
+
--
type: keyword

example: North America

Name of the continent.


--

*`client.geo.country_name`*::
+
--
type: keyword

example: Canada

Country name.


--

*`client.geo.region_name`*::
+
--
type: keyword

example: Quebec

Region name.


--

*`client.geo.city_name`*::
+
--
type: keyword

example: Montreal

City name.


--

*`client.geo.country_iso_code`*::
+
--
type: keyword

example: CA

Country ISO code.


--

*`client.geo.region_iso_code`*::
+
--
type: keyword

example: CA-QC

Region ISO code.


--

*`client.geo.name`*::
+
--
type: keyword

example: boston-dc

User-defined description of a location, at the level of granularity they care about.
Could be the name of their data centers, the floor number, if this describes a local physical entity, city names.
Not typically used in automated geolocation.


--

[float]
== cloud fields

Fields related to the cloud or infrastructure the events are coming from.



*`cloud.provider`*::
+
--
type: keyword

example: ec2

Name of the cloud provider. Example values are ec2, gce, or digitalocean.


--

*`cloud.availability_zone`*::
+
--
type: keyword

example: us-east-1c

Availability zone in which this host is running.


--

*`cloud.region`*::
+
--
type: keyword

example: us-east-1

Region in which this host is running.


--

*`cloud.instance.id`*::
+
--
type: keyword

example: i-1234567890abcdef0

Instance ID of the host machine.


--

*`cloud.instance.name`*::
+
--
type: keyword

Instance name of the host machine.


--

*`cloud.machine.type`*::
+
--
type: keyword

example: t2.medium

Machine type of the host machine.


--

*`cloud.account.id`*::
+
--
type: keyword

example: 666777888999

The cloud account or organization id used to identify different entities in a multi-tenant environment.
Examples: AWS account id, Google Cloud ORG Id, or other unique identifier.


--

[float]
== container fields

Container fields are used for meta information about the specific container that is the source of information. These fields help correlate data based containers from any runtime.



*`container.runtime`*::
+
--
type: keyword

example: docker

Runtime managing this container.


--

*`container.id`*::
+
--
type: keyword

Unique container id.


--

*`container.image.name`*::
+
--
type: keyword

Name of the image the container was built on.


--

*`container.image.tag`*::
+
--
type: keyword

Container image tag.


--

*`container.name`*::
+
--
type: keyword

Container name.


--

*`container.labels`*::
+
--
type: object

Image labels.


--

[float]
== destination fields

Destination fields describe details about the destination of a packet/event. Destination fields are usually populated in conjunction with source fields.



*`destination.ip`*::
+
--
type: ip

IP address of the destination.
Can be one or multiple IPv4 or IPv6 addresses.


--

*`destination.port`*::
+
--
type: long

Port of the destination.


--

*`destination.mac`*::
+
--
type: keyword

MAC address of the destination.


--

*`destination.domain`*::
+
--
type: keyword

Destination domain.


--

*`destination.bytes`*::
+
--
type: long

example: 184

Bytes sent from the destination to the source.


--

*`destination.packets`*::
+
--
type: long

example: 12

Packets sent from the destination to the source.


--

[float]
== geo fields

Geo fields can carry data about a specific location related to an event or geo information derived from an IP field.



*`destination.geo.location`*::
+
--
type: geo_point

example: { ""lon"": -73.614830, ""lat"": 45.505918 }

Longitude and latitude.


--

*`destination.geo.continent_name`*::
+
--
type: keyword

example: North America

Name of the continent.


--

*`destination.geo.country_name`*::
+
--
type: keyword

example: Canada

Country name.


--

*`destination.geo.region_name`*::
+
--
type: keyword

example: Quebec

Region name.


--

*`destination.geo.city_name`*::
+
--
type: keyword

example: Montreal

City name.


--

*`destination.geo.country_iso_code`*::
+
--
type: keyword

example: CA

Country ISO code.


--

*`destination.geo.region_iso_code`*::
+
--
type: keyword

example: CA-QC

Region ISO code.


--

*`destination.geo.name`*::
+
--
type: keyword

example: boston-dc

User-defined description of a location, at the level of granularity they care about.
Could be the name of their data centers, the floor number, if this describes a local physical entity, city names.
Not typically used in automated geolocation.


--

[float]
== ecs fields

Meta-information specific to ECS.



*`ecs.version`*::
+
--
type: keyword

example: 1.0.0-beta1

required: True

ECS version this event conforms to. `ecs.version` is a required field and must exist in all events.
When querying across multiple indices -- which may conform to slightly different ECS versions -- this field lets integrations adjust to the schema version of the events.
The current version is 1.0.0-beta1 .


--

[float]
== error fields

These fields can represent errors of any kind. Use them for errors that happen while fetching events or in cases where the event itself contains an error.



*`error.id`*::
+
--
type: keyword

Unique identifier for the error.


--

*`error.message`*::
+
--
type: text

Error message.


--

*`error.code`*::
+
--
type: keyword

Error code describing the error.


--

[float]
== event fields

The event fields are used for context information about the log or metric event itself. A log is defined as an event containing details of something that happened. Log events must include the time at which the thing happened. Examples of log events include a process starting on a host, a network packet being sent from a source to a destination, or a network connection between a client and a server being initiated or closed. A metric is defined as an event containing one or more numerical or categorical measurements and the time at which the measurement was taken. Examples of metric events include memory pressure measured on a host, or vulnerabilities measured on a scanned host.



*`event.id`*::
+
--
type: keyword

example: 8a4f500d

Unique ID to describe the event.


--

*`event.kind`*::
+
--
type: keyword

example: state

The kind of the event.
This gives information about what type of information the event contains, without being specific to the contents of the event.  Examples are `event`, `state`, `alarm`. Warning: In future versions of ECS, we plan to provide a list of acceptable values for this field, please use with caution.


--

*`event.category`*::
+
--
type: keyword

example: user-management

Event category.
This contains high-level information about the contents of the event. It is more generic than `event.action`, in the sense that typically a category contains multiple actions. Warning: In future versions of ECS, we plan to provide a list of acceptable values for this field, please use with caution.


--

*`event.action`*::
+
--
type: keyword

example: user-password-change

The action captured by the event.
This describes the information in the event. It is more specific than `event.category`. Examples are `group-add`, `process-started`, `file-created`. The value is normally defined by the implementer.


--

*`event.outcome`*::
+
--
type: keyword

example: success

The outcome of the event.
If the event describes an action, this fields contains the outcome of that action. Examples outcomes are `success` and `failure`. Warning: In future versions of ECS, we plan to provide a list of acceptable values for this field, please use with caution.


--

*`event.type`*::
+
--
type: keyword

Reserved for future usage.
Please avoid using this field for user data.


--

*`event.module`*::
+
--
type: keyword

example: mysql

Name of the module this data is coming from.
This information is coming from the modules used in Beats or Logstash.


--

*`event.dataset`*::
+
--
type: keyword

example: stats

Name of the dataset.
The concept of a `dataset` (fileset / metricset) is used in Beats as a subset of modules. It contains the information which is currently stored in metricset.name and metricset.module or fileset.name.


--

*`event.severity`*::
+
--
type: long

example: 7

Severity describes the severity of the event. What the different severity values mean can very different between use cases. It's up to the implementer to make sure severities are consistent across events.


--

*`event.original`*::
+
--
type: keyword

example: Sep 19 08:26:10 host CEF:0&#124;Security&#124; threatmanager&#124;1.0&#124;100&#124; worm successfully stopped&#124;10&#124;src=10.0.0.1 dst=2.1.2.2spt=1232

Raw text message of entire event. Used to demonstrate log integrity.
This field is not indexed and doc_values are disabled. It cannot be searched, but it can be retrieved from `_source`.


Field is not indexed.

--

*`event.hash`*::
+
--
type: keyword

example: 123456789012345678901234567890ABCD

Hash (perhaps logstash fingerprint) of raw field to be able to demonstrate log integrity.


--

*`event.duration`*::
+
--
type: long

Duration of the event in nanoseconds.
If event.start and event.end are known this value should be the difference between the end and start time.


--

*`event.timezone`*::
+
--
type: keyword

This field should be populated when the event's timestamp does not include timezone information already (e.g. default Syslog timestamps). It's optional otherwise.
Acceptable timezone formats are: a canonical ID (e.g. ""Europe/Amsterdam""), abbreviated (e.g. ""EST"") or an HH:mm differential (e.g. ""-05:00"").


--

*`event.created`*::
+
--
type: date

event.created contains the date when the event was created.
This timestamp is distinct from @timestamp in that @timestamp contains the processed timestamp. For logs these two timestamps can be different as the timestamp in the log line and when the event is read for example by Filebeat are not identical. `@timestamp` must contain the timestamp extracted from the log line, event.created when the log line is read. The same could apply to package capturing where @timestamp contains the timestamp extracted from the network package and event.created when the event was created.
In case the two timestamps are identical, @timestamp should be used.


--

*`event.start`*::
+
--
type: date

event.start contains the date when the event started or when the activity was first observed.


--

*`event.end`*::
+
--
type: date

event.end contains the date when the event ended or when the activity was last observed.


--

*`event.risk_score`*::
+
--
type: float

Risk score or priority of the event (e.g. security solutions). Use your system's original value here.


--

*`event.risk_score_norm`*::
+
--
type: float

Normalized risk score or priority of the event, on a scale of 0 to 100.
This is mainly useful if you use more than one system that assigns risk scores, and you want to see a normalized value across all systems.


--

[float]
== file fields

A file is defined as a set of information that has been created on, or has existed on a filesystem. File objects can be associated with host events, network events, and/or file events (e.g., those produced by File Integrity Monitoring [FIM] products or services). File fields provide details about the affected file associated with the event or metric.



*`file.path`*::
+
--
type: keyword

Path to the file.

--

*`file.target_path`*::
+
--
type: keyword

Target path for symlinks.

--

*`file.extension`*::
+
--
type: keyword

example: png

File extension.
This should allow easy filtering by file extensions.


--

*`file.type`*::
+
--
type: keyword

File type (file, dir, or symlink).

--

*`file.device`*::
+
--
type: keyword

Device that is the source of the file.

--

*`file.inode`*::
+
--
type: keyword

Inode representing the file in the filesystem.

--

*`file.uid`*::
+
--
type: keyword

The user ID (UID) or security identifier (SID) of the file owner.


--

*`file.owner`*::
+
--
type: keyword

File owner's username.

--

*`file.gid`*::
+
--
type: keyword

Primary group ID (GID) of the file.

--

*`file.group`*::
+
--
type: keyword

Primary group name of the file.

--

*`file.mode`*::
+
--
type: keyword

example: 416

Mode of the file in octal representation.

--

*`file.size`*::
+
--
type: long

File size in bytes (field is only added when `type` is `file`).

--

*`file.mtime`*::
+
--
type: date

Last time file content was modified.

--

*`file.ctime`*::
+
--
type: date

Last time file metadata changed.

--

[float]
== group fields

The group fields are meant to represent groups that are relevant to the event.



*`group.id`*::
+
--
type: keyword

Unique identifier for the group on the system/platform.


--

*`group.name`*::
+
--
type: keyword

Name of the group.


--

[float]
== host fields

A host is defined as a general computing instance. ECS host.* fields should be populated with details about the host on which the event happened, or on which the measurement was taken. Host types include hardware, virtual machines, Docker containers, and Kubernetes nodes.



*`host.hostname`*::
+
--
type: keyword

Hostname of the host.
It normally contains what the `hostname` command returns on the host machine.


--

*`host.name`*::
+
--
type: keyword

Name of the host.
It can contain what `hostname` returns on Unix systems, the fully qualified domain name, or a name specified by the user. The sender decides which value to use.


--

*`host.id`*::
+
--
type: keyword

Unique host id.
As hostname is not always unique, use values that are meaningful in your environment.
Example: The current usage of `beat.name`.


--

*`host.ip`*::
+
--
type: ip

Host ip address.


--

*`host.mac`*::
+
--
type: keyword

Host mac address.


--

*`host.type`*::
+
--
type: keyword

Type of host.
For Cloud providers this can be the machine type like `t2.medium`. If vm, this could be the container, for example, or other information meaningful in your environment.


--

*`host.architecture`*::
+
--
type: keyword

example: x86_64

Operating system architecture.


--

[float]
== os fields

The OS fields contain information about the operating system.



*`host.os.platform`*::
+
--
type: keyword

example: darwin

Operating system platform (such centos, ubuntu, windows).


--

*`host.os.name`*::
+
--
type: keyword

example: Mac OS X

Operating system name.


--

*`host.os.family`*::
+
--
type: keyword

example: debian

OS family (such as redhat, debian, freebsd, windows).


--

*`host.os.version`*::
+
--
type: keyword

example: 10.12.6-rc2

Operating system version as a raw string.


--

*`host.os.kernel`*::
+
--
type: keyword

example: 4.4.0-112-generic

Operating system kernel version as a raw string.


--

[float]
== geo fields

Geo fields can carry data about a specific location related to an event or geo information derived from an IP field.



*`host.geo.location`*::
+
--
type: geo_point

example: { ""lon"": -73.614830, ""lat"": 45.505918 }

Longitude and latitude.


--

*`host.geo.continent_name`*::
+
--
type: keyword

example: North America

Name of the continent.


--

*`host.geo.country_name`*::
+
--
type: keyword

example: Canada

Country name.


--

*`host.geo.region_name`*::
+
--
type: keyword

example: Quebec

Region name.


--

*`host.geo.city_name`*::
+
--
type: keyword

example: Montreal

City name.


--

*`host.geo.country_iso_code`*::
+
--
type: keyword

example: CA

Country ISO code.


--

*`host.geo.region_iso_code`*::
+
--
type: keyword

example: CA-QC

Region ISO code.


--

*`host.geo.name`*::
+
--
type: keyword

example: boston-dc

User-defined description of a location, at the level of granularity they care about.
Could be the name of their data centers, the floor number, if this describes a local physical entity, city names.
Not typically used in automated geolocation.


--

[float]
== http fields

Fields related to HTTP activity.



*`http.request.method`*::
+
--
type: keyword

example: GET, POST, PUT

Http request method.


--

*`http.request.referrer`*::
+
--
type: keyword

example: https://blog.example.com/

Referrer for this HTTP request.


--

*`http.response.status_code`*::
+
--
type: long

example: 404

Http response status code.


--

*`http.response.body`*::
+
--
type: keyword

example: Hello world

The full http response body.


--

*`http.version`*::
+
--
type: keyword

example: 1.1

Http version.


--

[float]
== log fields

Fields which are specific to log events.



*`log.level`*::
+
--
type: keyword

example: ERR

Log level of the log event.
Some examples are `WARN`, `ERR`, `INFO`.


--

*`log.original`*::
+
--
type: keyword

example: Sep 19 08:26:10 localhost My log


This is the original log message and contains the full log message before splitting it up in multiple parts.
In contrast to the `message` field which can contain an extracted part of the log message, this field contains the original, full log message. It can have already some modifications applied like encoding or new lines removed to clean up the log message.
This field is not indexed and doc_values are disabled so it can't be queried but the value can be retrieved from `_source`.


Field is not indexed.

--

[float]
== network fields

The network is defined as the communication path over which a host or network event happens. The network.* fields should be populated with details about the network activity associated with an event.



*`network.name`*::
+
--
type: keyword

example: Guest Wifi

Name given by operators to sections of their network.


--

*`network.type`*::
+
--
type: keyword

example: IPv4

In the OSI Model this would be the Network Layer. IPv4, IPv6, IPSec, PIM, etc


--

*`network.iana_number`*::
+
--
type: keyword

example: 6

IANA Protocol Number (https://www.iana.org/assignments/protocol-numbers/protocol-numbers.xhtml). Standardized list of protocols. This aligns well with NetFlow and sFlow related logs which use the IANA Protocol Number.


--

*`network.transport`*::
+
--
type: keyword

example: TCP

Same as network.iana_number, but instead using the Keyword name of the transport layer (UDP, TCP, IPv6-ICMP, etc.)


--

*`network.application`*::
+
--
type: keyword

example: AIM

A name given to an application. This can be arbitrarily assigned for things like microservices, but also apply to things like skype, icq, facebook, twitter. This would be used in situations where the vendor or service can be decoded such as from the source/dest IP owners, ports, or wire format.


--

*`network.protocol`*::
+
--
type: keyword

example: http

L7 Network protocol name. ex. http, lumberjack, transport protocol


--

*`network.direction`*::
+
--
type: keyword

example: inbound

Direction of the network traffic.
Recommended values are:
  * inbound
  * outbound
  * internal
  * external
  * unknown

When mapping events from a host-based monitoring context, populate this field from the host's point of view.
When mapping events from a network or perimeter-based monitoring context, populate this field from the point of view of your network perimeter.


--

*`network.forwarded_ip`*::
+
--
type: ip

example: 192.1.1.2

Host IP address when the source IP address is the proxy.


--

*`network.community_id`*::
+
--
type: keyword

example: 1:hO+sN4H+MG5MY/8hIrXPqc4ZQz0=

A hash of source and destination IPs and ports, as well as the protocol used in a communication. This is a tool-agnostic standard to identify flows.
Learn more at https://github.com/corelight/community-id-spec.


--

*`network.bytes`*::
+
--
type: long

example: 368

Total bytes transferred in both directions.
If `source.bytes` and `destination.bytes` are known, `network.bytes` is their sum.


--

*`network.packets`*::
+
--
type: long

example: 24

Total packets transferred in both directions.
If `source.packets` and `destination.packets` are known, `network.packets` is their sum.


--

[float]
== observer fields

An observer is defined as a special network, security, or application device used to detect, observe, or create network, security, or application-related events and metrics. This could be a custom hardware appliance or a server that has been configured to run special network, security, or application software. Examples include firewalls, intrusion detection/prevention systems, network monitoring sensors, web application firewalls, data loss prevention systems, and APM servers. The observer.* fields shall be populated with details of the system, if any, that detects, observes and/or creates a network, security, or application event or metric. Message queues and ETL components used in processing events or metrics are not considered observers in ECS.  



*`observer.mac`*::
+
--
type: keyword

MAC address of the observer


--

*`observer.ip`*::
+
--
type: ip

IP address of the observer.


--

*`observer.hostname`*::
+
--
type: keyword

Hostname of the observer.


--

*`observer.vendor`*::
+
--
type: keyword

observer vendor information.


--

*`observer.version`*::
+
--
type: keyword

Observer version.


--

*`observer.serial_number`*::
+
--
type: keyword

Observer serial number.


--

*`observer.type`*::
+
--
type: keyword

example: firewall

The type of the observer the data is coming from.
There is no predefined list of observer types. Some examples are `forwarder`, `firewall`, `ids`, `ips`, `proxy`, `poller`, `sensor`, `APM server`.


--

[float]
== os fields

The OS fields contain information about the operating system.



*`observer.os.platform`*::
+
--
type: keyword

example: darwin

Operating system platform (such centos, ubuntu, windows).


--

*`observer.os.name`*::
+
--
type: keyword

example: Mac OS X

Operating system name.


--

*`observer.os.family`*::
+
--
type: keyword

example: debian

OS family (such as redhat, debian, freebsd, windows).


--

*`observer.os.version`*::
+
--
type: keyword

example: 10.12.6-rc2

Operating system version as a raw string.


--

*`observer.os.kernel`*::
+
--
type: keyword

example: 4.4.0-112-generic

Operating system kernel version as a raw string.


--

[float]
== geo fields

Geo fields can carry data about a specific location related to an event or geo information derived from an IP field.



*`observer.geo.location`*::
+
--
type: geo_point

example: { ""lon"": -73.614830, ""lat"": 45.505918 }

Longitude and latitude.


--

*`observer.geo.continent_name`*::
+
--
type: keyword

example: North America

Name of the continent.


--

*`observer.geo.country_name`*::
+
--
type: keyword

example: Canada

Country name.


--

*`observer.geo.region_name`*::
+
--
type: keyword

example: Quebec

Region name.


--

*`observer.geo.city_name`*::
+
--
type: keyword

example: Montreal

City name.


--

*`observer.geo.country_iso_code`*::
+
--
type: keyword

example: CA

Country ISO code.


--

*`observer.geo.region_iso_code`*::
+
--
type: keyword

example: CA-QC

Region ISO code.


--

*`observer.geo.name`*::
+
--
type: keyword

example: boston-dc

User-defined description of a location, at the level of granularity they care about.
Could be the name of their data centers, the floor number, if this describes a local physical entity, city names.
Not typically used in automated geolocation.


--

[float]
== organization fields

The organization fields enrich data with information about the company or entity the data is associated with. These fields help you arrange or filter data stored in an index by one or multiple organizations.



*`organization.name`*::
+
--
type: keyword

Organization name.


--

*`organization.id`*::
+
--
type: keyword

Unique identifier for the organization.


--

[float]
== os fields

The OS fields contain information about the operating system.



*`os.platform`*::
+
--
type: keyword

example: darwin

Operating system platform (such centos, ubuntu, windows).


--

*`os.name`*::
+
--
type: keyword

example: Mac OS X

Operating system name.


--

*`os.family`*::
+
--
type: keyword

example: debian

OS family (such as redhat, debian, freebsd, windows).


--

*`os.version`*::
+
--
type: keyword

example: 10.12.6-rc2

Operating system version as a raw string.


--

*`os.kernel`*::
+
--
type: keyword

example: 4.4.0-112-generic

Operating system kernel version as a raw string.


--

[float]
== process fields

These fields contain information about a process. These fields can help you correlate metrics information with a process id/name from a log message.  The `process.pid` often stays in the metric itself and is copied to the global field for correlation.



*`process.pid`*::
+
--
type: long

Process id.


--

*`process.name`*::
+
--
type: keyword

example: ssh

Process name.
Sometimes called program name or similar.


--

*`process.ppid`*::
+
--
type: long

Process parent id.


--

*`process.args`*::
+
--
type: keyword

example: ['ssh', '-l', 'user', '10.0.0.16']

Process arguments.
May be filtered to protect sensitive information.


--

*`process.executable`*::
+
--
type: keyword

example: /usr/bin/ssh

Absolute path to the process executable.


--

*`process.title`*::
+
--
type: keyword

Process title.
The proctitle, some times the same as process name. Can also be different: for example a browser setting its title to the web page currently opened.


--

*`process.thread.id`*::
+
--
type: long

example: 4242

Thread ID.


--

*`process.start`*::
+
--
type: date

example: 2016-05-23T08:05:34.853Z

The time the process started.


--

*`process.working_directory`*::
+
--
type: keyword

example: /home/alice

The working directory of the process.


--

[float]
== related fields

This field set is meant to facilitate pivoting around a piece of data. Some pieces of information can be seen in many places in ECS. To facilitate searching for them, append values to their corresponding field in `related.`. A concrete example is IP addresses, which can be under host, observer, source, destination, client, server, and network.forwarded_ip. If you append all IPs to `related.ip`, you can then search for a given IP trivially, no matter where it appeared, by querying `related.ip:a.b.c.d`.



*`related.ip`*::
+
--
type: ip

All of the IPs seen on your event.


--

[float]
== server fields

A Server is defined as the responder in a network connection for events regarding sessions, connections, or bidirectional flow records. For TCP events, the server is the receiver of the initial SYN packet(s) of the TCP connection. For other protocols, the server is generally the responder in the network transaction. Some systems actually use the term ""responder"" to refer the server in TCP connections. The server fields describe details about the system acting as the server in the network event. Server fields are usually populated in conjunction with client fields. Server fields are generally not populated for packet-level events.



*`server.ip`*::
+
--
type: ip

IP address of the server.
Can be one or multiple IPv4 or IPv6 addresses.


--

*`server.port`*::
+
--
type: long

Port of the server.


--

*`server.mac`*::
+
--
type: keyword

MAC address of the server.


--

*`server.domain`*::
+
--
type: keyword

Server domain.


--

*`server.bytes`*::
+
--
type: long

example: 184

Bytes sent from the server to the client.


--

*`server.packets`*::
+
--
type: long

example: 12

Packets sent from the server to the client.


--

[float]
== geo fields

Geo fields can carry data about a specific location related to an event or geo information derived from an IP field.



*`server.geo.location`*::
+
--
type: geo_point

example: { ""lon"": -73.614830, ""lat"": 45.505918 }

Longitude and latitude.


--

*`server.geo.continent_name`*::
+
--
type: keyword

example: North America

Name of the continent.


--

*`server.geo.country_name`*::
+
--
type: keyword

example: Canada

Country name.


--

*`server.geo.region_name`*::
+
--
type: keyword

example: Quebec

Region name.


--

*`server.geo.city_name`*::
+
--
type: keyword

example: Montreal

City name.


--

*`server.geo.country_iso_code`*::
+
--
type: keyword

example: CA

Country ISO code.


--

*`server.geo.region_iso_code`*::
+
--
type: keyword

example: CA-QC

Region ISO code.


--

*`server.geo.name`*::
+
--
type: keyword

example: boston-dc

User-defined description of a location, at the level of granularity they care about.
Could be the name of their data centers, the floor number, if this describes a local physical entity, city names.
Not typically used in automated geolocation.


--

[float]
== service fields

The service fields describe the service for or from which the data was collected. These fields help you find and correlate logs for a specific service and version.



*`service.id`*::
+
--
type: keyword

example: d37e5ebfe0ae6c4972dbe9f0174a1637bb8247f6

Unique identifier of the running service.
This id should uniquely identify this service. This makes it possible to correlate logs and metrics for one specific service.
Example: If you are experiencing issues with one redis instance, you can filter on that id to see metrics and logs for that single instance.


--

*`service.name`*::
+
--
type: keyword

example: elasticsearch-metrics

Name of the service data is collected from.
The name of the service is normally user given. This allows if two instances of the same service are running on the same machine they can be differentiated by the `service.name`.
Also it allows for distributed services that run on multiple hosts to correlate the related instances based on the name.
In the case of Elasticsearch the service.name could contain the cluster name. For Beats the service.name is by default a copy of the `service.type` field if no name is specified.


--

*`service.type`*::
+
--
type: keyword

example: elasticsearch

The type of the service data is collected from.
The type can be used to group and correlate logs and metrics from one service type.
Example: If logs or metrics are collected from Elasticsearch, `service.type` would be `elasticsearch`.


--

*`service.state`*::
+
--
type: keyword

Current state of the service.


--

*`service.version`*::
+
--
type: keyword

example: 3.2.4

Version of the service the data was collected from.
This allows to look at a data set only for a specific version of a service.


--

*`service.ephemeral_id`*::
+
--
type: keyword

example: 8a4f500f

Ephemeral identifier of this service (if one exists).
This id normally changes across restarts, but `service.id` does not.


--

[float]
== source fields

Source fields describe details about the source of a packet/event. Source fields are usually populated in conjunction with destination fields.



*`source.ip`*::
+
--
type: ip

IP address of the source.
Can be one or multiple IPv4 or IPv6 addresses.


--

*`source.port`*::
+
--
type: long

Port of the source.


--

*`source.mac`*::
+
--
type: keyword

MAC address of the source.


--

*`source.domain`*::
+
--
type: keyword

Source domain.


--

*`source.bytes`*::
+
--
type: long

example: 184

Bytes sent from the source to the destination.


--

*`source.packets`*::
+
--
type: long

example: 12

Packets sent from the source to the destination.


--

[float]
== geo fields

Geo fields can carry data about a specific location related to an event or geo information derived from an IP field.



*`source.geo.location`*::
+
--
type: geo_point

example: { ""lon"": -73.614830, ""lat"": 45.505918 }

Longitude and latitude.


--

*`source.geo.continent_name`*::
+
--
type: keyword

example: North America

Name of the continent.


--

*`source.geo.country_name`*::
+
--
type: keyword

example: Canada

Country name.


--

*`source.geo.region_name`*::
+
--
type: keyword

example: Quebec

Region name.


--

*`source.geo.city_name`*::
+
--
type: keyword

example: Montreal

City name.


--

*`source.geo.country_iso_code`*::
+
--
type: keyword

example: CA

Country ISO code.


--

*`source.geo.region_iso_code`*::
+
--
type: keyword

example: CA-QC

Region ISO code.


--

*`source.geo.name`*::
+
--
type: keyword

example: boston-dc

User-defined description of a location, at the level of granularity they care about.
Could be the name of their data centers, the floor number, if this describes a local physical entity, city names.
Not typically used in automated geolocation.


--

[float]
== url fields

URL fields provide a complete URL, with scheme, host, and path.



*`url.original`*::
+
--
type: keyword

example: https://www.elastic.co:443/search?q=elasticsearch#top or /search?q=elasticsearch


Unmodified original url as seen in the event source.
Note that in network monitoring, the observed URL may be a full URL, whereas in access logs, the URL is often just represented as a path.
This field is meant to represent the URL as it was observed, complete or not.


--

*`url.full`*::
+
--
type: keyword

example: https://www.elastic.co:443/search?q=elasticsearch#top

If full URLs are important to your use case, they should be stored in `url.full`, whether this field is reconstructed or present in the event source.


--

*`url.scheme`*::
+
--
type: keyword

example: https

Scheme of the request, such as ""https"".
Note: The `:` is not part of the scheme.


--

*`url.domain`*::
+
--
type: keyword

example: www.elastic.co

Domain of the request, such as ""www.elastic.co"".
In some cases a URL may refer to an IP and/or port directly, without a domain name. In this case, the IP address would go to the `domain` field.


--

*`url.port`*::
+
--
type: integer

example: 443

Port of the request, such as 443.


--

*`url.path`*::
+
--
type: keyword

Path of the request, such as ""/search"".


--

*`url.query`*::
+
--
type: keyword

The query field describes the query string of the request, such as ""q=elasticsearch"".
The `?` is excluded from the query string. If a URL contains no `?`, there is no query field. If there is a `?` but no query, the query field exists with an empty string. The `exists` query can be used to differentiate between the two cases.


--

*`url.fragment`*::
+
--
type: keyword

Portion of the url after the `#`, such as ""top"".
The `#` is not part of the fragment.


--

*`url.username`*::
+
--
type: keyword

Username of the request.


--

*`url.password`*::
+
--
type: keyword

Password of the request.


--

[float]
== user fields

The user fields describe information about the user that is relevant to  the event. Fields can have one entry or multiple entries. If a user has more than one id, provide an array that includes all of them.



*`user.id`*::
+
--
type: keyword

One or multiple unique identifiers of the user.


--

*`user.name`*::
+
--
type: keyword

example: albert

Short name or login of the user.


--

*`user.full_name`*::
+
--
type: keyword

example: Albert Einstein

User's full name, if available.


--

*`user.email`*::
+
--
type: keyword

User email address.


--

*`user.hash`*::
+
--
type: keyword

Unique user hash to correlate information for a user in anonymized form.
Useful if `user.id` or `user.name` contain confidential information and cannot be used.


--

*`user.group`*::
+
--
type: keyword

Group the user is a part of. This field can contain a list of groups, if necessary.


--

[float]
== user_agent fields

The user_agent fields normally come from a browser request. They often show up in web service logs coming from the parsed user agent string.



*`user_agent.original`*::
+
--
type: keyword

example: Mozilla/5.0 (iPhone; CPU iPhone OS 12_1 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/12.0 Mobile/15E148 Safari/604.1

Unparsed version of the user_agent.


Field is not indexed.

--

*`user_agent.name`*::
+
--
type: keyword

example: Safari

Name of the user agent.


--

*`user_agent.version`*::
+
--
type: keyword

example: 12.0

Version of the user agent.


--

*`user_agent.device.name`*::
+
--
type: keyword

example: iPhone

Name of the device.


--

[float]
== os fields

The OS fields contain information about the operating system.



*`user_agent.os.platform`*::
+
--
type: keyword

example: darwin

Operating system platform (such centos, ubuntu, windows).


--

*`user_agent.os.name`*::
+
--
type: keyword

example: Mac OS X

Operating system name.


--

*`user_agent.os.family`*::
+
--
type: keyword

example: debian

OS family (such as redhat, debian, freebsd, windows).


--

*`user_agent.os.version`*::
+
--
type: keyword

example: 10.12.6-rc2

Operating system version as a raw string.


--

*`user_agent.os.kernel`*::
+
--
type: keyword

example: 4.4.0-112-generic

Operating system kernel version as a raw string.


--

*`beat.name`*::
+
--
type: alias

alias to: agent.type

--

*`beat.hostname`*::
+
--
type: alias

alias to: agent.hostname

--

*`agent.hostname`*::
+
--
type: keyword

Hostname of the agent.


--

*`user_agent.patch`*::
+
--
type: keyword

Patch version of the user agent.


--

*`user_agent.minor`*::
+
--
type: keyword

Minor version of the user agent.


--

*`user_agent.major`*::
+
--
type: keyword

Major version of the user agent.


--

*`user_agent.device`*::
+
--
type: keyword

Name of the physical device.


--

*`user_agent.os.major`*::
+
--
type: long

Major version of the operating system.


--

*`user_agent.os.minor`*::
+
--
type: long

Minor version of the operating system.


--

*`url.hostname`*::
+
--
type: keyword

Hostname of the request, such as ""elastic.co"".


--

[[exported-fields-eventlog]]
== Event log record fields

Contains data from a Windows event log record.



*`activity_id`*::
+
--
type: keyword

required: False

A globally unique identifier that identifies the current activity. The events that are published with this identifier are part of the same activity.


--

*`computer_name`*::
+
--
type: keyword

required: True

The name of the computer that generated the record. When using Windows event forwarding, this name can differ from the `beat.hostname`.


--

*`event_data`*::
+
--
type: object

required: False

The event-specific data. This field is mutually exclusive with `user_data`. If you are capturing event data on versions prior to Windows Vista, the parameters in `event_data` are named `param1`, `param2`, and so on, because event log parameters are unnamed in earlier versions of Windows.


--

*`event_id`*::
+
--
type: long

required: True

The event identifier. The value is specific to the source of the event.


--

*`keywords`*::
+
--
type: keyword

required: False

The keywords are used to classify an event.


--

*`log_name`*::
+
--
type: keyword

required: True

The name of the event log from which this record was read. This value is one of the names from the `event_logs` collection in the configuration.


--

*`level`*::
+
--
type: keyword

required: False

The level of the event. There are five levels of events that can be logged: Success, Information, Warning, Error, Audit Success, and Audit Failure.


--

*`message`*::
+
--
type: text

required: False

The message from the event log record.


--

*`message_error`*::
+
--
type: keyword

required: False

The error that occurred while reading and formatting the message from the log.


--

*`record_number`*::
+
--
type: keyword

required: True

The record number of the event log record. The first record written to an event log is record number 1, and other records are numbered sequentially. If the record number reaches the maximum value (2^32^ for the Event Logging API and 2^64^ for the Windows Event Log API), the next record number will be 0.


--

*`related_activity_id`*::
+
--
type: keyword

required: False

A globally unique identifier that identifies the activity to which control was transferred to. The related events would then have this identifier as their `activity_id` identifier.


--

*`opcode`*::
+
--
type: keyword

required: False

The opcode defined in the event. Task and opcode are typically used to identify the location in the application from where the event was logged.


--

*`provider_guid`*::
+
--
type: keyword

required: False

A globally unique identifier that identifies the provider that logged the event.


--

*`process_id`*::
+
--
type: long

required: False

The process_id identifies the process that generated the event.


--

*`source_name`*::
+
--
type: keyword

required: True

The source of the event log record (the application or service that logged the record).


--

*`task`*::
+
--
type: keyword

required: False

The task defined in the event. Task and opcode are typically used to identify the location in the application from where the event was logged. The category used by the Event Logging API (on pre Windows Vista operating systems) is written to this field.


--

*`thread_id`*::
+
--
type: long

required: False

The thread_id identifies the thread that generated the event.


--

*`user_data`*::
+
--
type: object

required: False

The event specific data. This field is mutually exclusive with `event_data`.


--

*`user.identifier`*::
+
--
type: keyword

example: S-1-5-21-3541430928-2051711210-1391384369-1001

required: False

The Windows security identifier (SID) of the account associated with this event.

If Winlogbeat cannot resolve the SID to a name, then the `user.name`, `user.domain`, and `user.type` fields will be omitted from the event. If you discover Winlogbeat not resolving SIDs, review the log for clues as to what the problem may be.


--

*`user.domain`*::
+
--
type: keyword

required: False

The domain that the account associated with this event is a member of.


--

*`user.type`*::
+
--
type: keyword

required: False

The type of account associated with this event.


--

*`version`*::
+
--
type: long

required: False

The version number of the event's definition.

--

*`xml`*::
+
--
type: text

required: False

The raw XML representation of the event obtained from Windows. This field is only available on operating systems supporting the Windows Event Log API (Microsoft Windows Vista and newer). This field is not included by default and must be enabled by setting `include_xml: true` as a configuration option for an individual event log.

The XML representation of the event is useful for troubleshooting purposes. The data in the fields reported by Winlogbeat can be compared to the data in the XML to diagnose problems.


--

[[exported-fields-host-processor]]
== Host fields

Info collected for the host machine.


[[exported-fields-kubernetes-processor]]
== Kubernetes fields

Kubernetes metadata added by the kubernetes processor




*`kubernetes.pod.name`*::
+
--
type: keyword

Kubernetes pod name


--

*`kubernetes.pod.uid`*::
+
--
type: keyword

Kubernetes Pod UID


--

*`kubernetes.namespace`*::
+
--
type: keyword

Kubernetes namespace


--

*`kubernetes.node.name`*::
+
--
type: keyword

Kubernetes node name


--

*`kubernetes.labels`*::
+
--
type: object

Kubernetes labels map


--

*`kubernetes.annotations`*::
+
--
type: object

Kubernetes annotations map


--

*`kubernetes.container.name`*::
+
--
type: keyword

Kubernetes container name


--

*`kubernetes.container.image`*::
+
--
type: keyword

Kubernetes container image


--

",12452,True,2981.1415814330894,median
"= ZeroToOne - Developer Guide
:site-section: DeveloperGuide
:toc:
:toc-title:
:toc-placement: preamble
:sectnums:
:imagesDir: images/
:stylesDir: stylesheets
:xrefstyle: full
ifdef::env-github[]
:tip-caption: :bulb:
:note-caption: :information_source:
:warning-caption: :warning:
endif::[]
:repoURL: https://github.com/AY1920S2-CS2103T-W16-2/main
:codeURL: {repoURL}/tree/master/

By: `Team AY1920S2 W16-2`      Since: `Feb 2020`

== Setting up

Refer to the guide <<SettingUp#, here>>.

== Design

[[Design-Architecture]]
=== Architecture [Wong Chi Shan]

.Architecture Diagram
image::developer-guide/common/ArchitectureDiagram.png[]

The *_Architecture Diagram_* given above explains the high-level design of the App. Given below is a quick overview of each component.

`Main` has two classes called link:{codeURL}/src/main/java/seedu/zerotoone/Main.java[`Main`] and link:{codeURL}/src/main/java/seedu/zerotoone/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::developer-guide/common/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 `exercise delete 1`.

.Component interactions for `exercise delete 1` command
image::developer-guide/common/ArchitectureSequenceDiagram.png[]

The sections below give more details of each component.

[[Design-Main]]
=== Main Component [Aloysius Chan]
.Structure of the Main Component
image::developer-guide/common/MainClassDiagram.png[]

*API* : link:{codeURL}/src/main/java/seedu/zerotoone/Main.java[`Main.java`]

The `Main` class consists of the `SplashScreen` and the `MainApp`.

When the app starts up, `Main#main` is called. This sets the `Preloader` of the `Application` to be `SplashScreen`. Thereafter, it launches `MainApp`.

During the GUI start up process, the `SplashScreen` will first load on a `Thread`. In the meantime, `MainApp#init` will run. Once `MainApp#init` completes, and just as `MainApp#start` is about to run, `MainApp` will send a `Preloader.StateChangeNotification` to `SplashScreen` to close its window. After that, `UiManager#start` is called, which creates the view for the main application.

[[Design-Ui]]
=== UI Component [Aloysius Chan]

.Structure of the UI Component
image::developer-guide/common/UiClassDiagram.png[]

*API* : link:{codeURL}/src/main/java/seedu/zerotoone/ui/Ui.java[`Ui.java`]

The UI consists of a `MainWindow` that is made up of a `CommandBox`, `ResultDisplay` and other panels. 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:{codeURL}/src/main/java/seedu/zerotoone/ui/MainWindow.java[`MainWindow`] is specified in link:{codeURL}/src/main/resources/view/MainWindow.fxml[`MainWindow.fxml`]

The `UI` component executes user commands using the `Logic` component.

For more information about each component, check out the 'Implementation' section.

[[Design-Logic]]
=== Logic Component [Aloysius Chan]

[[fig-LogicClassDiagram]]
.Structure of the Logic Component
image::developer-guide/common/LogicClassDiagram.png[]

*API* :
link:{codeURL}/src/main/java/seedu/zerotoone/logic/Logic.java[`Logic.java`]

. `Logic` uses the `ParserManager` class to parse the user command
. The `ParserManager` creates and returns a `Command` object
. The `Command` object is executed by the `LogicManager`
. The command execution can affect the `Model` (e.g. adding a exercise).
. 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 the list of workouts.

Inside the `Logic` package, there are some utility classes such as the `ArgumentTokenizer`. It is responsible for tokenizing an input and returning an `ArgumentMultimap`, which can be used to get the value of a particular `Prefix`.

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::developer-guide/common/DeleteSequenceDiagram.png[]

NOTE: The lifeline for `ExerciseCommandParser` and `DeleteCommandParser` should end at the destroy marker (X) but due to a limitation of PlantUML, the lifeline reaches the end of diagram.

For more information about each component, check out the 'Implementation' section.

[[Design-Model]]
=== Model Component [Aloysius Chan]

.Structure of the Model Component
image::developer-guide/common/ModelClassDiagram.png[]

*API* : link:{codeURL}/src/main/java/seedu/zerotoone/model/Model.java[`Model.java`]

The `Model`:

* stores a `UserPref` object that represents the user's preferences.
* stores an `ExerciseList` that represents the list of exercises.
* stores a `WorkoutList` that represents the list of workouts available.
* stores a `ScheduleList` that represents the list of upcoming schedules.
* stores a `LogList` that represents the list of completed data.
* stores a `TimerList` that represents a time delta in seconds.
* stores an `Optional` `OngoingWorkout` that may contain a session, if started.
* exposes an unmodifiable `ObservableList<Exercise>`, `ObservableList<Workout>`, `ObservableList<ScheduledWorkout>`, `ObservableList<Log>`, `ObservableList<OngoingSet>`, and `ObservableList<Integer>` (time delta) 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 changes.
* does not depend on any of the other components.

For more information about each component, check out the 'Implementation' section.

[[Design-Storage]]
=== Storage Component [Aloysius Chan]

.Structure of the Storage Component
image::developer-guide/common/StorageClassDiagram.png[]

*API* : link:{codeURL}/src/main/java/seedu/zerotoone/storage/Storage.java[`Storage.java`]

The `Storage` component is resonsible for the persistent storage of the application. It can save these class in JSON format and read it back:

* `UserPrefs`
* `Exercise`
* `Workout`
* `Schedule`
* `Log`

For more information about each component, check out the 'Implementation' section.

[[Design-Commons]]
=== Common Classes

Classes used by multiple components are in the `seedu.zerotoone.commons` package.

== Implementation

This section describes some noteworthy details on how each features are implemented.

// tag::session[]

=== Session (Home) [Gabriel Yeo]
==== Implementation
The Session feature resides on the Home page and is comprised of `Start`, `Stop`, `Done`, and `Skip` commands.
`OngoingWorkout`, `OngoingSession`, `OngoingSet`, and `OngoingSetList` are models that are vital components of the feature.

The Session feature also seamlessly incorporates a functional timer. Timer functionality is found embedded in the session related functions in `ModelManager`.

The activity diagram below demonstrates the actions of a user with this feature.

.Session Feature Activity Diagram
image::developer-guide/session/StartStopActivityDiagram.png[]

Start depicts the start of a valid (non-zero sets remaining) workout session.
Upon depletion of all remaining sets, the `OngoingWorkout` automatically stops and produces a `CompletedWorkout` which is saved.
The only inputs the user is required to give throughout the session are `done` (corresponding to the yes of the conditional branch)
and `skip` (no of the conditional branch). `Stop` is optional.

This is a conscious design choice as elaborated in the next section.

---

The operations handling these actions are found in `OngoingWorkout`:

* `OngoingWorkout#skip()/OngoingWorkout#done()` -- removes and returns the next set and updates queue of remaining sets.
* `OngoingWorkout#finish()` -- creates and returns an immutable `CompletedWorkout` object for saving and logging.

Further operations are exposed in the `Model` interface as `Model#startSession()` and `Model#stopSession()`.

.Session related models
image::developer-guide/session/SessionModel.png[]

The above class diagram briefly depicts how the session related models (in `OngoingWorkout`) interact with surrounding classes.

The `OngoingWorkout` class has a dependency on `Workout`, which has been abstracted for clarity.

In turn, `CompletedWorkout` class has a dependency on `OngoingWorkout`.

`OngoingWorkout` objects are created at the start of a workout session, and can be thought of as 'converted' to `CompletedWorkout` objects at the end of a workout session. `Workout` and `CompletedWorkout` objects are immutable, hence the design choice for using an intermediary, stateful `OngoingWorkout` class.

---

The inner workings of the feature are briefly expounded below through a simple simulation.
`Arms Day` is a `Workout` with ID = `2` and consists of 2 sets of one exercise called `Bench Press`.


.Example Workout Session
image::developer-guide/session/sessionExample.png[]

Step 1. The user selects an existing `Workout` called `Arms Day` with ID = `2` and starts a session with `start 2`.

* `Logic` and `Parser` redirect control to `StartCommand#execute()` where an instance of `OngoingWorkout` is created with
the `Arms Day` object. The upcoming set of the next exercise is displayed for the user.

* The timer starts counting. This acts as a visual cue for the user that notifies the start of the workout and is essentially a once-off, superfluous action, since it's main purpose is to time rest between sets.

Step 2. The user completes the first set and types `done`.

* `DoneCommand#execute()` is invoked, which in turn calls `Model#done()` to obtain the last `CompletedSet` object to display on the UI, and statefully
updates the instance of `OngoingWorkout`.

* The rest timer resets to 00:00 and starts counting.

.DoneCommand sequence diagram
image::developer-guide/session/DoneCommandSequenceDiagram.png[]

* The sequence diagram above demonstrates the interaction between the Logic and Model of ZeroToOne.
For brevity, some inner details between `OngoingWorkout#done()` and the return of `cs` are omitted.

Step 3. After resting, the user fails the last and final set of `Bench Press` and types `skip`.

* `SkipCommand#execute()` is invoked. The process is almost identical to the above execution of `done` except this time the instance of `CompletedSet` is created with `isFinished` set to `false`.

* Since this is the final set of the session, `OngoingWorkout#hasSetLeft()`
returns false, and `OngoingWorkout#finish()` is called which creates and returns an immutable `CompletedWorkout` object. This object
is saved and passed on for use by the `Log` feature.

* The workout session is now complete, and the timer and UI is reset.

* The workout session can be viewed in the `Log` tab.

[Note] In the usual flow, the `stop` command is not used, and is reserved only for a premature ending of a
workout session, where all remaining sets are marked as incomplete.

==== Design Considerations
===== Aspect: Seamless user-first experience
* **Current Implementation:** Minimal commands and typing during an ongoing session. Timer functionality is completely automatic.
** Pros: Less interruption during actual exercising to enter commands.
** Cons: More experienced users are not able to have a more customizable workout.


===== Aspect: Beginner-friendly set order
* **Current Implementation:** Exercises and sets have fixed ordering based on their creation.
** Pros: Easier for new user to follow a workout session, less typing required during a workout session. Session has simple and predictable behaviour.
** Cons: Experienced users are not able to have an ad-hoc, customizable workout without creating a new workout with the specific order they want.

// end::session[]

// tag::exercise[]
=== Exercise [Aloysius Chan]
==== Overview
The Exercise feature forms the basic building block for the application. It allows users to CRUD exercises, which will then be used for the creation of workouts. The command is prefixed by the keyword `exercise`. Available commands are `create`, `edit`, `list`, `delete` and many more.

==== Implementation
The following portion will explain in-detail each component of the Exercise feature.

===== Model
.Exercise Model Structure
image::developer-guide/exercise/ExerciseModelClassDiagram.png[]

The figure above depicts the Model of the Exercise feature. Starting from the most primitive type:

. `NumReps` stores the number of repetitions a person has to complete for a particular exercise set
. `Weight` stores the weight in kg that a person has to complete for a particular exercise set
. `ExerciseSet` represents an exercise set that a person has to complete. Each `ExerciseSet` comprises of exactly 1 `NumReps` object and 1 `Weight` object
. `ExerciseName` stores the name of a particular exercise
. `Exercise` represents a collection of exercise sets that a person has to complete. Each `Exercise` will consists of exactly 1 `ExerciseName` object and any number of `ExerciseSet` (including zero)
. `UniqueExerciseList` represents a collection of `Exercise` objects. There can be any number of `Exercise` objects in `UniqueExerciseList`, but they must be unique.
. `ExerciseList` implements the interface `ReadOnlyExerciseList` that ensures that the outward-facing exercise list is unmodifiable by other modules. The `ExerciseList` object has exactly 1 `UniqueExerciseList` for storage purposes.
. `ExerciseList` is controlled by the `ModelManager`.

Do note that some of the `Exercise` objects in the `ExerciseList` are also referenced in the `WorkoutList`. For more information, refer to the `Workout` implementation.

===== Storage
.Exercise Storage Structure
image::developer-guide/exercise/ExerciseStorageClassDiagram.png[]

The Storage component provides the functionalities that enable the persistent storage of the model. Starting from the most primitive type:

. `JacksonExerciseSet` contains exactly two `String` objects, one for the number of repetitions and one for the weight. This class has a dependency to the `NumReps` and `Weight` model due to the `toModelType()` function. This function converts `JacksonExerciseSet` into the model's `ExerciseSet` so that it can be used in other parts of the application.
. `JacksonExercise` contains exactly one `String` object that represents the exercise name, and any number of `JacksonExerciseSet` objects. Similarly, it has a dependency to `ExerciseName`, `ExerciseSet` and `Exercise` object due to the `toModelType()` function.
. `JacksonExerciseList` is the persistent storage for the `ExerciseList` model, and it contains any number of `JacksonExercise` objects.
. `ExerciseListStorageManager` implements the `ExerciseListStorage` which provides certain functionalities required for the storage to work properly. The `ExerciseListStorageManager` is controlled by the `StorageManager`.

===== Logic - Commands
.Exercise Commands Structure
image::developer-guide/exercise/ExerciseCommandClassDiagram.png[]

The Exercise Commands package stores the business logic of the exercise feature. The commands are organised in a hierarchical fashion, in the order of precedence in a valid input. For example, `SetCommand` inherits from `ExerciseCommand` as the `set` comes after `exercise` in the input `exercise set`.

Each command contains a `COMMAND_WORD` which is a single word that is unique to the command. Each command also implements an `execute` method that represents the logic of the command. Instructions to control the model, storage and view are stored inside this method.

===== Logic - Parsers
.Exercise Parser Structure
image::developer-guide/exercise/ExerciseParserClassDiagram.png[]

The parsers are responsible for parsing a user input into a `Command` object. For the Exercise component, there are parsers for every command that accepts user arguments. For example, since `exercise list` does not take in any argument, there is no parser for the `ListCommand`. After parsing the user input, the parser will return `Command` object to the caller, which will execute the command via the `execute` method.

===== Sample Command Execution
This section will illustrate an example of an exercise command execution using the input `exercise create e/Bench Press`.

.Exercise's CreateCommand Sequence Diagram
image::developer-guide/exercise/CreateCommandSequenceDiagram.png[]

In this portion, we will trace the sequence diagram of the `exercise create` command to better understand the internals of the Exercise feature.

. The user enters the command `exercise create e/Bench Press`
. `LogicManager` will pass the command to the `ParserManager` for parsing
. `ParserManager` upon seeing that the command is prefixed by `exercise` creates a `ExerciseCommandParser`
. `ParserManager` then pass `create e/Bench Press` to `ExerciseCommandParser`
. `ExerciseCommandParser` upon seeing that the command is prefixed by `create` creates a `CreateCommandParser`
. `ExerciseCommandParser` then pass the argument `e/Bench Press` to `CreateCommandParser`
. `CreateCommandParser` then attempts to create an `ExerciseName` object using the `String` in the argument
. Using the `ExerciseName`, `CreateCommandParser` then create a `CreateCommand` object with the exercise name
. The `CreateCommand` is then passed back to the `LogicManager`
. `LogicManager` calls `c.execute()`
. `CreateCommand` will attempt to create an `Exercise` using the exercise name
. After creating the `Exercise` object, the `CreateCommand` will attempt to store the new exercise by calling the `addExercise` method of `Model`
. After the exercise is successfully added, a `CommandResult` object is created
. This result is then passed back to the `LogicManager` which will display the output on the GUI

===== Summary
.Editing Exercise Set Activity Diagram
image::developer-guide/exercise/EditSetActivityDiagram.png[]

At this point, you should have gather enough information to start developing the Exercise feature. As a summary, this is a sample Activity Diagram that depicts a user flow when they want to edit an exercise set.

==== Design Considerations
===== Parser Component
One of the consideration while designing was that the commands in exercise are extremely nested. We have commands such as `exercise set create r/1 m/10`. While we could have chucked all the parsing in `ExerciseSetCreateParser` class, we realised that it will be better if we were to abstract the parser into separate classes. This allows us to group the functionalities of the parser in a single file. For example, `ExerciseCommandParser` will parse any string that has the word `exercise` as the prefix. `SetCommandParser` will do so for a prefix of `set`. This means that for the above command, while we have to go through multiple parsers which can make the performance of the application suffer, each of the parsers have a single responsibility which makes it a better design choice.

===== Model Component
For the Model component, note that `Exercise` objects are supposed to be unique whereas `ExerciseSet` objects are not. This is created due to our observations of the workout regimes in the real world.

For `ExerciseSet`, while set weights and number of repetitions tend to vary during an exercise, users may want to have the freedom to do multiple sets with the same configuration during the course of the exercise. Hence, it is unwise to make it unique.

However, for exercises, we noted that users tend to reuse the same exercise throughout different workout plans. At the same time, there is a high chance of users creating duplicate exercises when the number of exercises in the application increases significantly. Therefore, we chose to make `Exercise` a unique object instead.

// end::exercise[]

// tag::workout[]
=== Workout [Wong Chi Shan]
==== Overview
The workout feature in ZeroToOne allows users to manage their workouts! Users will be able to create a workout, add exercises to it, as well as edit the workout and its exercises, and more.

.Activity Diagram for Creating a Workout
image::developer-guide/workout/WorkoutActivityDiagram.png[]

This is an activity diagram for the user to create a new workout. Essentially, the user will first create a workout with a name that does not contain any exercises yet. The user will then try to find exercises to add, and if their desired exercises cannot be found, the user will create them and add them into the workout.

==== Components
The Workout Manager consists of a `WorkoutList`, which contains a number of workouts that the user has created.
Each workout consists of a `WorkoutId`, a `WorkoutName` and finally, an `WorkoutExerciseList`.

The following class diagram shows the overview of the Workout feature:

.Class Diagram for Workout
image::developer-guide/workout/WorkoutClassDiagram.png[]

* `WorkoutList` implements the interface `ReadOnlyWorkoutList`
* The `WorkoutList` is managed by the `ModelManager`
* `FilteredWorkoutList` is an aggregation of one `WorkoutList`, to filter the view of the workout list shown to the user
* `WorkoutList` composes of a `UniqueWorkoutList`
* In turn, a `UniqueWorkoutList` contains any number of `Workout` objects
* Each `Workout` is comprised of two things: a `WorkoutName` and any number of `Exercise` objects
** `WorkoutName` contains the name of the `Workout`
** `Exercise` is an exercise that belongs in a `Workout`

NOTE: Each `Workout` can contain any number of `Exercise` objects, including zero. However, a `Workout` must not be empty i.e. have at least one `Exercise`, in order to be scheduled. This is implemented in the Schedule feature as referenced in <<Schedule>>.

==== Workout Model
ZeroToOne's `Model` extends the `WorkoutModel`. Here are all the functions to carry out workout-related activities:

* `Model#getWorkoutListFilePath()` - Retrieves the `Path` of the `WorkoutList`
* `Model#setWorkoutListFilePath(Path workoutListFilePath)` - Sets the `Path` of the `WorkoutList`
* `Model#setWorkoutList(ReadOnlyWorkoutList workoutList)` - Sets the `WorkoutList` to be a `ReadOnlyWorkoutList`
* `Model#getWorkoutList()` - Returns an unmodifiable `ReadOnlyWorkoutList`
* `Model#hasWorkout(Workout workout)` - Returns true if a workout exists in the workout list
* `Model#deleteWorkout(Workout target)` - Deletes a specified workout from the workout list
* `Model#addWorkout(Workout target)` - Adds a new workout to the workout list
* `Model#setWorkout(Workout target, Workout editedWorkout)` - Replaces a particular workout with an edited workout
* `Model#setExerciseInWorkout(Exercise target, Exercise editedExericse` - Replaces a target exercise in any workout with the edited exercise
* `Model#deleteExerciseFromWorkout(Exercise exercise)` - Deletes any instance of an exercise from all workouts
* `Model#getFilteredWorkoutList()` - Returns an unmodifiable view of `ObservableList<Workout>`
* `Model#updateFilteredWorkoutList(Predicate<Workout> predicate)` - Updates the filter of `FilteredWorkoutList` to show filtered views of the list to the user

==== Storage of Workouts
.Class Diagram for Workout Storage
image::developer-guide/workout/WorkoutStorageClassDiagram.png[]

1. The `WorkoutListStorageManager` implements the interface `WorkoutListStorage`. It also creates a `JacksonWorkoutList`.
2. The `JacksonWorkoutList` composes of any number of `JacksonWorkout` objects.
3. In turn, each `JacksonWorkout` composes of a `String` which is the workout name, and any number of `JacksonExercise` objects which are the exercises in each workout.
4. The relationship of the Storage component to the Model component is also shown.

==== Parser for Workouts
I will go on to explain the Parser structure for the workout commands.

.Class Diagram of the Parser for Workouts
image::developer-guide/workout/WorkoutParserClassDiagram.png[]

* The `WorkoutCommandParser` creates all `Workout` related Parsers. These parsers allow the user to create, edit, delete and find workouts, as can be seen in the left hand side of the above diagram.
* In addition, the `WorkoutCommandParser` creates the `WorkoutExerciseCommandParser`.
* In turn, `WorkoutExerciseCommandParser` creates all workout `Exercise` related Parsers. These parsers allow the user to add, edit and delete said `Exercise` objects.

==== Sample Command Execution

To illustrate an example of a command from the Workout Manager, the following sequence diagram
depicts flow of the program when the command `workout find w/Arms Workout` is run.

.Sequence Diagram for Finding a Workout
image::developer-guide/workout/WorkoutSequenceDiagram.png[]

. When the user runs the command `workout find w/Arms Workout`, the `LogicManager` will first take in the command, by calling the `execute()` function on it.
. The `ParserManager` then has to `parse(""workout find w/Arms Workout"")`.
. Next, the `WorkoutCommandParser` has to `parse(""find w/Arms Workout"")` for the command.
. Once the command has been parsed as a `FindCommand`, it will be passed on to the `FindCommandParser`.
. The `FindCommandParser` can then create a `FindCommand`. This is constructed with the `WorkoutName` for ""Arms Workout"" (a low-level detail that has been abstracted from the diagram).
. The `FindCommand` can be returned to the `LogicManager`, where it will `execute()` the `FindCommand`.
. `Model#updateFilteredWorkoutList(Predicate<Workout> predicate)` is used to update the view of the workout list to show the requested Workout(s), using the `PredicateFilterWorkoutName` that is returned by the `FindCommand` (a low-level detail that has been abstracted from the diagram).
. Finally, the resulting output message will be returned as the `CommandResult`.


==== Design Considerations

===== Aspect: Exercises in workout

* Option 1: Use existing `Exercise` class in `Workout`
** Advantage: Building on an existing class is simpler and more intuitive.
** Disadvantage: Introduces a dependency on the `Exercise` class
* Option 2: Create a new `WorkoutExercise` class for the `Workout` class
** Advantage: Creates an extra layer of abstraction and removes the dependency on `Exercise`.
** Disadvantage: More code needed which may be redundant.

In the end, I decided to stick with Option 1. This is because creating a new `WorkoutExercise` class
is redundant and unnecessary, when there is no functional difference between an `Exercise` and a `WorkoutExercise`,
other than the context that they are referenced in. In addition, this would make the deletion of any instance of a particular `Exercise` from a Workout easier, when an `Exercise` is deleted from the `ExerciseList`. Hence, to simplify matters, using the existing `Exercise` class to construct workouts was better.
// end::workout[]

// tag::schedule[]
=== Schedule [Tang Guofeng]


==== Overview
The schedule feature in ZeroToOne allows users to plan their workouts! Users will be able to create a schedule on a specific date and time in the future, edit the date and time, as well as delete the schedule.

.Activity Diagram for Creating a Schedule
image::developer-guide/schedule/ScheduleActivityDiagram.png[]

This is an activity diagram for the user to create a new schedule. First, the user will try to find workout to schedule, and if their desired workout cannot be found, the user will create one and schedule them on a specified date.


==== Components
The following class diagram shows the overview of the `Scheduler`:

.Scheduler Class Diagram
image::developer-guide/schedule/ModelScheduleClassDiagram.png[]

As seen in the diagram above, the `Scheduler` consists two lists, `ScheduleList` and `ScheduledWorkoutList`.

The `ScheduleList` contains a number of `Schedule` that the user has created, while the `ScheduledWorkoutList` is essentially a chronologically sorted list of `ScheduledWorkout` that allows JavaFX listeners to track changes when they occur.

NOTE: The decision to have both `ScheduleList` and `ScheduledWorkoutList` may seem bizarre at first glance, but it is implemented this way after careful consideration, to better support operations on 'RecurringSchedule'(Proposed). Refer to <<Model Design Considerations>> for more information.


==== Schedule Model
ZeroToOne’s `Model` extends the `SchedulerModel`. Here are all the functions to carry out schedule-related activities:

* `Model#hasSchedule(Schedule schedule)` - Returns true if a schedule exists in the schedule list

* `Model#addSchedule(Schedule schedule)` - Adds a new schedule to the schedule list

* `Model#setSchedule(Schedule scheduleToEdit, Schedule editedSchedule)` - Replaces a particular schedule with an edited schedule

* `Model#populateSortedScheduledWorkoutList()` - Clear and populate `SortedScheduledWorkoutList` by querying every `Schedule` in `SchedueList` through method `Schedule#getScheduledWorkout()`

* `Model#getSortedScheduledWorkoutList()` - Returns an unmodifiable view of `ObservableList<ScheduledWorkout>`

* `Model#deleteScheduledWorkout(ScheduledWorkout scheduledWorkoutToDelete)` - Deletes the `Schedule` that generated the specified `ScheduledWorkout` from the schedule list, then re-populates `SortedScheduledWorkoutList`

* `Model#deleteWorkoutNameFromSchedule(WorkoutName workoutNameToDelete)` - Deletes all instances of schedules that are associated with the specified workout name

* `Model#editWorkoutNameInSchedule(WorkoutName workoutNameToEdit, WorkoutName editedWorkoutName)` - Updates all instances of schedules that are associated with the specified workout name to the new workout name

* `Model#getScheduleList()` - Returns an unmodifiable `ReadOnlyScheduleList`


==== Command Execution

===== Creating a Schedule
To illustrate an example of a command from the `Scheduler`, the following sequence diagram depicts flow of the program when the command `schedule create 1 d/2020-04-01 14:00` is run.

.Sequence Diagram for Creating a Schedule
image::developer-guide/schedule/ScheduleCreateSequenceDiagram.png[]

. When the user runs the command `schedule create 1 d/2020-04-01 14:00`, the `LogicManager` will first take in the command, by calling the `execute()` function on it.
. The `ParserManager` then has to `parse(""schedule create 1 d/2020-04-01 14:00"")`.
. Next, the `ScheduleCommandParser` has to `parse(""create 1 d/2020-04-01 14:00"")` for the command.
. Once the command has been parsed as a `CreateCommand`, it will be passed on to the `CreateCommandParser`, which will then parse the index using `ParserUtil`, and parse the date and time using `ScheduleParserUtil`.
. The `CreateCommandParser` can then create a `CreateCommand`, which is then passed back to `LogicManager` to execute.
. When `LogicManager` executes the `CreateCommand`, it creates a new `Schedule`, and checks whether the model already contains this `Schedule`.
. If the model does not contain this `Schedule`, the `LogicalManager` will then add it to the model by calling `Model#addSchedule(schedule)`.
. Finally, the resulting output message will be returned as the `CommandResult`.

NOTE: Date and time must not be outdated and follow the format {yyyy}-{mm}-{dd} {HH:mm}

===== Populating the SortedScheduledWorkoutList

And the following sequence diagram shows how the `ScheduledWorkoutList` is populated after the method `Model#addSchedule(schedule)` is called:

.Sequence Diagram for Populating `SortedScheduledWorkoutList`
image::developer-guide/schedule/PopulateSortedScheduledWorkoutList.png[]

. After the `LogicManager` calls the method `Model#addSchedule(schedule)`, `ModelManager` calls `Scheduler#addSchedule(schedule)`, which in turns calls `ScheduleList#addSchedule(schedule)` and adds the `Schedule` in the `ScheduleList`.
. The `Scheduler` will then populate the `ScheduledWorkoutList` by calling the method `populateSortedScheduledWorkoutList()`.
. First, `Scheduler` gets the current date and time by calling `DateTime#now()`.
. Then, `Scheduler` iterates through every `Schedule` in `ScheduleList`, and requests to get `ScheduledWorkout` by calling `Schedule#getScheduledWorkout(now)` on each of them.
. Finally, `Scheduler` resets the `SortedScheduledWorkoutList` with the latest `ScheduledWorkout` by calling `ScheduledWorkoutList#setScheduledWorkouts(scheduledWorkouts)`, and user's view of `ScheduledWorkout` is refreshed.
. And in the end, the resulting output message will be passed back to `LogicManager` and display to user.

NOTE: `Scheduler#populateSortedScheduledWorkoutList()` is called whenever the schedules in `ScheduleList` have been changed.


==== Model Design Considerations

===== Aspect: How to handle editing and deletion of recurring schedules

* **Option 1:** `Model` stores only `ScheduledWorkout` objects.
** Pros: Easier to implement.
** Cons: Harder to maintain when it comes to `edit` or `delete` of recurring scheduled workouts.
* **Option 2 (current choice):** Saves `Schedule` objects that can be used to produce `ScheduledWorkout` when requested.
** Pros: Changes can be made to recurring schedules instead, and in turn reflect in all related `ScheduledWorkout`.
** Cons: Makes model much more complicated.

In the end, I decided to go with option 2 as it is easier to maintain, more extensible and less computationally expensive.

When the system has a number of recurring schedules that do not have an end date, it introduces a few problems:

* How many scheduled workouts to create/store for each recurring schedule
* How to efficiently retrieve and update all related scheduled workouts when a recurring schedule is edited or deleted

Implementing option 1 would mean that we will have to impose an additional constraint onto the system, which is either how many scheduled workouts to display for each recurring schedule or what is the longest time frame of scheduled workouts to display to user, as we simply can't generate indefinite number of scheduled workouts for technically everlasting recurring schedules. Additionally, when the number of high frequency recurring schedules in the system increases, it will be extremly computationally expensive to edit or delete recurring schedules, as the system will have to iterate through every ScheduledWorkout objects and update accordingly.

On the other hand, implementing option 2 makes it easier to handle these problems by storing changes to the Schedule objects instead, which can be used to generate ScheduleWorkout objects when requested. Moreover, it is more extensible because if we are going to introduce a calendar view in the future, where user can view a specific time frame of scheduled workouts, the system only needs to generate for that time frame only, which can be done much more efficiently!
// end::schedule[]



// tag::log[]
=== Log Statistics [Liow Jiachen]
The log statistics feature in ZeroToOne allows users to view their completed workouts visually with meaningful aggregated information so they can see how much progress made.

==== Overview
The ZeroToOne user can generate and view these statistics via the `log display` command which takes in two optional parameters `startRange` and `endRange`. Workouts will only be considered if they fall within the `startTime` and `endTime` range.

===== Architecture
The log statistics feature was built from the ground up with modularity and extensibility in mind which is inline with SLAP and SOLID principles. This is exemplified in the decision to have a `DataPoint` abstract class. The class diagram is shown below.

A `DataPoint` is metric that takes gives the user some information on his or her performance. Data points are list row by row to the user with the `labelName` on the left followed by the `result` on the right in a table format.

.Log Display Screenshot
image::developer-guide/log/LogDisplayScreenshot.png[]

.DataPoint Abstract Class
image::developer-guide/log/DataPointAbstractClass.png[]

This abstract class is then extended by concrete class as shown below.

.Example Concrete Data Points
image::developer-guide/log/StatisticsDataPointsClassDiagram.png[]

Through this abstraction we make it easy to extend and include new metrics to track in the future. All that needs to be done is to create a new class that extends `DataPoint` and implements the `calculate` function that takes as input a list of `CompletedWorkout` and does the necessary calculations and sets the results.

==== Implementation
To help explain the implementation of this feature, this portion of the developer guide will examine the command execution of the `log display` command.

For the sake of clarity, this portion of implementation has been broken down into two phases.

Phase 1 will primarily deal with the actual command parsing, execution and the storing of the `startRange` and `endRage` in the model while Phase 2 will then go on to generate statistics based on the `startRange` and `endRange` provided in phase 1.

===== Execution Phase 1
The sequence diagram below describes the flow when the `log display` command is invoked by the user.

.Display Command Invocation Phase 1
image::developer-guide/log/DisplayCommandSequenceDiagramPart1.png[]

This next section goes over in a little more detail how the program unfolds.

Step 1: When the user enters the `log display` command, the `MainWindow#executeCommand()` is executed and in turn calls on the `LogicManager` to help with this.

Step 2: The `LogicManager` then goes through with the normal flow of parsing the command and its parameters and then returning a valid  `DisplayCommand`. This section will not go into details and specifics of this process as it has already been covered above.

Step 3: Once the `Logic Manager` receives the `DisplayCommand`, it will call the concrete implementation of the `DisplayCommand#execute(Model model)` to run the command with the current model.

Step 4: The `execute` function will then go ahead and store the `startRange` and `endRange` in the model via the `Model#setStatisticsDataRange` function.

Step 5: This is where the display command differs from all the other commands. When constructing the `CommandResult` to be returned, the `showReport` flag in `CommandResult` is set to `True`.

Summary:
`startRange` and `endRange` are updated in the current `Model`
The `showReport` flag in `CommandResult` being returned is set to `True`

===== ExecutionPhase 2
Following immediately from phase 1, phase 2 will commence with the return of `CommandResult` to the `MainWindow#executeCommand` function. The sequence diagram below documents the execution flow.

.Example Display Command Invocation Phase 2
image::developer-guide/log/DisplayCommandSequenceDiagramPart2.png[]

Similar to phase 1, this next section will detail the steps taken in a little more detail.

Step 1: When `CommandResult` is returned to the main window, it is checked for the `showReport` to decide if the report page should be shown.

Step 2: Since the `showResult` flag will be set to `True`, the `MainWindow` will call `LogicManager#generateStatistics` to help with the generating of the statistics.

Step 3: The `LogicManager` will then query all the information it requires from the model including the `startRange` and `endRange` described in phase 1.

Step 4: Next, the static function `Statistics#generate` will be invoked. This function will then instantiate new instances of all the `DataPoints` configured.

Step 5: Once instantiated, the `DataPoint#calculate` function will be invoked on all the `DataPoint` objects. This used to calculate and populate each data point with valid data from the list of workouts.

Step 6: Once this is done, a new `StatisticsData` object is created with the data points and the list of workouts and returned.

Step 7: Lastly, the view `StatisticsWindow#show` function is called with the `StatisticsData` previously returned. This renders the new window with the computed statistics.


==== Design Considerations
The following section will detail some of the design consideration and design choices we made while implementing the log statics feature.

==== Flexibility and Sensible Defaults
We wanted to build the statistics feature to be flexible. This is why we decided to include a `startRange` and `endRange` to the `log display` command. This allows users to generate reports for custom datetime ranges.

Due to this flexibility we had to think hard of sensible defaults for this date range if they were not specified. We eventually decided on the flow specified by the activity diagram below.

.Log sensible date range defaults
image::developer-guide/log/LogDateRangeSensibleDefaults.png[]

* **Alternative 1:** Do not support date range in log command
** Pros: Easy to implement.
** Cons: Less flexible and metrics used will be limited.

* **Alternative 2 :** Require `startRange` and `endRange` in all display commands
** Pros: Would have to consider sensible defaults
** Cons: More for the user to type if he/she wants to view statistics over all workouts.

* **Alternative 3 :** Allow optional `startRange` and `endRange` use start of epoch for start time and current datetime for end date.
** Pros: Easy to implement
** Cons: Statistics generated using the number of days might not make sense.
[Note] For example, the average workout time per day would not make sense since the number of days since epoch will be huge.

* **Alternative 4 (current choice):** Allow optional `startRange` and `endRange` and if not given take earliest start date time and latest end datetime
** Pros: More meaningful metrics and statistics
** Cons: More complicated model and defaults might not seem intuitive at first

===== Defensive Programming
We decided to build these features with security at the forefront. This can be seen in

* The use of optionals and `ifPresent()` functions guards against `NullPointerExceptions` when the user does not provide optional fields.
* `requireNonNull` are frequently used to check for `null` values.
* Strong exception handling when parsing `startRange` and `endRange` in the display command and throwing a `ParseCommandException` if date times provided are not valid in the specified format.

// end::log[]

=== 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*:

* Enjoys exercising and does it regularly
* Has a need to manage a significant number of workouts
* Prefers desktop apps over other types
* Can type fast
* Prefers typing over mouse input
* Is reasonably comfortable using CLI apps

*Value proposition*:
Manage workouts faster than a typical mouse/GUI-driven app

[appendix]
== User Stories [Wong Chi Shan]

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...
|`* * *` |User who wants to track live progress while exercising |Time each part of my workout |Stay on track for each workout session I do

|`* * *` |User who does a large variety of kinds of exercises |Keep track of all my exercises for different fitness purposes |Stay organised

|`* * *` |User with many different workouts |Keep track of all my workouts |Stay organised

|`* * *` |User that is busy with multiple commitments |Keep on schedule for my exercise regime |Stay disciplined and keep exercising regularly

|`* * *` |User who has exercise goals |See or track my current progress |Check if I am reaching my goals

|`* *` |User who likes to schedule single workout sessions, but will occasionally do recurring ones |Keep track of the two types of workouts |Manage different types of workouts simultaneously

|`* * *` |User who wants to track live progress while exercising |Have a timer for each part of my workout |Stay on schedule for each workout session I do

|`* *` |User who enjoys social activities |Share my workout routines with my friends |Help each other out by sharing new exercise regimes

|`* *` |User who has a regular workout schedule, but likes to schedule one-off sessions |Some way to keep track of both regular and one-off workouts |Differentiate between the workouts and manage them both simultaneously

|`* *` |User who loses motivation over a long period of time |Something to help me stay motivated |Keep going and not give up halfway

|`* *` |User who lacks self discipline at times |Something to help me maintain the discipline to stay on track |Stick to a regular exercise schedule and regime

|`* *` |User who needs some inspiration or a change of pace |Have sample workout routines to follow |Get more ideas and ways to structure my workouts and find new exercises

|`* *` |User who has many different types of workouts |To categorize the different types of workout  |Achieve better organisation

|`*` |New user who is not familiar with setting up exercise regimes |To have a way to consult with fitness trainers or professionals |Gain better knowledge and understanding of exercise regimes

|`*` |User who is sociable and largely influenced by my peers |To see my friends’ progress and achievements |Motivate myself to work harder and help each other out

|`*` |User who sometimes gets a little bored when working out |To have a way to entertain or distract myself when working out  |Keep myself on the task at hand by giving an extra motivation boost
|=======================================================================

[appendix]
== Use Cases [Wong Chi Shan]

(For all use cases below, the *System* is the `ZeroToOne` and the *Actor* is the `user`, unless specified otherwise)

[discrete]
=== Use Case 1: Adding Exercises to Workout

*MSS*

1. User requests for the existing exercises in the workout
2. System shows a list of the existing exercises
3. User requests to add an exercise to the workout
4. System adds the exercise to the workout
+
Use case ends.

*Extensions*

[none]
* 2a. The requested workout does not exist
** 2a1. Use case ends
+

* 2b. There are no exercises in the workout
** 2b1. System shows a message to inform the user
+
Use case resumes at step 2

* 3a. User request format is invalid
** 3a1. System shows an error message
+
Use case resumes at step 3

[discrete]
=== Use Case 2: Deleting Workouts

*MSS*

1. User requests to list workouts
2. System shows a list of all workouts
3. User requests to delete a specific workout
4. System deletes the workout
+
Use case ends.

*Extensions*

[none]
* 2a. The list is empty
+
Use case ends

* 3a. The given user index is invalid
** 3a1. System shows an error message
+
Use case resumes at step 2

[discrete]
=== Use Case 3: Find Past Workout by Keyword

*MSS*

1. User requests a log of past workouts
2. System shows a list of all past logged workouts
3. User requests to find a past workout by keyword
4. System shows the past workouts that match the keyword
+
Use case ends

*Extensions*

[none]
* 2a. The log is empty
+
Use case ends

* 3a. The keyword does not match any past workouts
** 3a1. System shows an error message
+
Use case ends

[appendix]
== Non Functional Requirements

.  Should work on any <<mainstream-os,mainstream OS>> as long as it has Java `11` or above installed.
.  Should be able to hold up to 100 workouts without a noticeable sluggishness in performance for typical usage.
.  A user with above average typing speed for regular English text (i.e. not code, not system admin commands) should be able to accomplish most of the tasks faster using commands than using the mouse.
. Should not depend on a remote server, so that a user can exercise in any condition or environment.

[appendix]
== Glossary

[[cli]]CLI::
Stands for Command Line Interface, which processes commands to a computer program in the form of lines of text.

[[exercise]]Exercise::
A single type of exercise, for example push ups or crunches.
GUI
Stands for Graphical User Interface, which is a form of user interface that allows users to interact with electronic devices through graphical means, not textual means.

[[instance]]Instance::
A specific instantiation of an object.

[[mainstream-os]] Mainstream OS::
Windows, Linux, Unix, OS-X

[[schedule]]Schedule::
A workout that has been planned to be carried out on a specific date or dates.

[[workout]]Workout::
A set of exercises to be done together, in a certain order and time frame.

//tag::gb3h[]
[appendix]
== Instructions for Manual Testing [Gabriel Yeo]

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 exercises and workouts. 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.

=== Starting a workout session

. Starting a workout session with a `WORKOUT_ID`

.. Prerequisites: At least 1 workout containing valid exercises and sets must exist.
.. Test case: `start 1` +
   Expected: Workout session started with the index of the workout shown in the status message. Timer starts counting from 00:00.
.. Test case: `start 0` +
   Expected: No workout session is started. Error details shown in the status message. Status bar remains the same. Timer remains at 00:00.
.. Other incorrect delete commands to try: `start`, `start x` (where x is larger than the list size), `start y` (where y is the ID of an invalid workout) +
   Expected: Similar to previous.

=== Saving a workout session

. Workout sessions are saved automatically at the end of a workout session.

.. Prerequisites: A workout session must be ongoing.
.. Test case: `stop` +
   Expected: Workout session stops and displays in the status message. Timer resets to 00:00. The workout session should appear in the `Log` tab.
.. Test case: `skip`, `done` +
   Expected: Same as above, if `skip` or `done` is given on the last set.
.. Other incorrect delete commands to try: `save`, `stop 1`, `skip`/`done` (when there are more sets remaining) +
   Expected: Error message displayed in the status bar.

//end::gb3h[]

//tag::session[]
[appendix]
== Effort [ZeroToOne Team]


[width=""59%"",cols=""22%,<23%,<25%,options=""header"",]
|=======================================================================
|Feature |AB3 |ZeroToOne

|LoC |~10k |~26k
|Difficulty |10 |15
|Effort |10 |15
|=======================================================================

The idea of an exercise app alone itself is not particularly challenging.
However, the ZeroToOne team believes that taking a user-experience-first philosophy toward designing an exercise app requires a conscientious design-approach, one that _is_ a challenge.

This is something that we have endeavoured to achieve in this project.

We think that despite the constraints of the CS2103T project, we have managed to demonstrate this to a larger degree.

AB3 deals primarily in the domain of data storage and retrieval. ZeroToOne has taken this one step further, with the ability to:

1. Statefully update new models during a workout session
2. Apply useful statistics across an entire collection of stored data
3. Extend AB3's models to be more functional

Furthermore, on top of the ~16k LoC added to the project, the ZeroToOne team has managed to:

1. Maintain > 70% test coverage
2. Apply SOLID design principles
3. Maintain a consistent quality of the codebase through stringent PR reviews and hooks.

The largest challenge we faced as a team was communication.
Being fast-moving and driven individuals, taking the initiative sometimes meant being able to make decisions for the team as an individual. This meant that it was vital that we were on the same page with our goals and expectations from the project.
Thus, we took more time than usual at the beginning of the project to plan our road-map moving forward, delegating work and defining our expectations clearly.

We hope you have enjoyed this journey and learnt as much as we have!
- The ZeroToOne Team

//end::session[]
",12181,False,1972.5305832576068,median
"CLASS zcl_gtt_sts_send_tor_data DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.

    INTERFACES /scmtms/if_common_badi .
    INTERFACES /scmtms/if_send_tor_data .
    INTERFACES if_badi_interface .
  PROTECTED SECTION.
private section.

  types:
    BEGIN OF ty_tor_stop_address,
      stop_postal_addr_info          TYPE /bofu/s_addr_postal_addressk,
      formatted_postal_address_descr TYPE  /bofu/addr_langind_mdiumdesc,
    END OF ty_tor_stop_address .
  types:
    tt_tor_stop_address TYPE STANDARD TABLE OF ty_tor_stop_address .

  methods GET_TOR_ROOT_FOR_DELETION
    importing
      !IT_TOR_ROOT_SSTRING type /SCMTMS/T_EM_BO_TOR_ROOT
      !IT_TOR_ROOT_BEFORE_SSTRING type /SCMTMS/T_EM_BO_TOR_ROOT
    exporting
      !ET_TOR_ROOT_FOR_DELETION type /SCMTMS/T_EM_BO_TOR_ROOT .
  methods SEND_DELETION_IDOC
    importing
      !IT_TOR_ROOT type /SCMTMS/T_EM_BO_TOR_ROOT
    raising
      /SCMTMS/CX_EVENT_MANAGEMENT .
  methods CALL_EVENT_MANAGER
    importing
      !IT_TOR_ROOT_FOR_DELETION type /SCMTMS/T_EM_BO_TOR_ROOT
      value(IT_TOR_ROOT_SSTRING) type /SCMTMS/T_EM_BO_TOR_ROOT
      value(IT_ITEM_SSTRING) type /SCMTMS/T_EM_BO_TOR_ITEM optional
      value(IT_STOP_SSTRING) type /SCMTMS/T_EM_BO_TOR_STOP optional
      value(IT_STOP_SUCC_SSTRING) type /SCMTMS/T_EM_BO_TOR_STOP_SUCC optional
      value(IT_PARTY_SSTRING) type /SCMTMS/T_EM_BO_TOR_PARTY optional
      value(IT_LOCATION_LOG_SSTRING) type /SCMTMS/T_EM_BO_LOC_ROOT optional
      value(IT_LOCATION_ADDR_SSTRING) type /SCMTMS/T_EM_BO_LOC_ROOT optional
      value(IT_TOR_ROOT_BEFORE_SSTRING) type /SCMTMS/T_EM_BO_TOR_ROOT optional
      value(IT_STOP_BEFORE_SSTRING) type /SCMTMS/T_EM_BO_TOR_STOP optional
      value(IT_STOP_ADDR_SSTRING) type /SCMTMS/T_EM_BO_LOC_ADDR optional
      value(IT_TRQ_ROOT_SSTRING) type /SCMTMS/T_EM_BO_TRQ_ROOT optional
      value(IT_TRQ_ROOT_BEFORE_SSTRING) type /SCMTMS/T_EM_BO_TRQ_ROOT optional
      value(IT_CAPA_ROOT_SSTRING) type /SCMTMS/T_EM_BO_TOR_ROOT optional
      value(IT_CAPA_ROOT_BEF_SSTRING) type /SCMTMS/T_EM_BO_TOR_ROOT optional
      value(IT_EXECINFO_SSTRING) type /SCMTMS/T_EM_BO_TOR_EXECINFO optional
      value(IT_EXECINFO_BEFORE_SSTRING) type /SCMTMS/T_EM_BO_TOR_EXECINFO optional
      value(IT_TENDERING_SSTRING) type /SCMTMS/T_EM_BO_TOR_TEND optional
      value(IT_ITEM_BEFORE_SSTRING) type /SCMTMS/T_EM_BO_TOR_ITEM optional
      value(IT_REQ_ROOT_SSTRING) type /SCMTMS/T_EM_BO_TOR_ROOT optional
      value(IT_REQ_ROOT_BEFORE_SSTRING) type /SCMTMS/T_EM_BO_TOR_ROOT optional
      value(IT_REQ_TU_ROOT_SSTRING) type /SCMTMS/T_EM_BO_TOR_ROOT optional
      value(IT_REQ_TU_ROOT_BEF_SSTRING) type /SCMTMS/T_EM_BO_TOR_ROOT optional
      value(IT_CAPA_STOP_SSTRING) type /SCMTMS/T_EM_BO_TOR_STOP optional
      value(IT_TOR_CREATED_KEYS) type /BOBF/T_FRW_KEY optional
      value(IT_REQ_STOP_SSTRING) type /SCMTMS/T_EM_BO_TOR_STOP optional
      value(IT_REQ_TU_STOP_SSTRING) type /SCMTMS/T_EM_BO_TOR_STOP optional
    raising
      /SCMTMS/CX_EVENT_MANAGEMENT .
  methods GET_STOP_POSTAL_ADDR_INFO
    importing
      !IT_STOP type /SCMTMS/T_TOR_STOP_K
    exporting
      value(ET_STOP_POSTAL_ADDR_INFO) type TT_TOR_STOP_ADDRESS .
  methods ADD_REQUIRED_FREIGHT_UNIT
    changing
      !CT_EXECINFO_SSTRING type /SCMTMS/T_EM_BO_TOR_EXECINFO
      !CT_EXECINFO_BEFORE_SSTRING type /SCMTMS/T_EM_BO_TOR_EXECINFO
      !CT_TENDERING_SSTRING type /SCMTMS/T_EM_BO_TOR_TEND
      !CT_ITEM_BEFORE_SSTRING type /SCMTMS/T_EM_BO_TOR_ITEM
      !CT_CAPA_STOP_SSTRING type /SCMTMS/T_EM_BO_TOR_STOP
      !CT_TOR_ROOT_SSTRING type /SCMTMS/T_EM_BO_TOR_ROOT
      !CT_ITEM_SSTRING type /SCMTMS/T_EM_BO_TOR_ITEM
      !CT_STOP_SSTRING type /SCMTMS/T_EM_BO_TOR_STOP
      !CT_STOP_SUCC_SSTRING type /SCMTMS/T_EM_BO_TOR_STOP_SUCC
      !CT_STOP_SUCC_BEFORE_SSTRING type /SCMTMS/T_EM_BO_TOR_STOP_SUCC
      !CT_PARTY_SSTRING type /SCMTMS/T_EM_BO_TOR_PARTY
      !CT_TOR_ROOT_BEFORE_SSTRING type /SCMTMS/T_EM_BO_TOR_ROOT
      !CT_STOP_BEFORE_SSTRING type /SCMTMS/T_EM_BO_TOR_STOP
      !CT_STOP_ADDR_SSTRING type /SCMTMS/T_EM_BO_LOC_ADDR
      !CT_CAPA_ROOT_SSTRING type /SCMTMS/T_EM_BO_TOR_ROOT
      !CT_CAPA_ROOT_BEF_SSTRING type /SCMTMS/T_EM_BO_TOR_ROOT
    raising
      /SCMTMS/CX_EVENT_MANAGEMENT .
ENDCLASS.



CLASS ZCL_GTT_STS_SEND_TOR_DATA IMPLEMENTATION.


  METHOD /scmtms/if_common_badi~set_badi_work_mode.

    DATA ls_work_mode TYPE /scmtms/s_badi_work_mode.

    ls_work_mode-intf_method_name = /scmtms/if_send_tor_data=>mc_intf_method_call_event_mgr.
    ls_work_mode-badi_work_mode   = /scmtms/if_common_badi=>gc_mode_customer_logic_only.
    INSERT ls_work_mode INTO TABLE ct_work_mode.

  ENDMETHOD.


  METHOD /scmtms/if_send_tor_data~avoid_retrieval_of_appl_tables.
    RETURN.
  ENDMETHOD.


  METHOD /scmtms/if_send_tor_data~call_event_mgr.

    DATA(lo_send_delivery_idoc) = NEW  zcl_gtt_sts_send_delivery_idoc(
                                          it_tor_root_sstring        = it_tor_root_sstring
                                          it_tor_root_before_sstring = it_tor_root_before_sstring
                                          it_tor_item_sstring        = it_item_sstring
                                          it_tor_item_before_sstring = it_item_before_sstring
                                          it_tor_stop_addr_sstring   = it_stop_addr_sstring
                                          it_tor_stop_sstring        = it_stop_sstring ).
    lo_send_delivery_idoc->send_delivery_idoc( ).

    get_tor_root_for_deletion(
      EXPORTING
        it_tor_root_sstring        = it_tor_root_sstring
        it_tor_root_before_sstring = it_tor_root_before_sstring
      IMPORTING
        et_tor_root_for_deletion   = DATA(lt_tor_root_for_deletion) ).

    send_deletion_idoc( lt_tor_root_for_deletion ).

    "" F.O./F.B./F.U. to DLV CrossTP update
    CALL FUNCTION 'ZGTT_MIA_CTP_TOR_TO_DL'
      EXPORTING
        it_tor_root_sstring        = it_tor_root_sstring
        it_tor_root_before_sstring = it_tor_root_before_sstring
        it_tor_item_sstring        = it_item_sstring
        it_tor_item_before_sstring = it_item_before_sstring
        it_tor_stop_sstring        = it_stop_sstring
        it_tor_stop_addr_sstring   = it_stop_addr_sstring.

    add_required_freight_unit(
      CHANGING
        ct_execinfo_sstring         = it_execinfo_sstring
        ct_execinfo_before_sstring  = it_execinfo_before_sstring
        ct_tendering_sstring        = it_tendering_sstring
        ct_item_before_sstring      = it_item_before_sstring
        ct_capa_stop_sstring        = it_capa_stop_sstring
        ct_tor_root_sstring         = it_tor_root_sstring
        ct_item_sstring             = it_item_sstring
        ct_stop_sstring             = it_stop_sstring
        ct_stop_succ_sstring        = it_stop_succ_sstring
        ct_stop_succ_before_sstring = it_stop_succ_before_sstring
        ct_party_sstring            = it_party_sstring
        ct_tor_root_before_sstring  = it_tor_root_before_sstring
        ct_stop_before_sstring      = it_stop_before_sstring
        ct_stop_addr_sstring        = it_stop_addr_sstring
        ct_capa_root_sstring        = it_capa_root_sstring
        ct_capa_root_bef_sstring    = it_capa_root_bef_sstring ).

    call_event_manager(
      EXPORTING
        it_tor_root_for_deletion   = lt_tor_root_for_deletion
        it_tor_root_sstring        = it_tor_root_sstring
        it_item_sstring            = it_item_sstring
        it_stop_sstring            = it_stop_sstring
        it_stop_succ_sstring       = it_stop_succ_sstring
        it_party_sstring           = it_party_sstring
        it_location_log_sstring    = it_location_log_sstring
        it_location_addr_sstring   = it_location_addr_sstring
        it_tor_root_before_sstring = it_tor_root_before_sstring
        it_stop_before_sstring     = it_stop_before_sstring
        it_stop_addr_sstring       = it_stop_addr_sstring
        it_trq_root_sstring        = it_trq_root_sstring
        it_trq_root_before_sstring = it_trq_root_before_sstring
        it_capa_root_sstring       = it_capa_root_sstring
        it_capa_root_bef_sstring   = it_capa_root_bef_sstring
        it_execinfo_sstring        = it_execinfo_sstring
        it_execinfo_before_sstring = it_execinfo_before_sstring
        it_tendering_sstring       = it_tendering_sstring
        it_item_before_sstring     = it_item_before_sstring
        it_req_root_sstring        = it_req_root_sstring
        it_req_root_before_sstring = it_req_root_before_sstring
        it_req_tu_root_sstring     = it_req_tu_root_sstring
        it_req_tu_root_bef_sstring = it_req_tu_root_bef_sstring
        it_capa_stop_sstring       = it_capa_stop_sstring
        it_tor_created_keys        = it_tor_created_keys
        it_req_stop_sstring        = it_req_stop_sstring
        it_req_tu_stop_sstring     = it_req_tu_stop_sstring ).

  ENDMETHOD.


  METHOD /scmtms/if_send_tor_data~get_additional_data.
    RETURN.
  ENDMETHOD.


  METHOD /scmtms/if_send_tor_data~prevent_event_msg_sending.
    RETURN.
  ENDMETHOD.


  METHOD add_required_freight_unit.

    DATA:
      lt_fu_root_key      TYPE /bobf/t_frw_key,
      lt_tor_root         TYPE /scmtms/t_tor_root_k,
      lt_tor_root_before  TYPE /scmtms/t_tor_root_k,
      lt_capa_root        TYPE /scmtms/t_tor_root_k,
      lt_capa_root_before TYPE /scmtms/t_tor_root_k,
      lt_execinfo         TYPE /scmtms/t_tor_exec_k,
      lt_execinfo_before  TYPE /scmtms/t_tor_exec_k,
      lt_item             TYPE /scmtms/t_tor_item_tr_k,
      lt_item_before      TYPE /scmtms/t_tor_item_tr_k,
      lt_stop_succ        TYPE /scmtms/t_tor_stop_succ_k,
      lt_stop_succ_before TYPE /scmtms/t_tor_stop_succ_k,
      lt_stop             TYPE /scmtms/t_tor_stop_k,
      lt_stop_before      TYPE /scmtms/t_tor_stop_k,
      lt_capa_stop        TYPE /scmtms/t_tor_stop_k,
      lt_stop_sorted      TYPE /scmtms/t_pln_stop_seq,
      lt_tendering        TYPE /scmtms/t_tor_tend_k,
      lt_party            TYPE /scmtms/t_tor_party_k.

    DATA:
      ls_stop_addr_sstring        TYPE /scmtms/s_em_bo_loc_addr,
      lt_root_sstring             TYPE /scmtms/t_em_bo_tor_root,
      lt_root_before_sstring      TYPE /scmtms/t_em_bo_tor_root,
      lt_stop_sstring             TYPE /scmtms/t_em_bo_tor_stop,
      lt_stop_before_sstring      TYPE /scmtms/t_em_bo_tor_stop,
      lt_item_sstring             TYPE /scmtms/t_em_bo_tor_item,
      lt_item_before_sstring      TYPE /scmtms/t_em_bo_tor_item,
      lt_stop_succ_sstring        TYPE /scmtms/t_em_bo_tor_stop_succ,
      lt_stop_succ_before_sstring TYPE /scmtms/t_em_bo_tor_stop_succ,
      lt_party_sstring            TYPE /scmtms/t_em_bo_tor_party,
      lt_capa_root_sstring        TYPE /scmtms/t_em_bo_tor_root,
      lt_capa_root_before_sstring TYPE /scmtms/t_em_bo_tor_root,
      lt_execinfo_sstring         TYPE /scmtms/t_em_bo_tor_execinfo,
      lt_execinfo_before_sstring  TYPE /scmtms/t_em_bo_tor_execinfo,
      lt_tendering_sstring        TYPE /scmtms/t_em_bo_tor_tend,
      lt_capa_stop_sstring        TYPE /scmtms/t_em_bo_tor_stop.

    DATA(lt_freight_order_key) = VALUE /bobf/t_frw_key( FOR <ls_tor_root_sstring> IN ct_tor_root_sstring
                                   WHERE ( tor_cat = /scmtms/if_tor_const=>sc_tor_category-active OR
                                           tor_cat = /scmtms/if_tor_const=>sc_tor_category-booking )
                                 ( key = <ls_tor_root_sstring>-node_id ) ).

    DATA(lo_tor_srv_mgr) = /bobf/cl_tra_serv_mgr_factory=>get_service_manager(
                                                              iv_bo_key = /scmtms/if_tor_c=>sc_bo_key ).
    lo_tor_srv_mgr->retrieve_by_association(
      EXPORTING
        iv_node_key    = /scmtms/if_tor_c=>sc_node-root
        it_key         = lt_freight_order_key
        iv_association = /scmtms/if_tor_c=>sc_association-root-req_tor
      IMPORTING
        et_key_link    = DATA(lt_capa2req_link) ).

    LOOP AT lt_capa2req_link ASSIGNING FIELD-SYMBOL(<ls_capa2req_link>).
      CHECK NOT line_exists( ct_tor_root_sstring[ node_id = <ls_capa2req_link>-target_key ] ).
      INSERT VALUE #( key = <ls_capa2req_link>-target_key ) INTO TABLE lt_fu_root_key.
    ENDLOOP.

    IF lt_fu_root_key IS INITIAL.
      RETURN.
    ENDIF.

    lo_tor_srv_mgr->retrieve(
      EXPORTING
        iv_node_key = /scmtms/if_tor_c=>sc_node-root
        it_key      = lt_fu_root_key
      IMPORTING
        et_data     = lt_tor_root ).
    lt_root_sstring = CORRESPONDING #( lt_tor_root MAPPING node_id = key ).
    INSERT LINES OF lt_root_sstring INTO TABLE ct_tor_root_sstring.


    lo_tor_srv_mgr->retrieve(
      EXPORTING
        iv_node_key     = /scmtms/if_tor_c=>sc_node-root
        it_key          = lt_fu_root_key
        iv_before_image = abap_true
      IMPORTING
        et_data         = lt_tor_root_before ).
    lt_root_before_sstring = CORRESPONDING #( lt_tor_root_before MAPPING node_id = key ).
    INSERT LINES OF lt_root_before_sstring INTO TABLE ct_tor_root_before_sstring.


    lo_tor_srv_mgr->retrieve_by_association(
      EXPORTING
        iv_node_key    = /scmtms/if_tor_c=>sc_node-root
        it_key         = lt_fu_root_key
        iv_association = /scmtms/if_tor_c=>sc_association-root-exec_valid
        iv_fill_data   = abap_true
      IMPORTING
        et_data        = lt_execinfo ).
    lt_execinfo_sstring = CORRESPONDING #( lt_execinfo MAPPING node_id = key parent_node_id = parent_key ).
    INSERT LINES OF lt_execinfo_sstring INTO TABLE ct_execinfo_sstring.


    lo_tor_srv_mgr->retrieve_by_association(
      EXPORTING
        iv_node_key     = /scmtms/if_tor_c=>sc_node-root
        it_key          = lt_fu_root_key
        iv_association  = /scmtms/if_tor_c=>sc_association-root-exec_valid
        iv_before_image = abap_true
        iv_fill_data    = abap_true
      IMPORTING
        et_data         = lt_execinfo_before ).
    lt_execinfo_before_sstring = CORRESPONDING #( lt_execinfo_before MAPPING node_id = key parent_node_id = parent_key ).
    INSERT LINES OF lt_execinfo_before_sstring INTO TABLE ct_execinfo_before_sstring.


    lo_tor_srv_mgr->retrieve_by_association(
      EXPORTING
        iv_node_key    = /scmtms/if_tor_c=>sc_node-root
        it_key         = lt_fu_root_key
        iv_association = /scmtms/if_tor_c=>sc_association-root-item_tr
        iv_fill_data   = abap_true
      IMPORTING
        et_data        = lt_item ).
    lt_item_sstring = CORRESPONDING #( lt_item MAPPING node_id = key parent_node_id = parent_key ).
    INSERT LINES OF lt_item_sstring INTO TABLE ct_item_sstring.


    lo_tor_srv_mgr->retrieve_by_association(
      EXPORTING
        iv_node_key     = /scmtms/if_tor_c=>sc_node-root
        it_key          = lt_fu_root_key
        iv_association  = /scmtms/if_tor_c=>sc_association-root-item_tr
        iv_before_image = abap_true
        iv_fill_data    = abap_true
      IMPORTING
        et_data         = lt_item_before ).
    lt_item_before_sstring = CORRESPONDING #( lt_item_before MAPPING node_id = key parent_node_id = parent_key ).
    INSERT LINES OF lt_item_before_sstring INTO TABLE ct_item_before_sstring.


    lo_tor_srv_mgr->retrieve_by_association(
      EXPORTING
        iv_node_key    = /scmtms/if_tor_c=>sc_node-root
        it_key         = lt_fu_root_key
        iv_association = /scmtms/if_tor_c=>sc_association-root-stop_successor_all
        iv_fill_data   = abap_true
      IMPORTING
        et_data        = lt_stop_succ ).
    lt_stop_succ_sstring = CORRESPONDING #( lt_stop_succ MAPPING node_id = key parent_node_id = parent_key ).
    INSERT LINES OF lt_stop_succ_sstring INTO TABLE ct_stop_succ_sstring.


    lo_tor_srv_mgr->retrieve_by_association(
      EXPORTING
        iv_node_key     = /scmtms/if_tor_c=>sc_node-root
        it_key          = lt_fu_root_key
        iv_association  = /scmtms/if_tor_c=>sc_association-root-stop_successor_all
        iv_before_image = abap_true
        iv_fill_data    = abap_true
      IMPORTING
        et_data         = lt_stop_succ_before ).
    lt_stop_succ_before_sstring = CORRESPONDING #( lt_stop_succ_before MAPPING node_id = key parent_node_id = parent_key ).
    INSERT LINES OF lt_stop_succ_before_sstring INTO TABLE ct_stop_succ_before_sstring.


    lo_tor_srv_mgr->retrieve_by_association(
      EXPORTING
        iv_node_key    = /scmtms/if_tor_c=>sc_node-root
        it_key         = lt_fu_root_key
        iv_association = /scmtms/if_tor_c=>sc_association-root-stop
        iv_fill_data   = abap_true
      IMPORTING
        et_data        = lt_stop ).

    /scmtms/cl_tor_helper_stop=>get_stop_sequence_linear(
      EXPORTING
        it_root      = lt_tor_root
        it_stop      = lt_stop
        it_stop_succ = lt_stop_succ
      IMPORTING
        et_stop_seq  = lt_stop_sorted ).
    lt_stop_sstring = CORRESPONDING #( lt_stop_sorted MAPPING node_id = stop_key parent_node_id = root_key ).
    INSERT LINES OF lt_stop_sstring INTO TABLE ct_stop_sstring.

    lo_tor_srv_mgr->retrieve_by_association(
      EXPORTING
        iv_node_key     = /scmtms/if_tor_c=>sc_node-root
        iv_before_image = abap_true
        it_key          = lt_fu_root_key
        iv_association  = /scmtms/if_tor_c=>sc_association-root-stop
        iv_fill_data    = abap_true
      IMPORTING
        et_data         = lt_stop_before ).
    lt_stop_sstring = CORRESPONDING #( lt_stop_before MAPPING node_id = key parent_node_id = parent_key ).
    INSERT LINES OF lt_stop_before_sstring INTO TABLE ct_stop_before_sstring.


    get_stop_postal_addr_info(
      EXPORTING
        it_stop                  = lt_stop
      IMPORTING
        et_stop_postal_addr_info = DATA(lt_stop_postal_addr_info) ).
    LOOP AT lt_stop_postal_addr_info ASSIGNING FIELD-SYMBOL(<ls_stop_addr>).
      MOVE-CORRESPONDING <ls_stop_addr>                       TO ls_stop_addr_sstring. ""#EC ENHOK
      MOVE-CORRESPONDING <ls_stop_addr>-stop_postal_addr_info TO ls_stop_addr_sstring. ""#EC ENHOK
      ls_stop_addr_sstring-parent_node_id = <ls_stop_addr>-stop_postal_addr_info-root_key.
      ls_stop_addr_sstring-node_id        = <ls_stop_addr>-stop_postal_addr_info-key.
      INSERT ls_stop_addr_sstring INTO TABLE ct_stop_addr_sstring.
    ENDLOOP.


    lo_tor_srv_mgr->retrieve_by_association(
      EXPORTING
        iv_node_key    = /scmtms/if_tor_c=>sc_node-root
        it_key         = lt_fu_root_key
        iv_association = /scmtms/if_tor_c=>sc_association-root-tendering
        iv_fill_data   = abap_true
      IMPORTING
        et_data        = lt_tendering ).
    lt_tendering_sstring = CORRESPONDING #( lt_tendering MAPPING node_id = key parent_node_id = parent_key ).
    INSERT LINES OF lt_tendering_sstring INTO TABLE ct_tendering_sstring.


    lo_tor_srv_mgr->retrieve_by_association(
      EXPORTING
        iv_node_key    = /scmtms/if_tor_c=>sc_node-root
        it_key         = lt_fu_root_key
        iv_association = /scmtms/if_tor_c=>sc_association-root-party
        iv_fill_data   = abap_true
      IMPORTING
        et_data        = lt_party ).
    lt_party_sstring = CORRESPONDING #( lt_party MAPPING node_id = key parent_node_id = parent_key ).
    INSERT LINES OF lt_party_sstring INTO TABLE ct_party_sstring.


    lo_tor_srv_mgr->retrieve_by_association(
      EXPORTING
        iv_node_key     = /scmtms/if_tor_c=>sc_node-root
        iv_before_image = abap_true
        it_key          = lt_fu_root_key
        iv_association  = /scmtms/if_tor_c=>sc_association-root-capa_tor
        iv_fill_data    = abap_true
      IMPORTING
        et_target_key   = DATA(lt_capa_root_key)
        et_data         = lt_capa_root ).
    lt_capa_root_sstring = CORRESPONDING #( lt_capa_root MAPPING node_id = key ).
    INSERT LINES OF lt_capa_root_sstring INTO TABLE ct_capa_root_sstring.


    lo_tor_srv_mgr->retrieve_by_association(
      EXPORTING
        iv_node_key     = /scmtms/if_tor_c=>sc_node-root
        iv_before_image = abap_true
        it_key          = lt_fu_root_key
        iv_association  = /scmtms/if_tor_c=>sc_association-root-capa_tor
        iv_fill_data    = abap_true
     IMPORTING
        et_data         = lt_capa_root_before ).
    lt_capa_root_before_sstring = CORRESPONDING #( lt_capa_root_before MAPPING node_id = key ).
    INSERT LINES OF lt_capa_root_before_sstring INTO TABLE ct_capa_root_bef_sstring.


    lo_tor_srv_mgr->retrieve_by_association(
      EXPORTING
        iv_node_key     = /scmtms/if_tor_c=>sc_node-root
        iv_before_image = abap_true
        it_key          = lt_capa_root_key
        iv_association  = /scmtms/if_tor_c=>sc_association-root-stop
        iv_fill_data    = abap_true
      IMPORTING
        et_data         = lt_capa_stop ).
    lt_capa_stop_sstring = CORRESPONDING #( lt_capa_stop MAPPING node_id = key parent_node_id = parent_key ).
    INSERT LINES OF lt_capa_stop_sstring INTO TABLE ct_capa_stop_sstring.


  ENDMETHOD.


  METHOD call_event_manager.

    DATA:
      lt_tor_root_sstring_tmp        TYPE /scmtms/t_em_bo_tor_root,
      lt_item_sstring_tmp            TYPE /scmtms/t_em_bo_tor_item,
      lt_stop_sstring_tmp            TYPE /scmtms/t_em_bo_tor_stop,
      lt_stop_succ_sstring_tmp       TYPE /scmtms/t_em_bo_tor_stop_succ,
      lt_party_sstring_tmp           TYPE /scmtms/t_em_bo_tor_party,
      lt_location_log_sstring_tmp    TYPE /scmtms/t_em_bo_loc_root,
      lt_location_addr_sstring_tmp   TYPE /scmtms/t_em_bo_loc_root,
      lt_tor_root_before_sstring_tmp TYPE /scmtms/t_em_bo_tor_root,
      lt_stop_before_sstring_tmp     TYPE /scmtms/t_em_bo_tor_stop,
      lt_stop_addr_sstring_tmp       TYPE /scmtms/t_em_bo_loc_addr,
      lt_trq_root_sstring_tmp        TYPE /scmtms/t_em_bo_trq_root,
      lt_trq_root_before_sstring_tmp TYPE /scmtms/t_em_bo_trq_root,
      lt_capa_root_sstring_tmp       TYPE /scmtms/t_em_bo_tor_root,
      lt_capa_root_bef_sstring_tmp   TYPE /scmtms/t_em_bo_tor_root,
      lt_execinfo_sstring_tmp        TYPE /scmtms/t_em_bo_tor_execinfo,
      lt_execinfo_before_sstring_tmp TYPE /scmtms/t_em_bo_tor_execinfo,
      lt_tendering_sstring_tmp       TYPE /scmtms/t_em_bo_tor_tend,
      lt_item_before_sstring_tmp     TYPE /scmtms/t_em_bo_tor_item,
      lt_req_root_sstring_tmp        TYPE /scmtms/t_em_bo_tor_root,
      lt_req_root_before_sstring_tmp TYPE /scmtms/t_em_bo_tor_root,
      lt_req_tu_root_sstring_tmp     TYPE /scmtms/t_em_bo_tor_root,
      lt_req_tu_root_bef_sstring_tmp TYPE /scmtms/t_em_bo_tor_root,
      lt_req_stop_sstring_tmp        TYPE /scmtms/t_em_bo_tor_stop,
      lt_req_tu_stop_sstring_tmp     TYPE /scmtms/t_em_bo_tor_stop,
      lt_capa_stop_sstring_tmp       TYPE /scmtms/t_em_bo_tor_stop,
      lt_tabcont                     TYPE trxas_tabcontainer.

    SORT it_execinfo_sstring            BY parent_node_id event_code.
    SORT it_execinfo_before_sstring     BY parent_node_id event_code.

    LOOP AT it_tor_root_sstring ASSIGNING FIELD-SYMBOL(<ls_tor_root>).
      <ls_tor_root>-tor_root_node = <ls_tor_root>-node_id.
    ENDLOOP.

    IF it_tor_root_for_deletion IS INITIAL.
      lt_tor_root_sstring_tmp        = it_tor_root_sstring.
      lt_item_sstring_tmp            = it_item_sstring.
      lt_stop_sstring_tmp            = it_stop_sstring.
      lt_stop_succ_sstring_tmp       = it_stop_succ_sstring.
      lt_party_sstring_tmp           = it_party_sstring.
      lt_location_log_sstring_tmp    = it_location_log_sstring.
      lt_location_addr_sstring_tmp   = it_location_addr_sstring.
      lt_tor_root_before_sstring_tmp = it_tor_root_before_sstring.
      lt_stop_before_sstring_tmp     = it_stop_before_sstring.
      lt_stop_addr_sstring_tmp       = it_stop_addr_sstring.
      lt_trq_root_sstring_tmp        = it_trq_root_sstring.
      lt_trq_root_before_sstring_tmp = it_trq_root_before_sstring.
      lt_capa_root_sstring_tmp       = it_capa_root_sstring.
      lt_capa_root_bef_sstring_tmp   = it_capa_root_bef_sstring.
      lt_execinfo_sstring_tmp        = it_execinfo_sstring.
      lt_execinfo_before_sstring_tmp = it_execinfo_before_sstring.
      lt_tendering_sstring_tmp       = it_tendering_sstring.
      lt_item_before_sstring_tmp     = it_item_before_sstring.
      lt_req_root_sstring_tmp        = it_req_root_sstring.
      lt_req_root_before_sstring_tmp = it_req_root_before_sstring.
      lt_req_tu_root_sstring_tmp     = it_req_tu_root_sstring.
      lt_req_tu_root_bef_sstring_tmp = it_req_tu_root_bef_sstring.
      lt_req_stop_sstring_tmp        = it_req_stop_sstring.
      lt_req_tu_stop_sstring_tmp     = it_req_tu_stop_sstring.
      lt_capa_stop_sstring_tmp       = it_capa_stop_sstring.
    ELSE.
      SORT it_tor_root_sstring            BY node_id ASCENDING.
      SORT it_item_sstring                BY parent_node_id ASCENDING.
      SORT it_stop_sstring                BY parent_node_id ASCENDING.
      SORT it_stop_succ_sstring           BY parent_node_id ASCENDING.
      SORT it_party_sstring               BY parent_node_id ASCENDING.
      SORT it_tor_root_before_sstring     BY node_id ASCENDING.
      SORT it_stop_before_sstring         BY parent_node_id ASCENDING.
      SORT it_stop_addr_sstring           BY parent_node_id ASCENDING.
      SORT it_trq_root_sstring            BY tor_root_node ASCENDING.
      SORT it_trq_root_before_sstring     BY tor_root_node ASCENDING.
      SORT it_capa_root_sstring           BY tor_root_node ASCENDING.
      SORT it_capa_root_bef_sstring       BY tor_root_node ASCENDING.
      SORT it_execinfo_sstring            BY parent_node_id ASCENDING.
      SORT it_execinfo_before_sstring     BY parent_node_id ASCENDING.
      SORT it_tendering_sstring           BY parent_node_id ASCENDING.
      SORT it_item_before_sstring         BY parent_node_id ASCENDING.
      SORT it_req_root_sstring            BY node_id ASCENDING.
      SORT it_req_root_before_sstring     BY node_id ASCENDING.
      SORT it_req_tu_root_sstring         BY node_id ASCENDING.
      SORT it_req_tu_root_bef_sstring     BY node_id ASCENDING.
      SORT it_req_stop_sstring            BY parent_node_id.
      SORT it_req_tu_stop_sstring         BY parent_node_id.
      SORT it_capa_stop_sstring           BY node_id.

      lt_capa_root_sstring_tmp     = it_capa_root_sstring.
      lt_capa_root_bef_sstring_tmp = it_capa_root_bef_sstring.
      lt_location_log_sstring_tmp  = it_location_log_sstring.""-> send all
      lt_location_addr_sstring_tmp = it_location_addr_sstring.""-> send all
      lt_stop_addr_sstring_tmp     = it_stop_addr_sstring.
      lt_capa_stop_sstring_tmp     = it_capa_stop_sstring.

      LOOP AT it_tor_root_sstring ASSIGNING FIELD-SYMBOL(<ls_tor_root_sstring>).

        CHECK NOT line_exists( it_tor_root_for_deletion[ node_id = <ls_tor_root_sstring>-node_id ] ).

        APPEND <ls_tor_root_sstring> TO lt_tor_root_sstring_tmp.

        READ TABLE it_item_sstring WITH KEY parent_node_track_rel
          COMPONENTS parent_node_id = <ls_tor_root_sstring>-node_id TRANSPORTING NO FIELDS.
        LOOP AT it_item_sstring FROM sy-tabix ASSIGNING FIELD-SYMBOL(<ls_item_sstring>).
          IF <ls_item_sstring>-parent_node_id = <ls_tor_root_sstring>-node_id.
            APPEND <ls_item_sstring> TO lt_item_sstring_tmp.
          ELSE.
            EXIT.
          ENDIF.
        ENDLOOP.

        READ TABLE it_stop_sstring WITH KEY parent_seqnum
          COMPONENTS parent_node_id = <ls_tor_root_sstring>-node_id TRANSPORTING NO FIELDS.
        LOOP AT it_stop_sstring FROM sy-tabix ASSIGNING FIELD-SYMBOL(<ls_stop_sstring>).
          IF <ls_stop_sstring>-parent_node_id = <ls_tor_root_sstring>-node_id.
            APPEND <ls_stop_sstring> TO lt_stop_sstring_tmp.
          ELSE.
            EXIT.
          ENDIF.
        ENDLOOP.

        READ TABLE it_stop_succ_sstring WITH KEY parent_node_id = <ls_tor_root_sstring>-node_id TRANSPORTING NO FIELDS.
        LOOP AT it_stop_succ_sstring FROM sy-tabix ASSIGNING FIELD-SYMBOL(<ls_stop_succ_sstring>).
          IF <ls_stop_succ_sstring>-parent_node_id = <ls_tor_root_sstring>-node_id.
            APPEND <ls_stop_succ_sstring> TO lt_stop_succ_sstring_tmp.
          ELSE.
            EXIT.
          ENDIF.
        ENDLOOP.

        READ TABLE it_party_sstring WITH KEY parent_node_id = <ls_tor_root_sstring>-node_id TRANSPORTING NO FIELDS.
        LOOP AT it_party_sstring FROM sy-tabix ASSIGNING FIELD-SYMBOL(<ls_party_sstring>).
          IF <ls_party_sstring>-parent_node_id = <ls_tor_root_sstring>-node_id.
            APPEND <ls_party_sstring> TO lt_party_sstring_tmp.
          ELSE.
            EXIT.
          ENDIF.
        ENDLOOP.

        READ TABLE it_tor_root_before_sstring WITH KEY node_id = <ls_tor_root_sstring>-node_id TRANSPORTING NO FIELDS.
        LOOP AT it_tor_root_before_sstring FROM sy-tabix ASSIGNING FIELD-SYMBOL(<ls_tor_root_before_sstring>).
          IF <ls_tor_root_before_sstring>-node_id = <ls_tor_root_sstring>-node_id.
            APPEND <ls_tor_root_before_sstring> TO lt_tor_root_before_sstring_tmp.
          ELSE.
            EXIT.
          ENDIF.
        ENDLOOP.

        READ TABLE it_stop_before_sstring WITH KEY parent_seqnum
          COMPONENTS parent_node_id = <ls_tor_root_sstring>-node_id TRANSPORTING NO FIELDS.
        LOOP AT it_stop_before_sstring FROM sy-tabix ASSIGNING FIELD-SYMBOL(<ls_stop_before_sstring>).
          IF <ls_stop_before_sstring>-parent_node_id = <ls_tor_root_sstring>-node_id.
            APPEND <ls_stop_before_sstring> TO lt_stop_before_sstring_tmp.
          ELSE.
            EXIT.
          ENDIF.
        ENDLOOP.

        READ TABLE it_trq_root_sstring WITH KEY tor_root_node = <ls_tor_root_sstring>-node_id TRANSPORTING NO FIELDS.
        LOOP AT it_trq_root_sstring FROM sy-tabix ASSIGNING FIELD-SYMBOL(<ls_trq_root_sstring>).
          IF <ls_trq_root_sstring>-tor_root_node = <ls_tor_root_sstring>-node_id.
            APPEND <ls_trq_root_sstring> TO lt_trq_root_sstring_tmp.
          ELSE.
            EXIT.
          ENDIF.
        ENDLOOP.

        READ TABLE it_trq_root_before_sstring WITH KEY tor_root_node = <ls_tor_root_sstring>-node_id TRANSPORTING NO FIELDS.
        LOOP AT it_trq_root_before_sstring FROM sy-tabix ASSIGNING FIELD-SYMBOL(<ls_trq_root_before_sstring>).
          IF <ls_trq_root_before_sstring>-tor_root_node = <ls_tor_root_sstring>-node_id.
            APPEND <ls_trq_root_before_sstring> TO lt_trq_root_before_sstring_tmp.
          ELSE.
            EXIT.
          ENDIF.
        ENDLOOP.

        READ TABLE  it_execinfo_sstring WITH KEY parent_node_id = <ls_tor_root_sstring>-node_id TRANSPORTING NO FIELDS.
        LOOP AT it_execinfo_sstring FROM sy-tabix ASSIGNING FIELD-SYMBOL(<ls_execinfo_sstring>).
          IF <ls_execinfo_sstring>-parent_node_id = <ls_tor_root_sstring>-node_id.
            APPEND <ls_execinfo_sstring> TO lt_execinfo_sstring_tmp.
          ELSE.
            EXIT.
          ENDIF.
        ENDLOOP.

        READ TABLE it_execinfo_before_sstring WITH KEY parent_node_id = <ls_tor_root_sstring>-node_id TRANSPORTING NO FIELDS.
        LOOP AT it_execinfo_before_sstring FROM sy-tabix ASSIGNING FIELD-SYMBOL(<ls_execinfo_before_sstring>).
          IF <ls_execinfo_before_sstring>-parent_node_id = <ls_tor_root_sstring>-node_id.
            APPEND <ls_execinfo_before_sstring> TO lt_execinfo_before_sstring_tmp.
          ELSE.
            EXIT.
          ENDIF.
        ENDLOOP.

        READ TABLE it_tendering_sstring WITH KEY parent_node_id = <ls_tor_root_sstring>-node_id TRANSPORTING NO FIELDS.
        LOOP AT it_tendering_sstring FROM sy-tabix ASSIGNING FIELD-SYMBOL(<ls_tendering_sstring>).
          IF <ls_tendering_sstring>-parent_node_id = <ls_tor_root_sstring>-node_id.
            APPEND <ls_tendering_sstring> TO lt_tendering_sstring_tmp.
          ELSE.
            EXIT.
          ENDIF.
        ENDLOOP.

        READ TABLE it_item_before_sstring WITH KEY parent_node_track_rel
          COMPONENTS parent_node_id = <ls_tor_root_sstring>-node_id TRANSPORTING NO FIELDS.
        LOOP AT it_item_before_sstring FROM sy-tabix ASSIGNING FIELD-SYMBOL(<ls_item_before_sstring>).
          IF <ls_item_before_sstring>-parent_node_id = <ls_tor_root_sstring>-node_id.
            APPEND <ls_item_before_sstring> TO lt_item_before_sstring_tmp.
          ELSE.
            EXIT.
          ENDIF.
        ENDLOOP.

        READ TABLE it_req_root_sstring WITH KEY tor_root_node = <ls_tor_root_sstring>-node_id TRANSPORTING NO FIELDS.
        LOOP AT it_req_root_sstring FROM sy-tabix ASSIGNING FIELD-SYMBOL(<ls_req_root_sstring>).
          IF <ls_req_root_sstring>-tor_root_node = <ls_tor_root_sstring>-node_id.
            APPEND <ls_req_root_sstring> TO lt_req_root_sstring_tmp.
            READ TABLE it_req_stop_sstring WITH KEY parent_seqnum
              COMPONENTS parent_node_id = <ls_req_root_sstring>-node_id TRANSPORTING NO FIELDS.
            LOOP AT it_req_stop_sstring FROM sy-tabix ASSIGNING FIELD-SYMBOL(<ls_req_stop_sstring_tmp>).
              IF <ls_req_stop_sstring_tmp>-parent_node_id = <ls_req_root_sstring>-node_id.
                INSERT <ls_req_stop_sstring_tmp> INTO TABLE lt_req_stop_sstring_tmp.
              ELSE.
                EXIT.
              ENDIF.
            ENDLOOP.
          ELSE.
            EXIT.
          ENDIF.
        ENDLOOP.

        READ TABLE it_req_root_before_sstring WITH KEY tor_root_node = <ls_tor_root_sstring>-node_id TRANSPORTING NO FIELDS.
        LOOP AT it_req_root_before_sstring FROM sy-tabix ASSIGNING FIELD-SYMBOL(<ls_req_root_before_sstring>).
          IF <ls_req_root_before_sstring>-tor_root_node = <ls_tor_root_sstring>-node_id.
            APPEND <ls_req_root_before_sstring> TO lt_req_root_before_sstring_tmp.
          ELSE.
            EXIT.
          ENDIF.
        ENDLOOP.

        READ TABLE it_req_tu_root_sstring WITH KEY node_id = <ls_tor_root_sstring>-node_id TRANSPORTING NO FIELDS.
        LOOP AT it_req_tu_root_sstring FROM sy-tabix ASSIGNING FIELD-SYMBOL(<ls_req_tu_root_sstring>).
          IF <ls_req_tu_root_sstring>-node_id = <ls_tor_root_sstring>-node_id.
            APPEND <ls_req_tu_root_sstring> TO lt_req_tu_root_sstring_tmp.
            READ TABLE it_req_tu_stop_sstring WITH KEY parent_seqnum
              COMPONENTS parent_node_id = <ls_req_tu_root_sstring>-node_id TRANSPORTING NO FIELDS.
            LOOP AT it_req_tu_stop_sstring FROM sy-tabix ASSIGNING FIELD-SYMBOL(<ls_req_tu_stop_sstring_tmp>).
              IF <ls_req_tu_stop_sstring_tmp>-parent_node_id = <ls_req_tu_root_sstring>-node_id.
                INSERT <ls_req_tu_stop_sstring_tmp> INTO TABLE lt_req_tu_stop_sstring_tmp.
              ELSE.
                EXIT.
              ENDIF.
            ENDLOOP.
          ELSE.
            EXIT.
          ENDIF.
        ENDLOOP.

        READ TABLE it_req_tu_root_bef_sstring WITH KEY node_id = <ls_tor_root_sstring>-node_id TRANSPORTING NO FIELDS.
        LOOP AT it_req_tu_root_bef_sstring FROM sy-tabix ASSIGNING FIELD-SYMBOL(<ls_req_tu_root_before_sstr>).
          IF <ls_req_tu_root_before_sstr>-node_id = <ls_tor_root_sstring>-node_id.
            APPEND <ls_req_tu_root_before_sstr> TO lt_req_tu_root_bef_sstring_tmp.
          ELSE.
            EXIT.
          ENDIF.
        ENDLOOP.

      ENDLOOP. ""LOOP AT lt_root_sstring_tmp
    ENDIF.

    CALL FUNCTION '/SAPTRX/EVENT_MGR_FILL_TABCONT'
      EXPORTING
        tabledef1          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-root
        tabledef2          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-item
        tabledef3          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-stop
        tabledef4          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-stop_successor
        tabledef5          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-party
        tabledef6          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-location_log
        tabledef7          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-location_addr
        tabledef8          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-root_before
        tabledef9          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-stop_before
        opt_init_container = 'X'
      TABLES
        table1             = lt_tor_root_sstring_tmp
        table2             = lt_item_sstring_tmp
        table3             = lt_stop_sstring_tmp
        table4             = lt_stop_succ_sstring_tmp
        table5             = lt_party_sstring_tmp
        table6             = lt_location_log_sstring_tmp
        table7             = lt_location_addr_sstring_tmp
        table8             = lt_tor_root_before_sstring_tmp
        table9             = lt_stop_before_sstring_tmp
      CHANGING
        table_container    = lt_tabcont.

    CALL FUNCTION '/SAPTRX/EVENT_MGR_FILL_TABCONT'
      EXPORTING
        tabledef1          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-stop_addr
        tabledef2          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_trq-root
        tabledef3          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_trq-root_before
        tabledef4          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-capa_root
        tabledef5          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-capa_root_before
        tabledef6          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-execinfo
        tabledef7          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-execinfo_before
        tabledef8          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-tendering
        tabledef9          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-item_before
        opt_init_container = ' '
      TABLES
        table1             = lt_stop_addr_sstring_tmp
        table2             = lt_trq_root_sstring_tmp
        table3             = lt_trq_root_before_sstring_tmp
        table4             = lt_capa_root_sstring_tmp
        table5             = lt_capa_root_bef_sstring_tmp
        table6             = lt_execinfo_sstring_tmp
        table7             = lt_execinfo_before_sstring_tmp
        table8             = lt_tendering_sstring_tmp
        table9             = lt_item_before_sstring_tmp
      CHANGING
        table_container    = lt_tabcont.

    CALL FUNCTION '/SAPTRX/EVENT_MGR_FILL_TABCONT'
      EXPORTING
        tabledef1          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-req_root
        tabledef2          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-req_root_before
        tabledef3          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-created_keys
        tabledef4          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-req_tu_root
        tabledef5          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-req_tu_root_before
        tabledef6          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-req_stop
        tabledef7          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-req_tu_stop
        tabledef8          = /scmtms/cl_scem_int_c=>sc_table_definition-bo_tor-capa_stop
        opt_init_container = ' '
      TABLES
        table1             = lt_req_root_sstring_tmp
        table2             = lt_req_root_before_sstring_tmp
        table3             = it_tor_created_keys
        table4             = lt_req_tu_root_sstring_tmp
        table5             = lt_req_tu_root_bef_sstring_tmp
        table6             = lt_req_stop_sstring_tmp
        table7             = lt_req_tu_stop_sstring_tmp
        table8             = lt_capa_stop_sstring_tmp
      CHANGING
        table_container    = lt_tabcont.

    IF lt_tabcont IS INITIAL.
      RETURN.
    ENDIF.

    CALL FUNCTION '/SAPTRX/EVENT_MGR_COMMUNICATE'
      EXPORTING
        business_process_type   = 'TMS_TOR'
        table_container         = lt_tabcont
      EXCEPTIONS
        parameter_error         = 1
        emr_determination_error = 2
        not_em_relevant         = 3
        log_system_error        = 4
        bpt_deactivated         = 5
        OTHERS                  = 6.
    DATA(lv_subrc) = sy-subrc.
    IF sy-subrc = 1.
      RAISE EXCEPTION TYPE /scmtms/cx_event_management
        EXPORTING
          textid = /scmtms/cx_event_management=>em_processing_parameter_err.
    ELSEIF sy-subrc = 4.
      RAISE EXCEPTION TYPE /scmtms/cx_event_management
        EXPORTING
          textid = /scmtms/cx_event_management=>em_processing_log_system.
    ELSEIF sy-subrc = 5.
      RAISE EXCEPTION TYPE /scmtms/cx_event_management
        EXPORTING
          textid = /scmtms/cx_event_management=>em_processing_bpt_deactivated.
    ELSEIF sy-subrc > 5.
      RAISE EXCEPTION TYPE /scmtms/cx_event_management
        EXPORTING
          textid  = /scmtms/cx_event_management=>em_processing_failed
          errcode = lv_subrc.
    ENDIF.

  ENDMETHOD.


  METHOD get_stop_postal_addr_info.

    DATA:
      lv_nation                  TYPE ad_nation,
      lv_formatted1              TYPE ad_line_s,
      lv_do_root_addr_key        TYPE /bobf/obm_node_key,
      lv_do_root_postal_addr_asc TYPE /bobf/obm_assoc_key,
      ls_stop_postal_addr_info   TYPE ty_tor_stop_address,
      lt_location_key            TYPE /bobf/t_frw_key,
      lt_adr_location_key        TYPE /bobf/t_frw_key,
      lt_address_root            TYPE /bofu/t_addr_addressi_k,
      lt_target_key              TYPE /bobf/t_frw_key,
      lt_postal_address          TYPE /bofu/t_addr_postal_addressk,
      lr_address_root            TYPE REF TO /bofu/s_addr_addressi_k.

    CLEAR et_stop_postal_addr_info.

    DATA(lo_loc_srv_mgr) = /bobf/cl_tra_serv_mgr_factory=>get_service_manager(
                                                              iv_bo_key = /scmtms/if_location_c=>sc_bo_key ).

    LOOP AT it_stop ASSIGNING FIELD-SYMBOL(<ls_stop>).

      /scmtms/cl_common_helper=>check_insert_key(
        EXPORTING
          iv_key = <ls_stop>-log_loc_uuid
        CHANGING
          ct_key = lt_location_key ).

      IF <ls_stop>-adr_loc_uuid IS NOT INITIAL.
        /scmtms/cl_common_helper=>check_insert_key(
          EXPORTING
            iv_key = <ls_stop>-adr_loc_uuid
          CHANGING
            ct_key = lt_adr_location_key ).
      ENDIF.
    ENDLOOP.

    lo_loc_srv_mgr->retrieve_by_association(
      EXPORTING
        iv_node_key    = /scmtms/if_location_c=>sc_node-root
        it_key         = lt_location_key
        iv_association = /scmtms/if_location_c=>sc_association-root-address
        iv_fill_data   = abap_true
      IMPORTING
        et_data        = lt_address_root
        et_target_key  = lt_target_key ).

    /scmtms/cl_common_helper=>get_do_entity_key(
      EXPORTING
        iv_host_bo_key      = /scmtms/if_location_c=>sc_bo_key
        iv_host_do_node_key = /scmtms/if_location_c=>sc_node-/bofu/address
        iv_do_entity_key    = /bofu/if_addr_constants=>sc_node-root
      RECEIVING
        rv_entity_key       = lv_do_root_addr_key ).

    /scmtms/cl_common_helper=>get_do_keys_4_rba(
      EXPORTING
        iv_host_bo_key      = /scmtms/if_location_c=>sc_bo_key
        iv_host_do_node_key = /scmtms/if_location_c=>sc_node-/bofu/address
        iv_do_node_key      = /bofu/if_addr_constants=>sc_node-postal_address
        iv_do_assoc_key     = /bofu/if_addr_constants=>sc_association-root-postal_address
      IMPORTING
        ev_assoc_key        = lv_do_root_postal_addr_asc ).

    lo_loc_srv_mgr->retrieve_by_association(
      EXPORTING
        iv_node_key    = lv_do_root_addr_key
        it_key         = lt_target_key
        iv_association = lv_do_root_postal_addr_asc
        iv_fill_data   = abap_true
      IMPORTING
        et_data        = lt_postal_address ).

    CALL FUNCTION 'ADDR_LANGUAGE_MAP_TO_VERSION'
      EXPORTING
        iv_language              = sy-langu
        iv_application_component = 'BU_ADDRVERS_MAP'
      IMPORTING
        ev_nation                = lv_nation
      EXCEPTIONS
        OTHERS                   = 0.

    LOOP AT lt_postal_address REFERENCE INTO DATA(lr_postal_address).
      ls_stop_postal_addr_info-stop_postal_addr_info-root_key   = lr_postal_address->root_key.
      ls_stop_postal_addr_info-stop_postal_addr_info-parent_key = lr_postal_address->parent_key.
      ls_stop_postal_addr_info-stop_postal_addr_info-key        = lr_postal_address->parent_key.

      ls_stop_postal_addr_info-stop_postal_addr_info-s_data-country_code        = lr_postal_address->country_code.
      ls_stop_postal_addr_info-stop_postal_addr_info-s_data-region              = lr_postal_address->region.
      ls_stop_postal_addr_info-stop_postal_addr_info-s_data-city_name           = lr_postal_address->city_name.
      ls_stop_postal_addr_info-stop_postal_addr_info-s_data-street_postal_code  = lr_postal_address->street_postal_code.
      ls_stop_postal_addr_info-stop_postal_addr_info-s_data-street_name         = lr_postal_address->street_name.
      ls_stop_postal_addr_info-stop_postal_addr_info-s_data-house_id            = lr_postal_address->house_id.
      ls_stop_postal_addr_info-stop_postal_addr_info-s_data-street              = lr_postal_address->street.
      ls_stop_postal_addr_info-stop_postal_addr_info-s_data-building_id         = lr_postal_address->building_id.
      ls_stop_postal_addr_info-stop_postal_addr_info-s_data-time_zone_code      = lr_postal_address->time_zone_code.

      READ TABLE lt_address_root WITH KEY key = lr_postal_address->parent_key REFERENCE INTO lr_address_root.

      CALL FUNCTION 'ADDRESS_INTO_PRINTFORM'
        EXPORTING
          address_type               = '1'
          address_number             = lr_address_root->postal_address_id
          number_of_lines            = 3
          street_has_priority        = abap_true
          no_upper_case_for_city     = abap_true
          iv_nation                  = lv_nation
        IMPORTING
          address_short_form_wo_name = lv_formatted1.
      ls_stop_postal_addr_info-formatted_postal_address_descr = lv_formatted1.
      INSERT ls_stop_postal_addr_info INTO TABLE et_stop_postal_addr_info.
    ENDLOOP.

  ENDMETHOD.


  METHOD get_tor_root_for_deletion.

    CLEAR et_tor_root_for_deletion.

    LOOP AT it_tor_root_sstring ASSIGNING FIELD-SYMBOL(<ls_tor_root_sstring>).

      ASSIGN it_tor_root_before_sstring[ node_id = <ls_tor_root_sstring>-node_id ]
        TO FIELD-SYMBOL(<ls_tor_root_before_sstring>).
      CHECK sy-subrc = 0.

      DATA(lv_carrier_removed) = xsdbool(
        <ls_tor_root_sstring>-tsp IS INITIAL AND <ls_tor_root_before_sstring>-tsp IS NOT INITIAL ).

      DATA(lv_execution_status_changed) = xsdbool(
        ( <ls_tor_root_sstring>-execution <> /scmtms/if_tor_status_c=>sc_root-execution-v_in_execution        AND
          <ls_tor_root_sstring>-execution <> /scmtms/if_tor_status_c=>sc_root-execution-v_ready_for_execution AND
          <ls_tor_root_sstring>-execution <> /scmtms/if_tor_status_c=>sc_root-execution-v_executed ) AND
        ( <ls_tor_root_before_sstring>-execution = /scmtms/if_tor_status_c=>sc_root-execution-v_in_execution        OR
          <ls_tor_root_before_sstring>-execution = /scmtms/if_tor_status_c=>sc_root-execution-v_ready_for_execution OR
          <ls_tor_root_before_sstring>-execution = /scmtms/if_tor_status_c=>sc_root-execution-v_executed ) ).

      DATA(lv_lifecycle_status_changed) = xsdbool(
        ( <ls_tor_root_sstring>-lifecycle <> /scmtms/if_tor_status_c=>sc_root-lifecycle-v_in_process AND
          <ls_tor_root_sstring>-lifecycle <> /scmtms/if_tor_status_c=>sc_root-lifecycle-v_completed ) AND
        ( <ls_tor_root_before_sstring>-lifecycle = /scmtms/if_tor_status_c=>sc_root-lifecycle-v_in_process OR
          <ls_tor_root_before_sstring>-lifecycle = /scmtms/if_tor_status_c=>sc_root-lifecycle-v_completed ) ).

      CASE <ls_tor_root_sstring>-tor_cat.
        WHEN /scmtms/if_tor_const=>sc_tor_category-active OR
             /scmtms/if_tor_const=>sc_tor_category-booking.

          IF lv_carrier_removed = abap_true OR
             lv_execution_status_changed = abap_true OR
             lv_lifecycle_status_changed = abap_true.
            INSERT <ls_tor_root_sstring> INTO TABLE et_tor_root_for_deletion.

          ENDIF.

        WHEN /scmtms/if_tor_const=>sc_tor_category-freight_unit.

          IF <ls_tor_root_sstring>-lifecycle = /scmtms/if_tor_status_c=>sc_root-lifecycle-v_canceled.
            INSERT <ls_tor_root_sstring> INTO TABLE et_tor_root_for_deletion.
          ENDIF.

        WHEN OTHERS.
          CONTINUE.
      ENDCASE.

    ENDLOOP.

  ENDMETHOD.


  METHOD send_deletion_idoc.

    IF it_tor_root IS INITIAL.
      RETURN.
    ENDIF.
    TRY.
        DATA(lo_send_deletion_idoc) = zcl_gtt_sts_send_deletion_idoc=>get_instance( it_tor_root ).
        lo_send_deletion_idoc->prepare_idoc_data( it_tor_root ).
        lo_send_deletion_idoc->send_idoc_data( ).
      CATCH cx_udm_message.
        RAISE EXCEPTION TYPE /scmtms/cx_event_management
          EXPORTING
            textid = /scmtms/cx_event_management=>em_processing_failed.
    ENDTRY.

  ENDMETHOD.
ENDCLASS.
",13030,True,2808.7340746592054,median
":tag1: geek

RaspBerry Pi 七宗罪，Pi 极为不靠谱的测评报告
============================================


===============
2.29 号下单的 RaspBerry PI (以下简称 RPI) 终于在 5.30 号到了，何等漫长的等待阿... 闲话少说，使用了快一个月，列举一下 RPI 的数宗罪
===============

== 外壳 ==

RPI 只提供裸版，各路豪杰都在给 RPI DIY 外壳，但是这个外壳确实不是一件容易的事情，Dell 的服务器部门有超过一半的科研经费花在机箱内部布局以及供电和散热上。RPI 的供电和散热都没有，而供电和散热，却又是 RPI 最严重的问题，后面会抱怨更多跟供电和散热有关的问题。由于没有外壳，在给 RPI 拔插设备的时候，就很难下手，只能按住接地的部分操作，而且上面突出的针脚又很多，稍不小心就会碰到某些阵脚，导致重启/死机/无法启动等问题。回去买一桶乐高积木，搭一个外壳出来试试。

== Bootloader ==

RPI 由于没有集成存储芯片(节约成本)，所以靠 SD 卡引导，但是支持众多型号的 SD 卡不是一件容易的事情。芯片中只提供了几百字节的 GPU 代码空间，用于从 SD 卡中加载 bootloader，所以就有一些型号的 SD 卡无法使用。但这还不是最严重的问题，当 RPI 无法启动的时候，就不得不排查很多问题，供电，SD卡，显示。普通的硬件产品，例如家用电脑，路由器，手机，都是有内部存储的，系统从内部存储引导，引导出错会给出出错信息用于排查错误。RPI 直接从外设引导，出问题排查时会有些麻烦，要尝试各种不同的电源，各种不同型号的 SD 卡，刷写不同的系统到 SD 卡上。

== CPU ==

RPI 的 CPU 标称 700 MHz ARM11，没有接触过 ARM 的可能不知道这个是什么概念，我们做一个简单的对比：

 * 2003 年主流配置，赛扬 1.7G，256MB 内存，编译内核：5～10 分钟
 * RPI，700 MHz ARM11，256MB 内存，编译内核：6 小时

RPI 刚出来的几天，众多 Geek 的 RPI 都在忙于编译内核，直到有人研究出来如何 CrossCompile，才把 RPI 从编译内核的苦海中解救出来

== RTC ==

RTC (Real-time clock) 是所有桌面/手持设备必备的部件，用于在系统启动的时候告诉系统当前时间。缺少 RTC 的系统在启动后无法获取当前时间，关机重启后系统时间就清零，给使用带来众多不便，虽然能够通过 NTP 启动后自动获取时间，但是没有网络的环境就悲剧了 (Model A 是不带以太网口的)。时间是系统中很重要的部分，很多服务都依赖时间，比如 802.1X，WPA2-enterprise，HTTPS，总之，需要使用证书认证的部分都将无法工作。RPI 不包含 RTC 的主要原因就是其成本太高了，需要 RTC 芯片以及一块在断电后仍能供电的电池，大概需要 3～5 刀 (RPI Model A $25)。

== USB ==

RPI 的 USB 是问题最严重的部分了，为了配合 RPI 的低功耗，板载的两个 USB 端口的输出功率被限制在 140mA 以下，就是说几乎全部的读卡器/外接硬盘/无线网卡都将无法使用。即使你的电源再牛逼，也无法把功率送到 USB 口。当然，没有 Geek 解决不了的问题，各路神仙都出现，自己 mod USB 供电电路。最简单的方法就是 link:http://www.raspberrypi.org/phpBB3/viewtopic.php?f=63&t=8591[直接短接 USB 电流限制部分] 。不过还有新问题，USB 是支持 HotPlug 的，当插入一个新 USB 设备的时候，会有很大的瞬间电流，而 RPI 的供电电路只有一个电容做缓冲，一旦这个电流超过此电容整流能力，会导致核心电压下降，结果就是导致重启。于是又有 Geek mod 了给一个 USB 供电的电容。道路真是坎坷阿，估计下个版本这些问题都会修正。

== 温度感应器 ==

pass:[<img src=""data:image/jpg;base64,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"" class=""img-polaroid"" style=""display: inline; float: right;"" />]

现在基本所有的家用 PC 内部都有数个温度感应器，分布在 CPU/GPU/电源/硬盘等重要部位。Intel CPU 内部的温度感应器甚至可以控制 CPU 运行频率，在温度低的时候如果有突发任务，可以短时间超频处理，超频幅度达到 3～4 倍（看我20倍界王拳，迷）。RPI 虽然功率很小，但是其芯片也非常小，热量有可能散发不出去，右边是某人给 CPU 和 Ethernet 芯片加了散热器。没有温度感应器，在芯片过热的情况下，可能会直接导致死机。RPI 论坛上已经有不少人在抱怨 RPI 无故死机的问题。

== 结论 ==

RPI 终归是个 Geek 的玩具，在 RPI 上面你会碰到各种各样没有遇到过的硬件问题，RPI 离产品化距离相当遥远。不过 RPI 的出现，应该能够推动低功耗，低成本家用设备的普及。StackOverflow 竟然开了  link:http://raspberrypi.stackexchange.com/[RPI 专版] ，我被雷到了。虽然 RPI 有这么多的缺点，但是 $35 买个玩具还是很值的。

",12206,True,4147.26887198257,median
"// Copyright 2010 the V8 project authors. All rights reserved.
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
//     * Redistributions of source code must retain the above copyright
//       notice, this list of conditions and the following disclaimer.
//     * Redistributions in binary form must reproduce the above
//       copyright notice, this list of conditions and the following
//       disclaimer in the documentation and/or other materials provided
//       with the distribution.
//     * Neither the name of Google Inc. nor the names of its
//       contributors may be used to endorse or promote products derived
//       from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// ""AS IS"" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

#include ""v8.h""

#if defined(V8_TARGET_ARCH_IA32)

#include ""codegen-inl.h""
#include ""ic-inl.h""
#include ""runtime.h""
#include ""stub-cache.h""
#include ""utils.h""

namespace v8 {
namespace internal {

// ----------------------------------------------------------------------------
// Static IC stub generators.
//

#define __ ACCESS_MASM(masm)


static void GenerateGlobalInstanceTypeCheck(MacroAssembler* masm,
                                            Register type,
                                            Label* global_object) {
  // Register usage:
  //   type: holds the receiver instance type on entry.
  __ cmp(type, JS_GLOBAL_OBJECT_TYPE);
  __ j(equal, global_object, not_taken);
  __ cmp(type, JS_BUILTINS_OBJECT_TYPE);
  __ j(equal, global_object, not_taken);
  __ cmp(type, JS_GLOBAL_PROXY_TYPE);
  __ j(equal, global_object, not_taken);
}


// Generated code falls through if the receiver is a regular non-global
// JS object with slow properties and no interceptors.
static void GenerateDictionaryLoadReceiverCheck(MacroAssembler* masm,
                                                Register receiver,
                                                Register r0,
                                                Register r1,
                                                Label* miss) {
  // Register usage:
  //   receiver: holds the receiver on entry and is unchanged.
  //   r0: used to hold receiver instance type.
  //       Holds the property dictionary on fall through.
  //   r1: used to hold receivers map.

  // Check that the receiver isn't a smi.
  __ test(receiver, Immediate(kSmiTagMask));
  __ j(zero, miss, not_taken);

  // Check that the receiver is a valid JS object.
  __ mov(r1, FieldOperand(receiver, HeapObject::kMapOffset));
  __ movzx_b(r0, FieldOperand(r1, Map::kInstanceTypeOffset));
  __ cmp(r0, FIRST_JS_OBJECT_TYPE);
  __ j(below, miss, not_taken);

  // If this assert fails, we have to check upper bound too.
  ASSERT(LAST_TYPE == JS_FUNCTION_TYPE);

  GenerateGlobalInstanceTypeCheck(masm, r0, miss);

  // Check for non-global object that requires access check.
  __ test_b(FieldOperand(r1, Map::kBitFieldOffset),
            (1 << Map::kIsAccessCheckNeeded) |
            (1 << Map::kHasNamedInterceptor));
  __ j(not_zero, miss, not_taken);

  __ mov(r0, FieldOperand(receiver, JSObject::kPropertiesOffset));
  __ CheckMap(r0, Factory::hash_table_map(), miss, true);
}


// Helper function used to load a property from a dictionary backing storage.
// This function may return false negatives, so miss_label
// must always call a backup property load that is complete.
// This function is safe to call if name is not a symbol, and will jump to
// the miss_label in that case.
// The generated code assumes that the receiver has slow properties,
// is not a global object and does not have interceptors.
static void GenerateDictionaryLoad(MacroAssembler* masm,
                                   Label* miss_label,
                                   Register elements,
                                   Register name,
                                   Register r0,
                                   Register r1,
                                   Register result) {
  // Register use:
  //
  // elements - holds the property dictionary on entry and is unchanged.
  //
  // name - holds the name of the property on entry and is unchanged.
  //
  // Scratch registers:
  //
  // r0   - used for the index into the property dictionary
  //
  // r1   - used to hold the capacity of the property dictionary.
  //
  // result - holds the result on exit.

  Label done;

  // Compute the capacity mask.
  const int kCapacityOffset =
      StringDictionary::kHeaderSize +
      StringDictionary::kCapacityIndex * kPointerSize;
  __ mov(r1, FieldOperand(elements, kCapacityOffset));
  __ shr(r1, kSmiTagSize);  // convert smi to int
  __ dec(r1);

  // Generate an unrolled loop that performs a few probes before
  // giving up. Measurements done on Gmail indicate that 2 probes
  // cover ~93% of loads from dictionaries.
  static const int kProbes = 4;
  const int kElementsStartOffset =
      StringDictionary::kHeaderSize +
      StringDictionary::kElementsStartIndex * kPointerSize;
  for (int i = 0; i < kProbes; i++) {
    // Compute the masked index: (hash + i + i * i) & mask.
    __ mov(r0, FieldOperand(name, String::kHashFieldOffset));
    __ shr(r0, String::kHashShift);
    if (i > 0) {
      __ add(Operand(r0), Immediate(StringDictionary::GetProbeOffset(i)));
    }
    __ and_(r0, Operand(r1));

    // Scale the index by multiplying by the entry size.
    ASSERT(StringDictionary::kEntrySize == 3);
    __ lea(r0, Operand(r0, r0, times_2, 0));  // r0 = r0 * 3

    // Check if the key is identical to the name.
    __ cmp(name, Operand(elements, r0, times_4,
                         kElementsStartOffset - kHeapObjectTag));
    if (i != kProbes - 1) {
      __ j(equal, &done, taken);
    } else {
      __ j(not_equal, miss_label, not_taken);
    }
  }

  // Check that the value is a normal property.
  __ bind(&done);
  const int kDetailsOffset = kElementsStartOffset + 2 * kPointerSize;
  __ test(Operand(elements, r0, times_4, kDetailsOffset - kHeapObjectTag),
          Immediate(PropertyDetails::TypeField::mask() << kSmiTagSize));
  __ j(not_zero, miss_label, not_taken);

  // Get the value at the masked, scaled index.
  const int kValueOffset = kElementsStartOffset + kPointerSize;
  __ mov(result, Operand(elements, r0, times_4, kValueOffset - kHeapObjectTag));
}


static void GenerateNumberDictionaryLoad(MacroAssembler* masm,
                                         Label* miss,
                                         Register elements,
                                         Register key,
                                         Register r0,
                                         Register r1,
                                         Register r2,
                                         Register result) {
  // Register use:
  //
  // elements - holds the slow-case elements of the receiver and is unchanged.
  //
  // key      - holds the smi key on entry and is unchanged.
  //
  // Scratch registers:
  //
  // r0 - holds the untagged key on entry and holds the hash once computed.
  //
  // r1 - used to hold the capacity mask of the dictionary
  //
  // r2 - used for the index into the dictionary.
  //
  // result - holds the result on exit if the load succeeds and we fall through.

  Label done;

  // Compute the hash code from the untagged key.  This must be kept in sync
  // with ComputeIntegerHash in utils.h.
  //
  // hash = ~hash + (hash << 15);
  __ mov(r1, r0);
  __ not_(r0);
  __ shl(r1, 15);
  __ add(r0, Operand(r1));
  // hash = hash ^ (hash >> 12);
  __ mov(r1, r0);
  __ shr(r1, 12);
  __ xor_(r0, Operand(r1));
  // hash = hash + (hash << 2);
  __ lea(r0, Operand(r0, r0, times_4, 0));
  // hash = hash ^ (hash >> 4);
  __ mov(r1, r0);
  __ shr(r1, 4);
  __ xor_(r0, Operand(r1));
  // hash = hash * 2057;
  __ imul(r0, r0, 2057);
  // hash = hash ^ (hash >> 16);
  __ mov(r1, r0);
  __ shr(r1, 16);
  __ xor_(r0, Operand(r1));

  // Compute capacity mask.
  __ mov(r1, FieldOperand(elements, NumberDictionary::kCapacityOffset));
  __ shr(r1, kSmiTagSize);  // convert smi to int
  __ dec(r1);

  // Generate an unrolled loop that performs a few probes before giving up.
  const int kProbes = 4;
  for (int i = 0; i < kProbes; i++) {
    // Use r2 for index calculations and keep the hash intact in r0.
    __ mov(r2, r0);
    // Compute the masked index: (hash + i + i * i) & mask.
    if (i > 0) {
      __ add(Operand(r2), Immediate(NumberDictionary::GetProbeOffset(i)));
    }
    __ and_(r2, Operand(r1));

    // Scale the index by multiplying by the entry size.
    ASSERT(NumberDictionary::kEntrySize == 3);
    __ lea(r2, Operand(r2, r2, times_2, 0));  // r2 = r2 * 3

    // Check if the key matches.
    __ cmp(key, FieldOperand(elements,
                             r2,
                             times_pointer_size,
                             NumberDictionary::kElementsStartOffset));
    if (i != (kProbes - 1)) {
      __ j(equal, &done, taken);
    } else {
      __ j(not_equal, miss, not_taken);
    }
  }

  __ bind(&done);
  // Check that the value is a normal propety.
  const int kDetailsOffset =
      NumberDictionary::kElementsStartOffset + 2 * kPointerSize;
  ASSERT_EQ(NORMAL, 0);
  __ test(FieldOperand(elements, r2, times_pointer_size, kDetailsOffset),
          Immediate(PropertyDetails::TypeField::mask() << kSmiTagSize));
  __ j(not_zero, miss);

  // Get the value at the masked, scaled index.
  const int kValueOffset =
      NumberDictionary::kElementsStartOffset + kPointerSize;
  __ mov(result, FieldOperand(elements, r2, times_pointer_size, kValueOffset));
}


// The offset from the inlined patch site to the start of the
// inlined load instruction.  It is 7 bytes (test eax, imm) plus
// 6 bytes (jne slow_label).
const int LoadIC::kOffsetToLoadInstruction = 13;


void LoadIC::GenerateArrayLength(MacroAssembler* masm) {
  // ----------- S t a t e -------------
  //  -- eax    : receiver
  //  -- ecx    : name
  //  -- esp[0] : return address
  // -----------------------------------
  Label miss;

  StubCompiler::GenerateLoadArrayLength(masm, eax, edx, &miss);
  __ bind(&miss);
  StubCompiler::GenerateLoadMiss(masm, Code::LOAD_IC);
}


void LoadIC::GenerateStringLength(MacroAssembler* masm) {
  // ----------- S t a t e -------------
  //  -- eax    : receiver
  //  -- ecx    : name
  //  -- esp[0] : return address
  // -----------------------------------
  Label miss;

  StubCompiler::GenerateLoadStringLength(masm, eax, edx, ebx, &miss);
  __ bind(&miss);
  StubCompiler::GenerateLoadMiss(masm, Code::LOAD_IC);
}


void LoadIC::GenerateFunctionPrototype(MacroAssembler* masm) {
  // ----------- S t a t e -------------
  //  -- eax    : receiver
  //  -- ecx    : name
  //  -- esp[0] : return address
  // -----------------------------------
  Label miss;

  StubCompiler::GenerateLoadFunctionPrototype(masm, eax, edx, ebx, &miss);
  __ bind(&miss);
  StubCompiler::GenerateLoadMiss(masm, Code::LOAD_IC);
}


// Checks the receiver for special cases (value type, slow case bits).
// Falls through for regular JS object.
static void GenerateKeyedLoadReceiverCheck(MacroAssembler* masm,
                                           Register receiver,
                                           Register map,
                                           int interceptor_bit,
                                           Label* slow) {
  // Register use:
  //   receiver - holds the receiver and is unchanged.
  // Scratch registers:
  //   map - used to hold the map of the receiver.

  // Check that the object isn't a smi.
  __ test(receiver, Immediate(kSmiTagMask));
  __ j(zero, slow, not_taken);

  // Get the map of the receiver.
  __ mov(map, FieldOperand(receiver, HeapObject::kMapOffset));

  // Check bit field.
  __ test_b(FieldOperand(map, Map::kBitFieldOffset),
            (1 << Map::kIsAccessCheckNeeded) | (1 << interceptor_bit));
  __ j(not_zero, slow, not_taken);
  // Check that the object is some kind of JS object EXCEPT JS Value type.
  // In the case that the object is a value-wrapper object,
  // we enter the runtime system to make sure that indexing
  // into string objects works as intended.
  ASSERT(JS_OBJECT_TYPE > JS_VALUE_TYPE);

  __ CmpInstanceType(map, JS_OBJECT_TYPE);
  __ j(below, slow, not_taken);
}


// Loads an indexed element from a fast case array.
static void GenerateFastArrayLoad(MacroAssembler* masm,
                                  Register receiver,
                                  Register key,
                                  Register scratch,
                                  Register result,
                                  Label* not_fast_array,
                                  Label* out_of_range) {
  // Register use:
  //   receiver - holds the receiver and is unchanged.
  //   key - holds the key and is unchanged (must be a smi).
  // Scratch registers:
  //   scratch - used to hold elements of the receiver and the loaded value.
  //   result - holds the result on exit if the load succeeds and
  //            we fall through.

  __ mov(scratch, FieldOperand(receiver, JSObject::kElementsOffset));
  // Check that the object is in fast mode (not dictionary).
  __ CheckMap(scratch, Factory::fixed_array_map(), not_fast_array, true);
  // Check that the key (index) is within bounds.
  __ cmp(key, FieldOperand(scratch, FixedArray::kLengthOffset));
  __ j(above_equal, out_of_range);
  // Fast case: Do the load.
  ASSERT((kPointerSize == 4) && (kSmiTagSize == 1) && (kSmiTag == 0));
  __ mov(scratch, FieldOperand(scratch, key, times_2, FixedArray::kHeaderSize));
  __ cmp(Operand(scratch), Immediate(Factory::the_hole_value()));
  // In case the loaded value is the_hole we have to consult GetProperty
  // to ensure the prototype chain is searched.
  __ j(equal, out_of_range);
  if (!result.is(scratch)) {
    __ mov(result, scratch);
  }
}


// Checks whether a key is an array index string or a symbol string.
// Falls through if the key is a symbol.
static void GenerateKeyStringCheck(MacroAssembler* masm,
                                   Register key,
                                   Register map,
                                   Register hash,
                                   Label* index_string,
                                   Label* not_symbol) {
  // Register use:
  //   key - holds the key and is unchanged. Assumed to be non-smi.
  // Scratch registers:
  //   map - used to hold the map of the key.
  //   hash - used to hold the hash of the key.
  __ CmpObjectType(key, FIRST_NONSTRING_TYPE, map);
  __ j(above_equal, not_symbol);

  // Is the string an array index, with cached numeric value?
  __ mov(hash, FieldOperand(key, String::kHashFieldOffset));
  __ test(hash, Immediate(String::kContainsCachedArrayIndexMask));
  __ j(zero, index_string, not_taken);

  // Is the string a symbol?
  ASSERT(kSymbolTag != 0);
  __ test_b(FieldOperand(map, Map::kInstanceTypeOffset), kIsSymbolMask);
  __ j(zero, not_symbol, not_taken);
}


// Picks out an array index from the hash field.
static void GenerateIndexFromHash(MacroAssembler* masm,
                                  Register key,
                                  Register hash) {
  // Register use:
  //   key - holds the overwritten key on exit.
  //   hash - holds the key's hash. Clobbered.

  // The assert checks that the constants for the maximum number of digits
  // for an array index cached in the hash field and the number of bits
  // reserved for it does not conflict.
  ASSERT(TenToThe(String::kMaxCachedArrayIndexLength) <
         (1 << String::kArrayIndexValueBits));
  // We want the smi-tagged index in key.  kArrayIndexValueMask has zeros in
  // the low kHashShift bits.
  ASSERT(String::kHashShift >= kSmiTagSize);
  __ and_(hash, String::kArrayIndexValueMask);
  __ shr(hash, String::kHashShift - kSmiTagSize);
  // Here we actually clobber the key which will be used if calling into
  // runtime later. However as the new key is the numeric value of a string key
  // there is no difference in using either key.
  __ mov(key, hash);
}


void KeyedLoadIC::GenerateGeneric(MacroAssembler* masm) {
  // ----------- S t a t e -------------
  //  -- eax    : key
  //  -- edx    : receiver
  //  -- esp[0] : return address
  // -----------------------------------
  Label slow, check_string, index_smi, index_string;
  Label check_pixel_array, probe_dictionary, check_number_dictionary;

  // Check that the key is a smi.
  __ test(eax, Immediate(kSmiTagMask));
  __ j(not_zero, &check_string, not_taken);
  __ bind(&index_smi);
  // Now the key is known to be a smi. This place is also jumped to from
  // where a numeric string is converted to a smi.

  GenerateKeyedLoadReceiverCheck(
      masm, edx, ecx, Map::kHasIndexedInterceptor, &slow);

  GenerateFastArrayLoad(masm,
                        edx,
                        eax,
                        ecx,
                        eax,
                        &check_pixel_array,
                        &slow);
  __ IncrementCounter(&Counters::keyed_load_generic_smi, 1);
  __ ret(0);

  __ bind(&check_pixel_array);
  // Check whether the elements is a pixel array.
  // edx: receiver
  // eax: key
  // ecx: elements
  __ mov(ebx, eax);
  __ SmiUntag(ebx);
  __ CheckMap(ecx, Factory::pixel_array_map(), &check_number_dictionary, true);
  __ cmp(ebx, FieldOperand(ecx, PixelArray::kLengthOffset));
  __ j(above_equal, &slow);
  __ mov(eax, FieldOperand(ecx, PixelArray::kExternalPointerOffset));
  __ movzx_b(eax, Operand(eax, ebx, times_1, 0));
  __ SmiTag(eax);
  __ ret(0);

  __ bind(&check_number_dictionary);
  // Check whether the elements is a number dictionary.
  // edx: receiver
  // ebx: untagged index
  // eax: key
  // ecx: elements
  __ CheckMap(ecx, Factory::hash_table_map(), &slow, true);
  Label slow_pop_receiver;
  // Push receiver on the stack to free up a register for the dictionary
  // probing.
  __ push(edx);
  GenerateNumberDictionaryLoad(masm,
                               &slow_pop_receiver,
                               ecx,
                               eax,
                               ebx,
                               edx,
                               edi,
                               eax);
  // Pop receiver before returning.
  __ pop(edx);
  __ ret(0);

  __ bind(&slow_pop_receiver);
  // Pop the receiver from the stack and jump to runtime.
  __ pop(edx);

  __ bind(&slow);
  // Slow case: jump to runtime.
  // edx: receiver
  // eax: key
  __ IncrementCounter(&Counters::keyed_load_generic_slow, 1);
  GenerateRuntimeGetProperty(masm);

  __ bind(&check_string);
  GenerateKeyStringCheck(masm, eax, ecx, ebx, &index_string, &slow);

  GenerateKeyedLoadReceiverCheck(
      masm, edx, ecx, Map::kHasNamedInterceptor, &slow);

  // If the receiver is a fast-case object, check the keyed lookup
  // cache. Otherwise probe the dictionary.
  __ mov(ebx, FieldOperand(edx, JSObject::kPropertiesOffset));
  __ cmp(FieldOperand(ebx, HeapObject::kMapOffset),
         Immediate(Factory::hash_table_map()));
  __ j(equal, &probe_dictionary);

  // Load the map of the receiver, compute the keyed lookup cache hash
  // based on 32 bits of the map pointer and the string hash.
  __ mov(ebx, FieldOperand(edx, HeapObject::kMapOffset));
  __ mov(ecx, ebx);
  __ shr(ecx, KeyedLookupCache::kMapHashShift);
  __ mov(edi, FieldOperand(eax, String::kHashFieldOffset));
  __ shr(edi, String::kHashShift);
  __ xor_(ecx, Operand(edi));
  __ and_(ecx, KeyedLookupCache::kCapacityMask);

  // Load the key (consisting of map and symbol) from the cache and
  // check for match.
  ExternalReference cache_keys
      = ExternalReference::keyed_lookup_cache_keys();
  __ mov(edi, ecx);
  __ shl(edi, kPointerSizeLog2 + 1);
  __ cmp(ebx, Operand::StaticArray(edi, times_1, cache_keys));
  __ j(not_equal, &slow);
  __ add(Operand(edi), Immediate(kPointerSize));
  __ cmp(eax, Operand::StaticArray(edi, times_1, cache_keys));
  __ j(not_equal, &slow);

  // Get field offset and check that it is an in-object property.
  // edx     : receiver
  // ebx     : receiver's map
  // eax     : key
  // ecx     : lookup cache index
  ExternalReference cache_field_offsets
      = ExternalReference::keyed_lookup_cache_field_offsets();
  __ mov(edi,
         Operand::StaticArray(ecx, times_pointer_size, cache_field_offsets));
  __ movzx_b(ecx, FieldOperand(ebx, Map::kInObjectPropertiesOffset));
  __ sub(edi, Operand(ecx));
  __ j(above_equal, &slow);

  // Load in-object property.
  __ movzx_b(ecx, FieldOperand(ebx, Map::kInstanceSizeOffset));
  __ add(ecx, Operand(edi));
  __ mov(eax, FieldOperand(edx, ecx, times_pointer_size, 0));
  __ IncrementCounter(&Counters::keyed_load_generic_lookup_cache, 1);
  __ ret(0);

  // Do a quick inline probe of the receiver's dictionary, if it
  // exists.
  __ bind(&probe_dictionary);

  __ mov(ecx, FieldOperand(edx, JSObject::kMapOffset));
  __ movzx_b(ecx, FieldOperand(ecx, Map::kInstanceTypeOffset));
  GenerateGlobalInstanceTypeCheck(masm, ecx, &slow);

  GenerateDictionaryLoad(masm, &slow, ebx, eax, ecx, edi, eax);
  __ IncrementCounter(&Counters::keyed_load_generic_symbol, 1);
  __ ret(0);

  __ bind(&index_string);
  GenerateIndexFromHash(masm, eax, ebx);
  // Now jump to the place where smi keys are handled.
  __ jmp(&index_smi);
}


void KeyedLoadIC::GenerateString(MacroAssembler* masm) {
  // ----------- S t a t e -------------
  //  -- eax    : key (index)
  //  -- edx    : receiver
  //  -- esp[0] : return address
  // -----------------------------------
  Label miss;
  Label index_out_of_range;

  Register receiver = edx;
  Register index = eax;
  Register scratch1 = ebx;
  Register scratch2 = ecx;
  Register result = eax;

  StringCharAtGenerator char_at_generator(receiver,
                                          index,
                                          scratch1,
                                          scratch2,
                                          result,
                                          &miss,  // When not a string.
                                          &miss,  // When not a number.
                                          &index_out_of_range,
                                          STRING_INDEX_IS_ARRAY_INDEX);
  char_at_generator.GenerateFast(masm);
  __ ret(0);

  ICRuntimeCallHelper call_helper;
  char_at_generator.GenerateSlow(masm, call_helper);

  __ bind(&index_out_of_range);
  __ Set(eax, Immediate(Factory::undefined_value()));
  __ ret(0);

  __ bind(&miss);
  GenerateMiss(masm);
}


void KeyedLoadIC::GenerateExternalArray(MacroAssembler* masm,
                                        ExternalArrayType array_type) {
  // ----------- S t a t e -------------
  //  -- eax    : key
  //  -- edx    : receiver
  //  -- esp[0] : return address
  // -----------------------------------
  Label slow, failed_allocation;

  // Check that the object isn't a smi.
  __ test(edx, Immediate(kSmiTagMask));
  __ j(zero, &slow, not_taken);

  // Check that the key is a smi.
  __ test(eax, Immediate(kSmiTagMask));
  __ j(not_zero, &slow, not_taken);

  // Get the map of the receiver.
  __ mov(ecx, FieldOperand(edx, HeapObject::kMapOffset));
  // Check that the receiver does not require access checks.  We need
  // to check this explicitly since this generic stub does not perform
  // map checks.
  __ test_b(FieldOperand(ecx, Map::kBitFieldOffset),
            1 << Map::kIsAccessCheckNeeded);
  __ j(not_zero, &slow, not_taken);

  __ CmpInstanceType(ecx, JS_OBJECT_TYPE);
  __ j(not_equal, &slow, not_taken);

  // Check that the elements array is the appropriate type of
  // ExternalArray.
  __ mov(ebx, FieldOperand(edx, JSObject::kElementsOffset));
  Handle<Map> map(Heap::MapForExternalArrayType(array_type));
  __ cmp(FieldOperand(ebx, HeapObject::kMapOffset),
         Immediate(map));
  __ j(not_equal, &slow, not_taken);

  // eax: key, known to be a smi.
  // edx: receiver, known to be a JSObject.
  // ebx: elements object, known to be an external array.
  // Check that the index is in range.
  __ mov(ecx, eax);
  __ SmiUntag(ecx);  // Untag the index.
  __ cmp(ecx, FieldOperand(ebx, ExternalArray::kLengthOffset));
  // Unsigned comparison catches both negative and too-large values.
  __ j(above_equal, &slow);

  __ mov(ebx, FieldOperand(ebx, ExternalArray::kExternalPointerOffset));
  // ebx: base pointer of external storage
  switch (array_type) {
    case kExternalByteArray:
      __ movsx_b(ecx, Operand(ebx, ecx, times_1, 0));
      break;
    case kExternalUnsignedByteArray:
      __ movzx_b(ecx, Operand(ebx, ecx, times_1, 0));
      break;
    case kExternalShortArray:
      __ movsx_w(ecx, Operand(ebx, ecx, times_2, 0));
      break;
    case kExternalUnsignedShortArray:
      __ movzx_w(ecx, Operand(ebx, ecx, times_2, 0));
      break;
    case kExternalIntArray:
    case kExternalUnsignedIntArray:
      __ mov(ecx, Operand(ebx, ecx, times_4, 0));
      break;
    case kExternalFloatArray:
      __ fld_s(Operand(ebx, ecx, times_4, 0));
      break;
    default:
      UNREACHABLE();
      break;
  }

  // For integer array types:
  // ecx: value
  // For floating-point array type:
  // FP(0): value

  if (array_type == kExternalIntArray ||
      array_type == kExternalUnsignedIntArray) {
    // For the Int and UnsignedInt array types, we need to see whether
    // the value can be represented in a Smi. If not, we need to convert
    // it to a HeapNumber.
    Label box_int;
    if (array_type == kExternalIntArray) {
      __ cmp(ecx, 0xC0000000);
      __ j(sign, &box_int);
    } else {
      ASSERT_EQ(array_type, kExternalUnsignedIntArray);
      // The test is different for unsigned int values. Since we need
      // the value to be in the range of a positive smi, we can't
      // handle either of the top two bits being set in the value.
      __ test(ecx, Immediate(0xC0000000));
      __ j(not_zero, &box_int);
    }

    __ mov(eax, ecx);
    __ SmiTag(eax);
    __ ret(0);

    __ bind(&box_int);

    // Allocate a HeapNumber for the int and perform int-to-double
    // conversion.
    if (array_type == kExternalIntArray) {
      __ push(ecx);
      __ fild_s(Operand(esp, 0));
      __ pop(ecx);
    } else {
      ASSERT(array_type == kExternalUnsignedIntArray);
      // Need to zero-extend the value.
      // There's no fild variant for unsigned values, so zero-extend
      // to a 64-bit int manually.
      __ push(Immediate(0));
      __ push(ecx);
      __ fild_d(Operand(esp, 0));
      __ pop(ecx);
      __ pop(ecx);
    }
    // FP(0): value
    __ AllocateHeapNumber(ecx, ebx, edi, &failed_allocation);
    // Set the value.
    __ mov(eax, ecx);
    __ fstp_d(FieldOperand(eax, HeapNumber::kValueOffset));
    __ ret(0);
  } else if (array_type == kExternalFloatArray) {
    // For the floating-point array type, we need to always allocate a
    // HeapNumber.
    __ AllocateHeapNumber(ecx, ebx, edi, &failed_allocation);
    // Set the value.
    __ mov(eax, ecx);
    __ fstp_d(FieldOperand(eax, HeapNumber::kValueOffset));
    __ ret(0);
  } else {
    __ mov(eax, ecx);
    __ SmiTag(eax);
    __ ret(0);
  }

  // If we fail allocation of the HeapNumber, we still have a value on
  // top of the FPU stack. Remove it.
  __ bind(&failed_allocation);
  __ ffree();
  __ fincstp();
  // Fall through to slow case.

  // Slow case: Jump to runtime.
  __ bind(&slow);
  __ IncrementCounter(&Counters::keyed_load_external_array_slow, 1);
  GenerateRuntimeGetProperty(masm);
}


void KeyedLoadIC::GenerateIndexedInterceptor(MacroAssembler* masm) {
  // ----------- S t a t e -------------
  //  -- eax    : key
  //  -- edx    : receiver
  //  -- esp[0] : return address
  // -----------------------------------
  Label slow;

  // Check that the receiver isn't a smi.
  __ test(edx, Immediate(kSmiTagMask));
  __ j(zero, &slow, not_taken);

  // Check that the key is a smi.
  __ test(eax, Immediate(kSmiTagMask));
  __ j(not_zero, &slow, not_taken);

  // Get the map of the receiver.
  __ mov(ecx, FieldOperand(edx, HeapObject::kMapOffset));

  // Check that it has indexed interceptor and access checks
  // are not enabled for this object.
  __ movzx_b(ecx, FieldOperand(ecx, Map::kBitFieldOffset));
  __ and_(Operand(ecx), Immediate(kSlowCaseBitFieldMask));
  __ cmp(Operand(ecx), Immediate(1 << Map::kHasIndexedInterceptor));
  __ j(not_zero, &slow, not_taken);

  // Everything is fine, call runtime.
  __ pop(ecx);
  __ push(edx);  // receiver
  __ push(eax);  // key
  __ push(ecx);  // return address

  // Perform tail call to the entry.
  ExternalReference ref = ExternalReference(
      IC_Utility(kKeyedLoadPropertyWithInterceptor));
  __ TailCallExternalReference(ref, 2, 1);

  __ bind(&slow);
  GenerateMiss(masm);
}


void KeyedStoreIC::GenerateGeneric(MacroAssembler* masm) {
  // ----------- S t a t e -------------
  //  -- eax    : value
  //  -- ecx    : key
  //  -- edx    : receiver
  //  -- esp[0] : return address
  // -----------------------------------
  Label slow, fast, array, extra, check_pixel_array;

  // Check that the object isn't a smi.
  __ test(edx, Immediate(kSmiTagMask));
  __ j(zero, &slow, not_taken);
  // Get the map from the receiver.
  __ mov(edi, FieldOperand(edx, HeapObject::kMapOffset));
  // Check that the receiver does not require access checks.  We need
  // to do this because this generic stub does not perform map checks.
  __ test_b(FieldOperand(edi, Map::kBitFieldOffset),
            1 << Map::kIsAccessCheckNeeded);
  __ j(not_zero, &slow, not_taken);
  // Check that the key is a smi.
  __ test(ecx, Immediate(kSmiTagMask));
  __ j(not_zero, &slow, not_taken);
  __ CmpInstanceType(edi, JS_ARRAY_TYPE);
  __ j(equal, &array);
  // Check that the object is some kind of JS object.
  __ CmpInstanceType(edi, FIRST_JS_OBJECT_TYPE);
  __ j(below, &slow, not_taken);

  // Object case: Check key against length in the elements array.
  // eax: value
  // edx: JSObject
  // ecx: key (a smi)
  __ mov(edi, FieldOperand(edx, JSObject::kElementsOffset));
  // Check that the object is in fast mode (not dictionary).
  __ CheckMap(edi, Factory::fixed_array_map(), &check_pixel_array, true);
  __ cmp(ecx, FieldOperand(edi, FixedArray::kLengthOffset));
  __ j(below, &fast, taken);

  // Slow case: call runtime.
  __ bind(&slow);
  GenerateRuntimeSetProperty(masm);

  // Check whether the elements is a pixel array.
  __ bind(&check_pixel_array);
  // eax: value
  // ecx: key (a smi)
  // edx: receiver
  // edi: elements array
  __ CheckMap(edi, Factory::pixel_array_map(), &slow, true);
  // Check that the value is a smi. If a conversion is needed call into the
  // runtime to convert and clamp.
  __ test(eax, Immediate(kSmiTagMask));
  __ j(not_zero, &slow);
  __ mov(ebx, ecx);
  __ SmiUntag(ebx);
  __ cmp(ebx, FieldOperand(edi, PixelArray::kLengthOffset));
  __ j(above_equal, &slow);
  __ mov(ecx, eax);  // Save the value. Key is not longer needed.
  __ SmiUntag(ecx);
  {  // Clamp the value to [0..255].
    Label done;
    __ test(ecx, Immediate(0xFFFFFF00));
    __ j(zero, &done);
    __ setcc(negative, ecx);  // 1 if negative, 0 if positive.
    __ dec_b(ecx);  // 0 if negative, 255 if positive.
    __ bind(&done);
  }
  __ mov(edi, FieldOperand(edi, PixelArray::kExternalPointerOffset));
  __ mov_b(Operand(edi, ebx, times_1, 0), ecx);
  __ ret(0);  // Return value in eax.

  // Extra capacity case: Check if there is extra capacity to
  // perform the store and update the length. Used for adding one
  // element to the array by writing to array[array.length].
  __ bind(&extra);
  // eax: value
  // edx: receiver, a JSArray
  // ecx: key, a smi.
  // edi: receiver->elements, a FixedArray
  // flags: compare (ecx, edx.length())
  __ j(not_equal, &slow, not_taken);  // do not leave holes in the array
  __ cmp(ecx, FieldOperand(edi, FixedArray::kLengthOffset));
  __ j(above_equal, &slow, not_taken);
  // Add 1 to receiver->length, and go to fast array write.
  __ add(FieldOperand(edx, JSArray::kLengthOffset),
         Immediate(Smi::FromInt(1)));
  __ jmp(&fast);

  // Array case: Get the length and the elements array from the JS
  // array. Check that the array is in fast mode; if it is the
  // length is always a smi.
  __ bind(&array);
  // eax: value
  // edx: receiver, a JSArray
  // ecx: key, a smi.
  __ mov(edi, FieldOperand(edx, JSObject::kElementsOffset));
  __ CheckMap(edi, Factory::fixed_array_map(), &check_pixel_array, true);

  // Check the key against the length in the array, compute the
  // address to store into and fall through to fast case.
  __ cmp(ecx, FieldOperand(edx, JSArray::kLengthOffset));  // Compare smis.
  __ j(above_equal, &extra, not_taken);

  // Fast case: Do the store.
  __ bind(&fast);
  // eax: value
  // ecx: key (a smi)
  // edx: receiver
  // edi: FixedArray receiver->elements
  __ mov(CodeGenerator::FixedArrayElementOperand(edi, ecx), eax);
  // Update write barrier for the elements array address.
  __ mov(edx, Operand(eax));
  __ RecordWrite(edi, 0, edx, ecx);
  __ ret(0);
}


void KeyedStoreIC::GenerateExternalArray(MacroAssembler* masm,
                                         ExternalArrayType array_type) {
  // ----------- S t a t e -------------
  //  -- eax    : value
  //  -- ecx    : key
  //  -- edx    : receiver
  //  -- esp[0] : return address
  // -----------------------------------
  Label slow, check_heap_number;

  // Check that the object isn't a smi.
  __ test(edx, Immediate(kSmiTagMask));
  __ j(zero, &slow);
  // Get the map from the receiver.
  __ mov(edi, FieldOperand(edx, HeapObject::kMapOffset));
  // Check that the receiver does not require access checks.  We need
  // to do this because this generic stub does not perform map checks.
  __ test_b(FieldOperand(edi, Map::kBitFieldOffset),
            1 << Map::kIsAccessCheckNeeded);
  __ j(not_zero, &slow);
  // Check that the key is a smi.
  __ test(ecx, Immediate(kSmiTagMask));
  __ j(not_zero, &slow);
  // Get the instance type from the map of the receiver.
  __ CmpInstanceType(edi, JS_OBJECT_TYPE);
  __ j(not_equal, &slow);

  // Check that the elements array is the appropriate type of
  // ExternalArray.
  // eax: value
  // edx: receiver, a JSObject
  // ecx: key, a smi
  __ mov(edi, FieldOperand(edx, JSObject::kElementsOffset));
  __ CheckMap(edi, Handle<Map>(Heap::MapForExternalArrayType(array_type)),
              &slow, true);

  // Check that the index is in range.
  __ mov(ebx, ecx);
  __ SmiUntag(ebx);
  __ cmp(ebx, FieldOperand(edi, ExternalArray::kLengthOffset));
  // Unsigned comparison catches both negative and too-large values.
  __ j(above_equal, &slow);

  // Handle both smis and HeapNumbers in the fast path. Go to the
  // runtime for all other kinds of values.
  // eax: value
  // edx: receiver
  // ecx: key
  // edi: elements array
  // ebx: untagged index
  __ test(eax, Immediate(kSmiTagMask));
  __ j(not_equal, &check_heap_number);
  // smi case
  __ mov(ecx, eax);  // Preserve the value in eax.  Key is no longer needed.
  __ SmiUntag(ecx);
  __ mov(edi, FieldOperand(edi, ExternalArray::kExternalPointerOffset));
  // ecx: base pointer of external storage
  switch (array_type) {
    case kExternalByteArray:
    case kExternalUnsignedByteArray:
      __ mov_b(Operand(edi, ebx, times_1, 0), ecx);
      break;
    case kExternalShortArray:
    case kExternalUnsignedShortArray:
      __ mov_w(Operand(edi, ebx, times_2, 0), ecx);
      break;
    case kExternalIntArray:
    case kExternalUnsignedIntArray:
      __ mov(Operand(edi, ebx, times_4, 0), ecx);
      break;
    case kExternalFloatArray:
      // Need to perform int-to-float conversion.
      __ push(ecx);
      __ fild_s(Operand(esp, 0));
      __ pop(ecx);
      __ fstp_s(Operand(edi, ebx, times_4, 0));
      break;
    default:
      UNREACHABLE();
      break;
  }
  __ ret(0);  // Return the original value.

  __ bind(&check_heap_number);
  // eax: value
  // edx: receiver
  // ecx: key
  // edi: elements array
  // ebx: untagged index
  __ cmp(FieldOperand(eax, HeapObject::kMapOffset),
         Immediate(Factory::heap_number_map()));
  __ j(not_equal, &slow);

  // The WebGL specification leaves the behavior of storing NaN and
  // +/-Infinity into integer arrays basically undefined. For more
  // reproducible behavior, convert these to zero.
  __ fld_d(FieldOperand(eax, HeapNumber::kValueOffset));
  __ mov(edi, FieldOperand(edi, ExternalArray::kExternalPointerOffset));
  // ebx: untagged index
  // edi: base pointer of external storage
  // top of FPU stack: value
  if (array_type == kExternalFloatArray) {
    __ fstp_s(Operand(edi, ebx, times_4, 0));
    __ ret(0);
  } else {
    // Need to perform float-to-int conversion.
    // Test the top of the FP stack for NaN.
    Label is_nan;
    __ fucomi(0);
    __ j(parity_even, &is_nan);

    if (array_type != kExternalUnsignedIntArray) {
      __ push(ecx);  // Make room on stack
      __ fistp_s(Operand(esp, 0));
      __ pop(ecx);
    } else {
      // fistp stores values as signed integers.
      // To represent the entire range, we need to store as a 64-bit
      // int and discard the high 32 bits.
      __ sub(Operand(esp), Immediate(2 * kPointerSize));
      __ fistp_d(Operand(esp, 0));
      __ pop(ecx);
      __ add(Operand(esp), Immediate(kPointerSize));
    }
    // ecx: untagged integer value
    switch (array_type) {
      case kExternalByteArray:
      case kExternalUnsignedByteArray:
        __ mov_b(Operand(edi, ebx, times_1, 0), ecx);
        break;
      case kExternalShortArray:
      case kExternalUnsignedShortArray:
        __ mov_w(Operand(edi, ebx, times_2, 0), ecx);
        break;
      case kExternalIntArray:
      case kExternalUnsignedIntArray: {
        // We also need to explicitly check for +/-Infinity. These are
        // converted to MIN_INT, but we need to be careful not to
        // confuse with legal uses of MIN_INT.
        Label not_infinity;
        // This test would apparently detect both NaN and Infinity,
        // but we've already checked for NaN using the FPU hardware
        // above.
        __ mov_w(edx, FieldOperand(eax, HeapNumber::kValueOffset + 6));
        __ and_(edx, 0x7FF0);
        __ cmp(edx, 0x7FF0);
        __ j(not_equal, &not_infinity);
        __ mov(ecx, 0);
        __ bind(&not_infinity);
        __ mov(Operand(edi, ebx, times_4, 0), ecx);
        break;
      }
      default:
        UNREACHABLE();
        break;
    }
    __ ret(0);  // Return original value.

    __ bind(&is_nan);
    __ ffree();
    __ fincstp();
    switch (array_type) {
      case kExternalByteArray:
      case kExternalUnsignedByteArray:
        __ mov_b(Operand(edi, ebx, times_1, 0), 0);
        break;
      case kExternalShortArray:
      case kExternalUnsignedShortArray:
        __ xor_(ecx, Operand(ecx));
        __ mov_w(Operand(edi, ebx, times_2, 0), ecx);
        break;
      case kExternalIntArray:
      case kExternalUnsignedIntArray:
        __ mov(Operand(edi, ebx, times_4, 0), Immediate(0));
        break;
      default:
        UNREACHABLE();
        break;
    }
    __ ret(0);  // Return the original value.
  }

  // Slow case: call runtime.
  __ bind(&slow);
  GenerateRuntimeSetProperty(masm);
}


// Defined in ic.cc.
Object* CallIC_Miss(Arguments args);

// The generated code does not accept smi keys.
// The generated code falls through if both probes miss.
static void GenerateMonomorphicCacheProbe(MacroAssembler* masm,
                                          int argc,
                                          Code::Kind kind) {
  // ----------- S t a t e -------------
  //  -- ecx                 : name
  //  -- edx                 : receiver
  // -----------------------------------
  Label number, non_number, non_string, boolean, probe, miss;

  // Probe the stub cache.
  Code::Flags flags =
      Code::ComputeFlags(kind, NOT_IN_LOOP, MONOMORPHIC, NORMAL, argc);
  StubCache::GenerateProbe(masm, flags, edx, ecx, ebx, eax);

  // If the stub cache probing failed, the receiver might be a value.
  // For value objects, we use the map of the prototype objects for
  // the corresponding JSValue for the cache and that is what we need
  // to probe.
  //
  // Check for number.
  __ test(edx, Immediate(kSmiTagMask));
  __ j(zero, &number, not_taken);
  __ CmpObjectType(edx, HEAP_NUMBER_TYPE, ebx);
  __ j(not_equal, &non_number, taken);
  __ bind(&number);
  StubCompiler::GenerateLoadGlobalFunctionPrototype(
      masm, Context::NUMBER_FUNCTION_INDEX, edx);
  __ jmp(&probe);

  // Check for string.
  __ bind(&non_number);
  __ CmpInstanceType(ebx, FIRST_NONSTRING_TYPE);
  __ j(above_equal, &non_string, taken);
  StubCompiler::GenerateLoadGlobalFunctionPrototype(
      masm, Context::STRING_FUNCTION_INDEX, edx);
  __ jmp(&probe);

  // Check for boolean.
  __ bind(&non_string);
  __ cmp(edx, Factory::true_value());
  __ j(equal, &boolean, not_taken);
  __ cmp(edx, Factory::false_value());
  __ j(not_equal, &miss, taken);
  __ bind(&boolean);
  StubCompiler::GenerateLoadGlobalFunctionPrototype(
      masm, Context::BOOLEAN_FUNCTION_INDEX, edx);

  // Probe the stub cache for the value object.
  __ bind(&probe);
  StubCache::GenerateProbe(masm, flags, edx, ecx, ebx, no_reg);
  __ bind(&miss);
}


static void GenerateFunctionTailCall(MacroAssembler* masm,
                                     int argc,
                                     Label* miss) {
  // ----------- S t a t e -------------
  //  -- ecx                 : name
  //  -- edi                 : function
  //  -- esp[0]              : return address
  //  -- esp[(argc - n) * 4] : arg[n] (zero-based)
  //  -- ...
  //  -- esp[(argc + 1) * 4] : receiver
  // -----------------------------------

  // Check that the result is not a smi.
  __ test(edi, Immediate(kSmiTagMask));
  __ j(zero, miss, not_taken);

  // Check that the value is a JavaScript function, fetching its map into eax.
  __ CmpObjectType(edi, JS_FUNCTION_TYPE, eax);
  __ j(not_equal, miss, not_taken);

  // Invoke the function.
  ParameterCount actual(argc);
  __ InvokeFunction(edi, actual, JUMP_FUNCTION);
}

// The generated code falls through if the call should be handled by runtime.
static void GenerateCallNormal(MacroAssembler* masm, int argc) {
  // ----------- S t a t e -------------
  //  -- ecx                 : name
  //  -- esp[0]              : return address
  //  -- esp[(argc - n) * 4] : arg[n] (zero-based)
  //  -- ...
  //  -- esp[(argc + 1) * 4] : receiver
  // -----------------------------------
  Label miss;

  // Get the receiver of the function from the stack; 1 ~ return address.
  __ mov(edx, Operand(esp, (argc + 1) * kPointerSize));

  GenerateDictionaryLoadReceiverCheck(masm, edx, eax, ebx, &miss);

  // eax: elements
  // Search the dictionary placing the result in edi.
  GenerateDictionaryLoad(masm, &miss, eax, ecx, edi, ebx, edi);
  GenerateFunctionTailCall(masm, argc, &miss);

  __ bind(&miss);
}


static void GenerateCallMiss(MacroAssembler* masm, int argc, IC::UtilityId id) {
  // ----------- S t a t e -------------
  //  -- ecx                 : name
  //  -- esp[0]              : return address
  //  -- esp[(argc - n) * 4] : arg[n] (zero-based)
  //  -- ...
  //  -- esp[(argc + 1) * 4] : receiver
  // -----------------------------------

  if (id == IC::kCallIC_Miss) {
    __ IncrementCounter(&Counters::call_miss, 1);
  } else {
    __ IncrementCounter(&Counters::keyed_call_miss, 1);
  }

  // Get the receiver of the function from the stack; 1 ~ return address.
  __ mov(edx, Operand(esp, (argc + 1) * kPointerSize));

  // Enter an internal frame.
  __ EnterInternalFrame();

  // Push the receiver and the name of the function.
  __ push(edx);
  __ push(ecx);

  // Call the entry.
  CEntryStub stub(1);
  __ mov(eax, Immediate(2));
  __ mov(ebx, Immediate(ExternalReference(IC_Utility(id))));
  __ CallStub(&stub);

  // Move result to edi and exit the internal frame.
  __ mov(edi, eax);
  __ LeaveInternalFrame();

  // Check if the receiver is a global object of some sort.
  // This can happen only for regular CallIC but not KeyedCallIC.
  if (id == IC::kCallIC_Miss) {
    Label invoke, global;
    __ mov(edx, Operand(esp, (argc + 1) * kPointerSize));  // receiver
    __ test(edx, Immediate(kSmiTagMask));
    __ j(zero, &invoke, not_taken);
    __ mov(ebx, FieldOperand(edx, HeapObject::kMapOffset));
    __ movzx_b(ebx, FieldOperand(ebx, Map::kInstanceTypeOffset));
    __ cmp(ebx, JS_GLOBAL_OBJECT_TYPE);
    __ j(equal, &global);
    __ cmp(ebx, JS_BUILTINS_OBJECT_TYPE);
    __ j(not_equal, &invoke);

    // Patch the receiver on the stack.
    __ bind(&global);
    __ mov(edx, FieldOperand(edx, GlobalObject::kGlobalReceiverOffset));
    __ mov(Operand(esp, (argc + 1) * kPointerSize), edx);
    __ bind(&invoke);
  }

  // Invoke the function.
  ParameterCount actual(argc);
  __ InvokeFunction(edi, actual, JUMP_FUNCTION);
}


void CallIC::GenerateMegamorphic(MacroAssembler* masm, int argc) {
  // ----------- S t a t e -------------
  //  -- ecx                 : name
  //  -- esp[0]              : return address
  //  -- esp[(argc - n) * 4] : arg[n] (zero-based)
  //  -- ...
  //  -- esp[(argc + 1) * 4] : receiver
  // -----------------------------------

  // Get the receiver of the function from the stack; 1 ~ return address.
  __ mov(edx, Operand(esp, (argc + 1) * kPointerSize));
  GenerateMonomorphicCacheProbe(masm, argc, Code::CALL_IC);
  GenerateMiss(masm, argc);
}


void CallIC::GenerateNormal(MacroAssembler* masm, int argc) {
  // ----------- S t a t e -------------
  //  -- ecx                 : name
  //  -- esp[0]              : return address
  //  -- esp[(argc - n) * 4] : arg[n] (zero-based)
  //  -- ...
  //  -- esp[(argc + 1) * 4] : receiver
  // -----------------------------------

  GenerateCallNormal(masm, argc);
  GenerateMiss(masm, argc);
}


void CallIC::GenerateMiss(MacroAssembler* masm, int argc) {
  // ----------- S t a t e -------------
  //  -- ecx                 : name
  //  -- esp[0]              : return address
  //  -- esp[(argc - n) * 4] : arg[n] (zero-based)
  //  -- ...
  //  -- esp[(argc + 1) * 4] : receiver
  // -----------------------------------

  GenerateCallMiss(masm, argc, IC::kCallIC_Miss);
}


void KeyedCallIC::GenerateMegamorphic(MacroAssembler* masm, int argc) {
  // ----------- S t a t e -------------
  //  -- ecx                 : name
  //  -- esp[0]              : return address
  //  -- esp[(argc - n) * 4] : arg[n] (zero-based)
  //  -- ...
  //  -- esp[(argc + 1) * 4] : receiver
  // -----------------------------------

  // Get the receiver of the function from the stack; 1 ~ return address.
  __ mov(edx, Operand(esp, (argc + 1) * kPointerSize));

  Label do_call, slow_call, slow_load, slow_reload_receiver;
  Label check_number_dictionary, check_string, lookup_monomorphic_cache;
  Label index_smi, index_string;

  // Check that the key is a smi.
  __ test(ecx, Immediate(kSmiTagMask));
  __ j(not_zero, &check_string, not_taken);

  __ bind(&index_smi);
  // Now the key is known to be a smi. This place is also jumped to from
  // where a numeric string is converted to a smi.

  GenerateKeyedLoadReceiverCheck(
      masm, edx, eax, Map::kHasIndexedInterceptor, &slow_call);

  GenerateFastArrayLoad(
      masm, edx, ecx, eax, edi, &check_number_dictionary, &slow_load);
  __ IncrementCounter(&Counters::keyed_call_generic_smi_fast, 1);

  __ bind(&do_call);
  // receiver in edx is not used after this point.
  // ecx: key
  // edi: function
  GenerateFunctionTailCall(masm, argc, &slow_call);

  __ bind(&check_number_dictionary);
  // eax: elements
  // ecx: smi key
  // Check whether the elements is a number dictionary.
  __ CheckMap(eax, Factory::hash_table_map(), &slow_load, true);
  __ mov(ebx, ecx);
  __ SmiUntag(ebx);
  // ebx: untagged index
  // Receiver in edx will be clobbered, need to reload it on miss.
  GenerateNumberDictionaryLoad(
      masm, &slow_reload_receiver, eax, ecx, ebx, edx, edi, edi);
  __ IncrementCounter(&Counters::keyed_call_generic_smi_dict, 1);
  __ jmp(&do_call);

  __ bind(&slow_reload_receiver);
  __ mov(edx, Operand(esp, (argc + 1) * kPointerSize));

  __ bind(&slow_load);
  // This branch is taken when calling KeyedCallIC_Miss is neither required
  // nor beneficial.
  __ IncrementCounter(&Counters::keyed_call_generic_slow_load, 1);
  __ EnterInternalFrame();
  __ push(ecx);  // save the key
  __ push(edx);  // pass the receiver
  __ push(ecx);  // pass the key
  __ CallRuntime(Runtime::kKeyedGetProperty, 2);
  __ pop(ecx);  // restore the key
  __ LeaveInternalFrame();
  __ mov(edi, eax);
  __ jmp(&do_call);

  __ bind(&check_string);
  GenerateKeyStringCheck(masm, ecx, eax, ebx, &index_string, &slow_call);

  // The key is known to be a symbol.
  // If the receiver is a regular JS object with slow properties then do
  // a quick inline probe of the receiver's dictionary.
  // Otherwise do the monomorphic cache probe.
  GenerateKeyedLoadReceiverCheck(
      masm, edx, eax, Map::kHasNamedInterceptor, &lookup_monomorphic_cache);

  __ mov(ebx, FieldOperand(edx, JSObject::kPropertiesOffset));
  __ CheckMap(ebx, Factory::hash_table_map(), &lookup_monomorphic_cache, true);

  GenerateDictionaryLoad(masm, &slow_load, ebx, ecx, eax, edi, edi);
  __ IncrementCounter(&Counters::keyed_call_generic_lookup_dict, 1);
  __ jmp(&do_call);

  __ bind(&lookup_monomorphic_cache);
  __ IncrementCounter(&Counters::keyed_call_generic_lookup_cache, 1);
  GenerateMonomorphicCacheProbe(masm, argc, Code::KEYED_CALL_IC);
  // Fall through on miss.

  __ bind(&slow_call);
  // This branch is taken if:
  // - the receiver requires boxing or access check,
  // - the key is neither smi nor symbol,
  // - the value loaded is not a function,
  // - there is hope that the runtime will create a monomorphic call stub
  //   that will get fetched next time.
  __ IncrementCounter(&Counters::keyed_call_generic_slow, 1);
  GenerateMiss(masm, argc);

  __ bind(&index_string);
  GenerateIndexFromHash(masm, ecx, ebx);
  // Now jump to the place where smi keys are handled.
  __ jmp(&index_smi);
}


void KeyedCallIC::GenerateNormal(MacroAssembler* masm, int argc) {
  // ----------- S t a t e -------------
  //  -- ecx                 : name
  //  -- esp[0]              : return address
  //  -- esp[(argc - n) * 4] : arg[n] (zero-based)
  //  -- ...
  //  -- esp[(argc + 1) * 4] : receiver
  // -----------------------------------

  GenerateCallNormal(masm, argc);
  GenerateMiss(masm, argc);
}


void KeyedCallIC::GenerateMiss(MacroAssembler* masm, int argc) {
  // ----------- S t a t e -------------
  //  -- ecx                 : name
  //  -- esp[0]              : return address
  //  -- esp[(argc - n) * 4] : arg[n] (zero-based)
  //  -- ...
  //  -- esp[(argc + 1) * 4] : receiver
  // -----------------------------------

  GenerateCallMiss(masm, argc, IC::kKeyedCallIC_Miss);
}


// Defined in ic.cc.
Object* LoadIC_Miss(Arguments args);

void LoadIC::GenerateMegamorphic(MacroAssembler* masm) {
  // ----------- S t a t e -------------
  //  -- eax    : receiver
  //  -- ecx    : name
  //  -- esp[0] : return address
  // -----------------------------------

  // Probe the stub cache.
  Code::Flags flags = Code::ComputeFlags(Code::LOAD_IC,
                                         NOT_IN_LOOP,
                                         MONOMORPHIC);
  StubCache::GenerateProbe(masm, flags, eax, ecx, ebx, edx);

  // Cache miss: Jump to runtime.
  GenerateMiss(masm);
}


void LoadIC::GenerateNormal(MacroAssembler* masm) {
  // ----------- S t a t e -------------
  //  -- eax    : receiver
  //  -- ecx    : name
  //  -- esp[0] : return address
  // -----------------------------------
  Label miss;

  GenerateDictionaryLoadReceiverCheck(masm, eax, edx, ebx, &miss);

  // edx: elements
  // Search the dictionary placing the result in eax.
  GenerateDictionaryLoad(masm, &miss, edx, ecx, edi, ebx, eax);
  __ ret(0);

  // Cache miss: Jump to runtime.
  __ bind(&miss);
  GenerateMiss(masm);
}


void LoadIC::GenerateMiss(MacroAssembler* masm) {
  // ----------- S t a t e -------------
  //  -- eax    : receiver
  //  -- ecx    : name
  //  -- esp[0] : return address
  // -----------------------------------

  __ IncrementCounter(&Counters::load_miss, 1);

  __ pop(ebx);
  __ push(eax);  // receiver
  __ push(ecx);  // name
  __ push(ebx);  // return address

  // Perform tail call to the entry.
  ExternalReference ref = ExternalReference(IC_Utility(kLoadIC_Miss));
  __ TailCallExternalReference(ref, 2, 1);
}


// One byte opcode for test eax,0xXXXXXXXX.
static const byte kTestEaxByte = 0xA9;


void LoadIC::ClearInlinedVersion(Address address) {
  // Reset the map check of the inlined inobject property load (if
  // present) to guarantee failure by holding an invalid map (the null
  // value).  The offset can be patched to anything.
  PatchInlinedLoad(address, Heap::null_value(), kMaxInt);
}


void KeyedLoadIC::ClearInlinedVersion(Address address) {
  // Insert null as the map to check for to make sure the map check fails
  // sending control flow to the IC instead of the inlined version.
  PatchInlinedLoad(address, Heap::null_value());
}


void KeyedStoreIC::ClearInlinedVersion(Address address) {
  // Insert null as the elements map to check for.  This will make
  // sure that the elements fast-case map check fails so that control
  // flows to the IC instead of the inlined version.
  PatchInlinedStore(address, Heap::null_value());
}


void KeyedStoreIC::RestoreInlinedVersion(Address address) {
  // Restore the fast-case elements map check so that the inlined
  // version can be used again.
  PatchInlinedStore(address, Heap::fixed_array_map());
}


bool LoadIC::PatchInlinedLoad(Address address, Object* map, int offset) {
  // The address of the instruction following the call.
  Address test_instruction_address =
      address + Assembler::kCallTargetAddressOffset;
  // If the instruction following the call is not a test eax, nothing
  // was inlined.
  if (*test_instruction_address != kTestEaxByte) return false;

  Address delta_address = test_instruction_address + 1;
  // The delta to the start of the map check instruction.
  int delta = *reinterpret_cast<int*>(delta_address);

  // The map address is the last 4 bytes of the 7-byte
  // operand-immediate compare instruction, so we add 3 to get the
  // offset to the last 4 bytes.
  Address map_address = test_instruction_address + delta + 3;
  *(reinterpret_cast<Object**>(map_address)) = map;

  // The offset is in the last 4 bytes of a six byte
  // memory-to-register move instruction, so we add 2 to get the
  // offset to the last 4 bytes.
  Address offset_address =
      test_instruction_address + delta + kOffsetToLoadInstruction + 2;
  *reinterpret_cast<int*>(offset_address) = offset - kHeapObjectTag;
  return true;
}


static bool PatchInlinedMapCheck(Address address, Object* map) {
  Address test_instruction_address =
      address + Assembler::kCallTargetAddressOffset;
  // The keyed load has a fast inlined case if the IC call instruction
  // is immediately followed by a test instruction.
  if (*test_instruction_address != kTestEaxByte) return false;

  // Fetch the offset from the test instruction to the map cmp
  // instruction.  This offset is stored in the last 4 bytes of the 5
  // byte test instruction.
  Address delta_address = test_instruction_address + 1;
  int delta = *reinterpret_cast<int*>(delta_address);
  // Compute the map address.  The map address is in the last 4 bytes
  // of the 7-byte operand-immediate compare instruction, so we add 3
  // to the offset to get the map address.
  Address map_address = test_instruction_address + delta + 3;
  // Patch the map check.
  *(reinterpret_cast<Object**>(map_address)) = map;
  return true;
}


bool KeyedLoadIC::PatchInlinedLoad(Address address, Object* map) {
  return PatchInlinedMapCheck(address, map);
}


bool KeyedStoreIC::PatchInlinedStore(Address address, Object* map) {
  return PatchInlinedMapCheck(address, map);
}


// Defined in ic.cc.
Object* KeyedLoadIC_Miss(Arguments args);


void KeyedLoadIC::GenerateMiss(MacroAssembler* masm) {
  // ----------- S t a t e -------------
  //  -- eax    : key
  //  -- edx    : receiver
  //  -- esp[0] : return address
  // -----------------------------------

  __ IncrementCounter(&Counters::keyed_load_miss, 1);

  __ pop(ebx);
  __ push(edx);  // receiver
  __ push(eax);  // name
  __ push(ebx);  // return address

  // Perform tail call to the entry.
  ExternalReference ref = ExternalReference(IC_Utility(kKeyedLoadIC_Miss));
  __ TailCallExternalReference(ref, 2, 1);
}


void KeyedLoadIC::GenerateRuntimeGetProperty(MacroAssembler* masm) {
  // ----------- S t a t e -------------
  //  -- eax    : key
  //  -- edx    : receiver
  //  -- esp[0] : return address
  // -----------------------------------

  __ pop(ebx);
  __ push(edx);  // receiver
  __ push(eax);  // name
  __ push(ebx);  // return address

  // Perform tail call to the entry.
  __ TailCallRuntime(Runtime::kKeyedGetProperty, 2, 1);
}


void StoreIC::GenerateMegamorphic(MacroAssembler* masm) {
  // ----------- S t a t e -------------
  //  -- eax    : value
  //  -- ecx    : name
  //  -- edx    : receiver
  //  -- esp[0] : return address
  // -----------------------------------

  Code::Flags flags = Code::ComputeFlags(Code::STORE_IC,
                                         NOT_IN_LOOP,
                                         MONOMORPHIC);
  StubCache::GenerateProbe(masm, flags, edx, ecx, ebx, no_reg);

  // Cache miss: Jump to runtime.
  GenerateMiss(masm);
}


void StoreIC::GenerateMiss(MacroAssembler* masm) {
  // ----------- S t a t e -------------
  //  -- eax    : value
  //  -- ecx    : name
  //  -- edx    : receiver
  //  -- esp[0] : return address
  // -----------------------------------

  __ pop(ebx);
  __ push(edx);
  __ push(ecx);
  __ push(eax);
  __ push(ebx);

  // Perform tail call to the entry.
  ExternalReference ref = ExternalReference(IC_Utility(kStoreIC_Miss));
  __ TailCallExternalReference(ref, 3, 1);
}


void StoreIC::GenerateArrayLength(MacroAssembler* masm) {
  // ----------- S t a t e -------------
  //  -- eax    : value
  //  -- ecx    : name
  //  -- edx    : receiver
  //  -- esp[0] : return address
  // -----------------------------------
  //
  // This accepts as a receiver anything JSObject::SetElementsLength accepts
  // (currently anything except for external and pixel arrays which means
  // anything with elements of FixedArray type.), but currently is restricted
  // to JSArray.
  // Value must be a number, but only smis are accepted as the most common case.

  Label miss;

  Register receiver = edx;
  Register value = eax;
  Register scratch = ebx;

  // Check that the receiver isn't a smi.
  __ test(receiver, Immediate(kSmiTagMask));
  __ j(zero, &miss, not_taken);

  // Check that the object is a JS array.
  __ CmpObjectType(receiver, JS_ARRAY_TYPE, scratch);
  __ j(not_equal, &miss, not_taken);

  // Check that elements are FixedArray.
  __ mov(scratch, FieldOperand(receiver, JSArray::kElementsOffset));
  __ CmpObjectType(scratch, FIXED_ARRAY_TYPE, scratch);
  __ j(not_equal, &miss, not_taken);

  // Check that value is a smi.
  __ test(value, Immediate(kSmiTagMask));
  __ j(not_zero, &miss, not_taken);

  // Prepare tail call to StoreIC_ArrayLength.
  __ pop(scratch);
  __ push(receiver);
  __ push(value);
  __ push(scratch);  // return address

  ExternalReference ref = ExternalReference(IC_Utility(kStoreIC_ArrayLength));
  __ TailCallExternalReference(ref, 2, 1);

  __ bind(&miss);

  GenerateMiss(masm);
}


// Defined in ic.cc.
Object* KeyedStoreIC_Miss(Arguments args);

void KeyedStoreIC::GenerateRuntimeSetProperty(MacroAssembler* masm) {
  // ----------- S t a t e -------------
  //  -- eax    : value
  //  -- ecx    : key
  //  -- edx    : receiver
  //  -- esp[0] : return address
  // -----------------------------------

  __ pop(ebx);
  __ push(edx);
  __ push(ecx);
  __ push(eax);
  __ push(ebx);

  // Do tail-call to runtime routine.
  __ TailCallRuntime(Runtime::kSetProperty, 3, 1);
}


void KeyedStoreIC::GenerateMiss(MacroAssembler* masm) {
  // ----------- S t a t e -------------
  //  -- eax    : value
  //  -- ecx    : key
  //  -- edx    : receiver
  //  -- esp[0] : return address
  // -----------------------------------

  __ pop(ebx);
  __ push(edx);
  __ push(ecx);
  __ push(eax);
  __ push(ebx);

  // Do tail-call to runtime routine.
  ExternalReference ref = ExternalReference(IC_Utility(kKeyedStoreIC_Miss));
  __ TailCallExternalReference(ref, 3, 1);
}

#undef __


} }  // namespace v8::internal

#endif  // V8_TARGET_ARCH_IA32
",16232,True,3204.4911377201947,median
"/*
 * This file is part of the Simutrans-Extended project under the Artistic License.
 * (see LICENSE.txt)
 */

#include ""welt.h""
#include ""simwin.h""
#include ""../simversion.h""
#include ""../dataobj/settings.h""
#include ""../dataobj/environment.h""
#include ""../dataobj/translator.h""
#include ""../player/finance.h"" // MAX_PLAYER_HISTORY_YEARS
#include ""../vehicle/vehicle.h""
#include ""../path_explorer.h""
#include ""settings_stats.h""
#include ""components/gui_divider.h""

/* stuff not set here ....
INIT_NUM( ""intercity_road_length"", env_t::intercity_road_length);
INIT_NUM( ""diagonal_multiplier"", pak_diagonal_multiplier);
*/

static char const* const version[] =
{
	""0.99.17"",
	""0.100.0"",
	""0.101.0"",
	""0.102.1"",
	""0.102.2"",
	""0.102.3"",
	""0.102.5"",
	""0.110.0"",
	""0.110.1"",
	""0.110.5"",
	""0.110.6"",
	""0.110.7"",
	""0.111.0"",
	""0.111.1"",
	""0.111.2"",
	""0.111.3"",
	""0.111.4"",
	""0.112.0"",
	""0.112.1"",
	""0.112.2"",
	""0.112.3"",
	""0.112.5"",
	""0.112.6"",
	""0.112.7"",
	""0.120.0"",
	""0.120.1"",
	""0.120.2"",
	""0.120.3"",
	""0.120.4"",
	""0.120.5"",
	""0.120.7"",
	""0.120.1.2"",
	""0.120.2.1"",
	""0.120.2.2""
};

static const char *version_ex[] =
{
	"""", /*Ex version 0 has no Ex string at all*/
	"".1"",
	"".2"",
	"".3"",
	"".4"",
	"".5"",
	"".6"",
	"".7"",
	"".8"",
	"".9"",
	"".10"",
	"".11"",
	"".12"",
	"".13"",
	"".14"",
	"".15"",
	"".16"",
	"".17""
};

static const char *revision_ex[] =
{
	""0"", /*Ex version 0 has no Ex string at all*/
	""1"",
	""2"",
	""3"",
	""4"",
	""5"",
	""6"",
	""7"",
	""8"",
	""9"",
	""10"",
	""11"",
	""12"",
	""13"",
	""14"",
	""15"",
	""16"",
	""17"",
	""18"",
	""19"",
	""20"",
	""21"",
	""22"",
	""23"",
	""24"",
	""25"",
	""26"",
	""27"",
	""28"",
	""29"",
	""30"",
	""31"",
	""32"",
	""33"",
	""34"",
	""35"",
	""36"",
	""37"",
	""38"",
	""39"",
	""40"",
	""41"",
	""42"",
	""43""
};


#define INIT_TABLE_END(tbl) \\
	ypos += (tbl).get_table_height();\\
	width = max(width, (tbl).get_pos().x * 2 + (tbl).get_table_width());\\
	tbl.set_size(tbl.get_table_size());


void settings_extended_general_stats_t::init( settings_t *sets )
{
	new_world = (win_get_magic(magic_welt_gui_t) != NULL);
	set_table_layout(1, 0);
	add_table(3, 2);
	{
		INIT_LB(""revenue of"");
		INIT_LB(""above\\nminutes"");
		INIT_LB(""get\\nrevenue $"");

		INIT_NUM_RANGE(""travelling post office"", sets->get_tpo_min_minutes(), 0, 14400, sets->get_tpo_revenue(), 0, 10000);
	}
	end_table();

	SEPERATOR;
	add_table(2,0);

#ifdef MULTI_THREAD
	world()->await_private_car_threads();
#endif

	INIT_NUM( ""city_threshold_size"", sets->get_city_threshold_size(), 1000, 100000, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""capital_threshold_size"", sets->get_capital_threshold_size(), 10000, 1000000, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""city_threshold_percentage"", sets->get_city_threshold_percentage(), 0, 100, gui_numberinput_t::PLAIN, false);
	INIT_NUM( ""capital_threshold_percentage"", sets->get_capital_threshold_percentage(), 0, 100, gui_numberinput_t::PLAIN, false);
	INIT_NUM( ""max_small_city_size"", sets->get_max_small_city_size(), 1000, 100000, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""max_city_size"", sets->get_max_city_size(), 10000, 1000000, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""congestion_density_factor"", sets->get_congestion_density_factor(), 0, 1024, gui_numberinput_t::AUTOLINEAR, false );
	INIT_BOOL( ""quick_city_growth"", sets->get_quick_city_growth());
	INIT_BOOL( ""assume_everywhere_connected_by_road"", sets->get_assume_everywhere_connected_by_road());
	INIT_NUM( ""max_route_tiles_to_process_in_a_step"", sets->get_max_route_tiles_to_process_in_a_step(), 0, 262140, gui_numberinput_t::AUTOLINEAR, false);
	INIT_NUM( ""max_route_tiles_to_process_in_a_step_paused_background"", sets->get_max_route_tiles_to_process_in_a_step_paused_background(), 0, 262140, gui_numberinput_t::AUTOLINEAR, false)
	INIT_BOOL(""toll_free_public_roads"", sets->get_toll_free_public_roads());
	INIT_NUM( ""spacing_shift_mode"", sets->get_spacing_shift_mode(), 0, 2 , gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""spacing_shift_divisor"", sets->get_spacing_shift_divisor(), 1, 32767 , gui_numberinput_t::AUTOLINEAR, false );
	INIT_BOOL( ""allow_routing_on_foot"", sets->get_allow_routing_on_foot());
	INIT_BOOL(""allow_airports_without_control_towers"", sets->get_allow_airports_without_control_towers());
	INIT_NUM(""global_power_factor_percent"", sets->get_global_power_factor_percent(), 0, 1000, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM(""global_force_factor_percent"", sets->get_global_force_factor_percent(), 0, 1000, gui_numberinput_t::AUTOLINEAR, false);
	INIT_NUM(""enforce_weight_limits"", sets->get_enforce_weight_limits(), 0, 3, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM(""max_diversion_tiles"", sets->get_max_diversion_tiles(), 0, 65535, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM(""way_degradation_fraction"", sets->get_way_degradation_fraction(), 0, 40, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM(""sighting_distance_meters"", sets->get_sighting_distance_meters(), 0, 7500, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM(""tilting_min_radius_effect"", sets->get_tilting_min_radius_effect(), 0, 10000, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM(""assumed_curve_radius_45_degrees"", sets->get_assumed_curve_radius_45_degrees(), 0, 10000, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM(""max_speed_drive_by_sight_kmh"", sets->get_max_speed_drive_by_sight_kmh(), 0, 1000, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM(""max_speed_drive_by_sight_tram_kmh"", sets->get_max_speed_drive_by_sight_tram_kmh(), 0, 1000, gui_numberinput_t::AUTOLINEAR, false);
	INIT_NUM(""time_interval_seconds_to_clear"", sets->get_time_interval_seconds_to_clear(), 0, 10000, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM(""time_interval_seconds_to_caution"", sets->get_time_interval_seconds_to_caution(), 0, 10000, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM(""town_road_speed_limit"", sets->get_town_road_speed_limit(), 0, 500, gui_numberinput_t::AUTOLINEAR, false);
	INIT_NUM(""minimum_staffing_percentage_consumer_industry"", sets->get_minimum_staffing_percentage_consumer_industry(), 0, 100, gui_numberinput_t::AUTOLINEAR, false);
	INIT_NUM(""minimum_staffing_percentage_full_production_producer_industry"", sets->get_minimum_staffing_percentage_full_production_producer_industry(), 0, 100, gui_numberinput_t::AUTOLINEAR, false);

	SEPERATOR;
	INIT_NUM(""population_per_level"", sets->get_population_per_level(), gui_numberinput_t::PLAIN, 1000, 1, false);
	INIT_NUM(""visitor_demand_per_level"", sets->get_visitor_demand_per_level(), 1, 1000, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""jobs_per_level"", sets->get_jobs_per_level(), 1, 1000, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""mail_per_level"", sets->get_mail_per_level(), 1, 1000, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""power_revenue_factor_percentage"", sets->get_power_revenue_factor_percentage(), 0, 10000, gui_numberinput_t::PLAIN, false);
	SEPERATOR;
	INIT_NUM(""forge_cost_road"", sets->get_forge_cost_road(), 0, 1000000, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""forge_cost_track"", sets->get_forge_cost_track(), 0, 1000000, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""forge_cost_water"", sets->get_forge_cost_water(), 0, 1000000, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""forge_cost_monorail"", sets->get_forge_cost_monorail(), 0, 1000000, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""forge_cost_maglev"", sets->get_forge_cost_maglev(), 0, 1000000, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""forge_cost_tram"", sets->get_forge_cost_tram(), 0, 1000000, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""forge_cost_narrowgauge"", sets->get_forge_cost_narrowgauge(), 0, 1000000, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""forge_cost_air"", sets->get_forge_cost_air(), 0, 1000000, gui_numberinput_t::PLAIN, false);

	SEPERATOR;
	INIT_BOOL(""rural_industries_no_staff_shortage"", sets->rural_industries_no_staff_shortage);
	INIT_NUM(""auto_connect_industries_and_attractions_by_road"", sets->auto_connect_industries_and_attractions_by_road, 0, 65535, gui_numberinput_t::PLAIN, false);

	SEPERATOR;
	INIT_NUM(""parallel_ways_forge_cost_percentage_road"", sets->get_parallel_ways_forge_cost_percentage_road(), 0, 100, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""parallel_ways_forge_cost_percentage_track"", sets->get_parallel_ways_forge_cost_percentage_track(), 0, 100, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""parallel_ways_forge_cost_percentage_water"", sets->get_parallel_ways_forge_cost_percentage_water(), 0, 100, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""parallel_ways_forge_cost_percentage_monorail"", sets->get_parallel_ways_forge_cost_percentage_monorail(), 0, 100, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""parallel_ways_forge_cost_percentage_maglev"", sets->get_parallel_ways_forge_cost_percentage_maglev(), 0, 100, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""parallel_ways_forge_cost_percentage_tram"", sets->get_parallel_ways_forge_cost_percentage_tram(), 0, 100, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""parallel_ways_forge_cost_percentage_narrowgauge"", sets->get_parallel_ways_forge_cost_percentage_narrowgauge(), 0, 100, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""parallel_ways_forge_cost_percentage_air"", sets->get_parallel_ways_forge_cost_percentage_air(), 0, 100, gui_numberinput_t::PLAIN, false);

	SEPERATOR;
	INIT_NUM(""default_increase_maintenance_after_years_road"", sets->get_default_increase_maintenance_after_years(road_wt), 0, 1000, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""default_increase_maintenance_after_years_rail"", sets->get_default_increase_maintenance_after_years(track_wt), 0, 1000, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""default_increase_maintenance_after_years_water"", sets->get_default_increase_maintenance_after_years(water_wt), 0, 1000, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""default_increase_maintenance_after_years_monorail"", sets->get_default_increase_maintenance_after_years(monorail_wt), 0, 1000, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""default_increase_maintenance_after_years_maglev"", sets->get_default_increase_maintenance_after_years(maglev_wt), 0, 1000, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""default_increase_maintenance_after_years_tram"", sets->get_default_increase_maintenance_after_years(tram_wt), 0, 1000, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""default_increase_maintenance_after_years_narrowgauge"", sets->get_default_increase_maintenance_after_years(narrowgauge_wt), 0, 1000, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""default_increase_maintenance_after_years_air"", sets->get_default_increase_maintenance_after_years(air_wt), 0, 1000, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""default_increase_maintenance_after_years_other"", sets->get_default_increase_maintenance_after_years(overheadlines_wt), 0, 1000, gui_numberinput_t::PLAIN, false);

	SEPERATOR;

	INIT_NUM(""path_explorer_time_midpoint"", sets->get_path_explorer_time_midpoint(), 1, 2048, gui_numberinput_t::PLAIN, false);
	INIT_BOOL(""save_path_explorer_data"", sets->get_save_path_explorer_data());

	SEPERATOR;

	INIT_BOOL(""pause_server_no_clients"", env_t::pause_server_no_clients);
	INIT_BOOL(""server_runs_background_tasks_when_paused"", env_t::server_runs_background_tasks_when_paused);

	SEPERATOR;

	INIT_BOOL(""show_future_vehicle_information"", sets->get_show_future_vehicle_info());

	SEPERATOR;

	INIT_NUM(""industry_density_proportion_override"", sets->get_industry_density_proportion_override(), 0, 65535, gui_numberinput_t::AUTOLINEAR, false);

	SEPERATOR;

	INIT_NUM(""do_not_record_private_car_routes_to_city_attractions"", sets->get_do_not_record_private_car_routes_to_city_attractions(), 0, 65535, gui_numberinput_t::PLAIN, false);
	INIT_NUM(""do_not_record_private_car_routes_to_city_industries"", sets->get_do_not_record_private_car_routes_to_city_industries(), 0, 65535, gui_numberinput_t::PLAIN, false);
	INIT_BOOL(""do_not_record_private_car_routes_to_distant_non_consumer_industries "", sets->get_do_not_record_private_car_routes_to_distant_non_consumer_industries());
	INIT_BOOL(""do_not_record_private_car_routes_to_city_buildings"", sets->get_do_not_record_private_car_routes_to_city_buildings());

	INIT_END
}


void settings_extended_general_stats_t::read(settings_t *sets)
{
#ifdef MULTI_THREAD
	world()->await_private_car_threads();
#endif
	READ_INIT;

	READ_NUM( sets->set_tpo_min_minutes );
	READ_NUM( sets->set_tpo_revenue );

	READ_NUM( sets->set_city_threshold_size );
	READ_NUM( sets->set_capital_threshold_size );
	READ_NUM( sets->set_city_threshold_percentage );
	READ_NUM(sets->set_capital_threshold_percentage);
	READ_NUM( sets->set_max_small_city_size );
	READ_NUM( sets->set_max_city_size );
	READ_NUM( sets->set_congestion_density_factor );
	READ_BOOL( sets->set_quick_city_growth );
	READ_BOOL( sets->set_assume_everywhere_connected_by_road );
	READ_NUM( sets->set_max_route_tiles_to_process_in_a_step );
	READ_NUM( sets->set_max_route_tiles_to_process_in_a_step_paused_background );
	READ_BOOL_VALUE(sets->toll_free_public_roads);
	READ_NUM( sets->set_spacing_shift_mode );
	READ_NUM( sets->set_spacing_shift_divisor);
	READ_BOOL( sets->set_allow_routing_on_foot);
	READ_BOOL( sets->set_allow_airports_without_control_towers );
	READ_NUM( sets->set_global_power_factor_percent );
	READ_NUM( sets->set_global_force_factor_percent );
	READ_NUM( sets->set_enforce_weight_limits );
	READ_NUM_VALUE( sets->max_diversion_tiles );
	READ_NUM_VALUE( sets->way_degradation_fraction );
	READ_NUM_VALUE( sets->sighting_distance_meters );
	sets->sighting_distance_tiles = sets->sighting_distance_meters / sets->meters_per_tile;
	READ_NUM_VALUE( sets->tilting_min_radius_effect );
	READ_NUM_VALUE( sets->assumed_curve_radius_45_degrees );
	READ_NUM_VALUE( sets->max_speed_drive_by_sight_kmh );
	sets->max_speed_drive_by_sight = kmh_to_speed(sets->max_speed_drive_by_sight_kmh);
	READ_NUM_VALUE( sets->max_speed_drive_by_sight_tram_kmh );
	sets->max_speed_drive_by_sight_tram = kmh_to_speed(sets->max_speed_drive_by_sight_tram_kmh);
	READ_NUM_VALUE( sets->time_interval_seconds_to_clear );
	READ_NUM_VALUE( sets->time_interval_seconds_to_caution );
	READ_NUM_VALUE( sets->town_road_speed_limit );
	READ_NUM_VALUE(sets->minimum_staffing_percentage_consumer_industry);
	READ_NUM_VALUE(sets->minimum_staffing_percentage_full_production_producer_industry);

	READ_NUM_VALUE(sets->population_per_level);
	READ_NUM_VALUE(sets->visitor_demand_per_level);
	READ_NUM_VALUE(sets->jobs_per_level);
	READ_NUM_VALUE(sets->mail_per_level);
	READ_NUM_VALUE(sets->power_revenue_factor_percentage);

	READ_NUM_VALUE(sets->forge_cost_road);
	READ_NUM_VALUE(sets->forge_cost_track);
	READ_NUM_VALUE(sets->forge_cost_water);
	READ_NUM_VALUE(sets->forge_cost_monorail);
	READ_NUM_VALUE(sets->forge_cost_maglev);
	READ_NUM_VALUE(sets->forge_cost_tram);
	READ_NUM_VALUE(sets->forge_cost_narrowgauge);
	READ_NUM_VALUE(sets->forge_cost_air);

	READ_BOOL_VALUE(sets->rural_industries_no_staff_shortage);
	READ_NUM_VALUE(sets->auto_connect_industries_and_attractions_by_road);

	READ_NUM_VALUE(sets->parallel_ways_forge_cost_percentage_road);
	READ_NUM_VALUE(sets->parallel_ways_forge_cost_percentage_track);
	READ_NUM_VALUE(sets->parallel_ways_forge_cost_percentage_water);
	READ_NUM_VALUE(sets->parallel_ways_forge_cost_percentage_monorail);
	READ_NUM_VALUE(sets->parallel_ways_forge_cost_percentage_maglev);
	READ_NUM_VALUE(sets->parallel_ways_forge_cost_percentage_tram);
	READ_NUM_VALUE(sets->parallel_ways_forge_cost_percentage_narrowgauge);
	READ_NUM_VALUE(sets->parallel_ways_forge_cost_percentage_air);

	uint16 default_increase_maintenance_after_years_other;
	READ_NUM_VALUE( default_increase_maintenance_after_years_other );
	for(uint8 i = road_wt; i <= air_wt; i ++)
	{
		switch(i)
		{
		case road_wt:
		case track_wt:
		case water_wt:
		case monorail_wt:
		case maglev_wt:
		case tram_wt:
		case narrowgauge_wt:
		case air_wt:
			sets->set_default_increase_maintenance_after_years((waytype_t)i, (*numiter++)->get_value());
			break;
		default:
			sets->set_default_increase_maintenance_after_years((waytype_t)i, default_increase_maintenance_after_years_other);
		}
	}

	READ_NUM_VALUE(sets->path_explorer_time_midpoint);
	READ_BOOL_VALUE(sets->save_path_explorer_data);

	READ_BOOL_VALUE(env_t::pause_server_no_clients);
	READ_BOOL_VALUE(env_t::server_runs_background_tasks_when_paused);

	READ_BOOL_VALUE(sets->show_future_vehicle_info);

	READ_NUM_VALUE(sets->industry_density_proportion_override);

	READ_NUM_VALUE(sets->private_car_route_to_attraction_visitor_demand_threshold);
	READ_NUM_VALUE(sets->private_car_route_to_industry_visitor_demand_threshold);
	READ_BOOL_VALUE(sets->do_not_record_private_car_routes_to_distant_non_consumer_industries);
	READ_BOOL_VALUE(sets->do_not_record_private_car_routes_to_city_buildings);

	path_explorer_t::set_absolute_limits_external();
}


void settings_extended_revenue_stats_t::init( settings_t *sets )
{
	INIT_INIT;
	INIT_NUM( ""passenger_trips_per_month_hundredths"", sets->get_passenger_trips_per_month_hundredths(), 0, 4096, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""mail_packets_per_month_hundredths"", sets->get_mail_packets_per_month_hundredths(), 0, 4096, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""passenger_routing_packet_size"", sets->get_passenger_routing_packet_size(), 1, 64, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM(""max_onward_trips"", sets->get_max_onward_trips(), 0, 32, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM(""onward_trip_chance_percent"", sets->get_onward_trip_chance_percent(), 0, 100, gui_numberinput_t::PROGRESS, false );
	INIT_NUM(""commuting_trip_chance_percent"", sets->get_commuting_trip_chance_percent(), 0, 100, gui_numberinput_t::PROGRESS, false );
	INIT_NUM( ""max_alternative_destinations_visiting"", sets->get_max_alternative_destinations_visiting(), 0, 65534, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""max_alternative_destinations_commuting"", sets->get_max_alternative_destinations_commuting(), 0, 65534, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""max_alternative_destinations_per_visitor_demand_millionths"", sets->get_max_alternative_destinations_per_visitor_demand_millionths(), 0, 65534, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""max_alternative_destinations_per_job_millionths"", sets->get_max_alternative_destinations_per_job_millionths(), 0, 65534, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM(""min_alternative_destinations_visiting"", sets->get_min_alternative_destinations_visiting(), 0, 65534, gui_numberinput_t::AUTOLINEAR, false);
	INIT_NUM(""min_alternative_destinations_commuting"", sets->get_min_alternative_destinations_commuting(), 0, 65534, gui_numberinput_t::AUTOLINEAR, false);
	INIT_NUM(""min_alternative_destinations_per_visitor_demand_millionths"", sets->get_min_alternative_destinations_per_visitor_demand_millionths(), 0, 65534, gui_numberinput_t::AUTOLINEAR, false);
	INIT_NUM(""min_alternative_destinations_per_job_millionths"", sets->get_min_alternative_destinations_per_job_millionths(), 0, 65534, gui_numberinput_t::AUTOLINEAR, false);
	INIT_NUM(""passenger_max_wait"", sets->get_passenger_max_wait(), 0, 311040, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM(""min_wait_airport"", sets->get_min_wait_airport(), 0, 311040, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM(""random_mode_commuting"", sets->get_random_mode_commuting(), 0, 16, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM(""random_mode_visiting"", sets->get_random_mode_visiting(), 0, 16, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM(""tolerance_modifier_percentage"", sets->get_tolerance_modifier_percentage(), 0, 8192, gui_numberinput_t::AUTOLINEAR, false );
	end_table();

	add_table(3,0);
	{
		INIT_LB(""passenger\\ndistribution"");
		// Note: ""Waiting"" here should be ""journey time"": these are translated in en.tab, but should be correct in other translations, too.
		INIT_LB(""waiting\\ntolerance\\nmin. min"");
		INIT_LB(""waiting\\ntolerance\\nmax. min"");

		INIT_NUM_RANGE(""commuting"", sets->get_min_commuting_tolerance()/10, 1, 5256000, sets->get_range_commuting_tolerance()/10, 1, 5256000);
		INIT_NUM_RANGE(""visiting"", sets->get_min_visiting_tolerance()/10, 1, 5256000, sets->get_range_visiting_tolerance()/10, 1, 5256000);

		new_component_span<gui_divider_t>(3);

		INIT_LB(""comfort expectance\\nfor travelling"");
		INIT_LB(""duration\\nin minutes"");
		INIT_LB(""min comfort\\nrating"");

		INIT_NUM_RANGE(""short time"", sets->get_tolerable_comfort_short_minutes(), 0, 120, sets->get_tolerable_comfort_short(), 0, 255);
		INIT_NUM_RANGE(""median short time"", sets->get_tolerable_comfort_median_short_minutes(), 0, 720, sets->get_tolerable_comfort_median_short(), 0, 255);
		INIT_NUM_RANGE(""median median time"", sets->get_tolerable_comfort_median_median_minutes(), 0, 1440, sets->get_tolerable_comfort_median_median(), 0, 255);
		INIT_NUM_RANGE(""median long time"", sets->get_tolerable_comfort_median_long_minutes(), 0, 1440*7, sets->get_tolerable_comfort_median_long(), 0, 255);
		INIT_NUM_RANGE(""long time"", sets->get_tolerable_comfort_long_minutes(), 0, 1440*30, sets->get_tolerable_comfort_long(), 0, 255);

		new_component_span<gui_divider_t>(3);

		INIT_LB(""comfort impact\\nlimitations"");
		INIT_LB(""differential"");
		INIT_LB(""percent"");
		INIT_NUM_RANGE(""max luxury bonus"", sets->get_max_luxury_bonus_differential(), 0, 250, sets->get_max_luxury_bonus_percent(), 0, 1000);
		INIT_NUM_RANGE(""max discomfort penalty"", sets->get_max_discomfort_penalty_differential(), 0, 250, sets->get_max_discomfort_penalty_percent(), 0, 1000);

		new_component_span<gui_divider_t>(3);

		INIT_LB(""catering bonus\\nfor travelling"");
		INIT_LB(""duration\\nin minutes"");
		INIT_LB(""max catering\\nrevenue $"");

		INIT_LB(""min traveltime"");
		gui_numberinput_t *ni_mt = new_component<gui_numberinput_t>();
		ni_mt->init(sets->get_catering_min_minutes(), 0, 14400);
		numinp.append(ni_mt);
		new_component<gui_empty_t>();

		INIT_NUM_RANGE(""catering level 1"", sets->get_catering_level1_minutes(), 0, 14400, sets->get_catering_level1_max_revenue(), 0, 10000);
		INIT_NUM_RANGE(""catering level 2"", sets->get_catering_level2_minutes(), 0, 14400, sets->get_catering_level2_max_revenue(), 0, 10000);
		INIT_NUM_RANGE(""catering level 3"", sets->get_catering_level3_minutes(), 0, 14400, sets->get_catering_level3_max_revenue(), 0, 10000);
		INIT_NUM_RANGE(""catering level 4"", sets->get_catering_level4_minutes(), 0, 14400, sets->get_catering_level4_max_revenue(), 0, 10000);
		INIT_NUM_RANGE(""catering level 5"", sets->get_catering_level5_minutes(), 0, 14400, sets->get_catering_level5_max_revenue(), 0, 10000);
	}
	end_table();

	add_table(2, 0);
	SEPERATOR;
	INIT_NUM(""max_comfort_preference_percentage"", sets->get_max_comfort_preference_percentage(), 100, 65535, gui_numberinput_t::AUTOLINEAR, false);

	INIT_END
}


void settings_extended_revenue_stats_t::read(settings_t *sets)
{
	READ_INIT
	(void)booliter;

	READ_NUM_VALUE( sets->passenger_trips_per_month_hundredths );
	READ_NUM_VALUE( sets->mail_packets_per_month_hundredths );
	READ_NUM_VALUE( sets->passenger_routing_packet_size );
	READ_NUM_VALUE( sets->max_onward_trips );
	READ_NUM_VALUE( sets->onward_trip_chance_percent );
	READ_NUM_VALUE( sets->commuting_trip_chance_percent );
	READ_NUM_VALUE( sets->max_alternative_destinations_visiting );
	READ_NUM_VALUE( sets->max_alternative_destinations_commuting );
	READ_NUM_VALUE( sets->max_alternative_destinations_per_visitor_demand_millionths );
	READ_NUM_VALUE( sets->max_alternative_destinations_per_job_millionths );
	READ_NUM_VALUE(sets->min_alternative_destinations_visiting);
	READ_NUM_VALUE(sets->min_alternative_destinations_commuting);
	READ_NUM_VALUE(sets->min_alternative_destinations_per_visitor_demand_millionths);
	READ_NUM_VALUE(sets->min_alternative_destinations_per_job_millionths);
	READ_NUM_VALUE( sets->passenger_max_wait );
	READ_NUM_VALUE( sets->min_wait_airport );
	READ_NUM_VALUE( sets->random_mode_commuting );
	READ_NUM_VALUE( sets->random_mode_visiting );
	READ_NUM_VALUE( sets->tolerance_modifier_percentage );

	READ_NUM_VALUE_TENTHS( (sets->min_commuting_tolerance) );
	READ_NUM_VALUE_TENTHS( sets->range_commuting_tolerance);
	READ_NUM_VALUE_TENTHS( sets->min_visiting_tolerance );
	READ_NUM_VALUE_TENTHS( sets->range_visiting_tolerance );
	READ_NUM_VALUE( sets->tolerable_comfort_short_minutes );
	READ_NUM_VALUE( sets->tolerable_comfort_short );
	READ_NUM_VALUE( sets->tolerable_comfort_median_short_minutes );
	READ_NUM_VALUE( sets->tolerable_comfort_median_short );
	READ_NUM_VALUE( sets->tolerable_comfort_median_median_minutes );
	READ_NUM_VALUE( sets->tolerable_comfort_median_median );
	READ_NUM_VALUE( sets->tolerable_comfort_median_long_minutes );
	READ_NUM_VALUE( sets->tolerable_comfort_median_long );
	READ_NUM_VALUE( sets->tolerable_comfort_long_minutes );
	READ_NUM_VALUE( sets->tolerable_comfort_long );

	READ_NUM_VALUE( sets->max_luxury_bonus_differential );
	READ_NUM_VALUE( sets->max_luxury_bonus_percent );
	READ_NUM_VALUE( sets->max_discomfort_penalty_differential );
	READ_NUM_VALUE( sets->max_discomfort_penalty_percent );

	READ_NUM_VALUE( sets->catering_min_minutes );
	READ_NUM_VALUE( sets->catering_level1_minutes );
	READ_NUM_VALUE( sets->catering_level1_max_revenue );
	READ_NUM_VALUE( sets->catering_level2_minutes );
	READ_NUM_VALUE( sets->catering_level2_max_revenue );
	READ_NUM_VALUE( sets->catering_level3_minutes );
	READ_NUM_VALUE( sets->catering_level3_max_revenue );
	READ_NUM_VALUE( sets->catering_level4_minutes );
	READ_NUM_VALUE( sets->catering_level4_max_revenue );
	READ_NUM_VALUE( sets->catering_level5_minutes );
	READ_NUM_VALUE( sets->catering_level5_max_revenue );

	READ_NUM_VALUE(sets->max_comfort_preference_percentage);

	// And convert to the form used in-game...
	sets->cache_catering_revenues();
	sets->cache_comfort_tables();
}

bool settings_general_stats_t::action_triggered(gui_action_creator_t *comp, value_t v)
{
	assert( comp==&savegame || comp==&savegame_ex || comp ==&savegame_ex_rev); (void)comp;

	if(  v.i==-1  )
	{
		if(comp==&savegame)
		{
			savegame.set_selection( 0 );
		}
		else if( comp==&savegame_ex )
		{
			savegame_ex.set_selection( 0 );
		}
		else if( comp == &savegame_ex_rev )
		{
			savegame_ex_rev.set_selection( 0 );
		}
	}
	return true;
}

/* Nearly automatic lists with controls:
 * BEWARE: The init exit pair MUST match in the same order or else!!!
 */
void settings_general_stats_t::init(settings_t const* const sets)
{
	INIT_INIT

	// combobox for savegame version
	savegame.clear_elements();
	for(  uint32 i=0;  i<lengthof(version);  i++  ) {
		savegame.new_component<gui_scrolled_list_t::const_text_scrollitem_t>( version[i]+2, SYSCOL_TEXT );
		if(  strcmp(version[i],env_t::savegame_version_str)==0  ) {
			savegame.set_selection( i );
		}
	}
	savegame.set_focusable( false );
	savegame.set_width_fixed( true );
	savegame.set_size(D_EDIT_SIZE);
	add_component( &savegame );
	savegame.add_listener( this );
	INIT_LB( ""savegame version"" );
	SEPERATOR
	INIT_BOOL( ""drive_left"", sets->is_drive_left() );
	INIT_BOOL( ""signals_on_left"", sets->is_signals_left() );
	SEPERATOR
	INIT_NUM( ""autosave"", env_t::autosave, 0, 12, gui_numberinput_t::AUTOLINEAR, false );
	//INIT_NUM( ""frames_per_second"",env_t::fps, 10, 30, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""fast_forward"", env_t::max_acceleration, 1, 1000, gui_numberinput_t::AUTOLINEAR, false );
	SEPERATOR
	INIT_BOOL( ""numbered_stations"", sets->get_numbered_stations() );
	INIT_NUM( ""show_names"", env_t::show_names, 0, 7, gui_numberinput_t::AUTOLINEAR, true );
	SEPERATOR
	INIT_NUM( ""bits_per_month"", sets->get_bits_per_month(), 16, 48, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""use_timeline"", sets->get_use_timeline(), 0, 3, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM_NEW( ""starting_year"", sets->get_starting_year(), 0, 2999, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM_NEW( ""starting_month"", sets->get_starting_month(), 0, 11, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""show_month"", env_t::show_month, 0, 9, gui_numberinput_t::AUTOLINEAR, true );
	SEPERATOR
	INIT_NUM( ""random_grounds_probability"", env_t::ground_object_probability, 0, 0x7FFFFFFFul, gui_numberinput_t::POWER2, false );
	INIT_NUM( ""random_wildlife_probability"", env_t::moving_object_probability, 0, 0x7FFFFFFFul, gui_numberinput_t::POWER2, false );
	SEPERATOR
	INIT_BOOL( ""pedes_and_car_info"", env_t::road_user_info );
	INIT_BOOL( ""tree_info"", env_t::tree_info );
	INIT_BOOL( ""ground_info"", env_t::ground_info );
	INIT_BOOL( ""townhall_info"", env_t::townhall_info );
	INIT_BOOL( ""only_single_info"", env_t::single_info );
	SEPERATOR
	INIT_NUM( ""compass_map_position"", env_t::compass_map_position, 0, 16, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""compass_screen_position"", env_t::compass_screen_position, 0, 16, gui_numberinput_t::AUTOLINEAR, false );
	SEPERATOR
	INIT_NUM( ""world_maximum_height"", sets->get_maximumheight(), 16, 127, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""world_minimum_height"", sets->get_minimumheight(), -127, -12, gui_numberinput_t::AUTOLINEAR, false );

	SEPERATOR

	// comboboxes for Extended savegame version and revision
	savegame_ex.clear_elements();
	for(  uint32 i=0;  i<lengthof(version_ex);  i++  )
	{
		if(i == 0)
		{
			savegame_ex.new_component<gui_scrolled_list_t::const_text_scrollitem_t>( ""0"", SYSCOL_TEXT );
		}
		else
		{
			savegame_ex.new_component<gui_scrolled_list_t::const_text_scrollitem_t>( version_ex[i]+1, SYSCOL_TEXT );
		}
		if(  strcmp(version_ex[i],EXTENDED_VER_NR)==0  )
		{
			savegame_ex.set_selection( i );
		}
	}
	savegame_ex.set_focusable( false );
	savegame_ex.set_width_fixed( true );
	savegame_ex.set_size(D_EDIT_SIZE);
	add_component( &savegame_ex );
	savegame_ex.add_listener( this );
	INIT_LB( ""savegame Extended version"" );

	savegame_ex_rev.clear_elements();
	for(  uint32 i=0;  i<lengthof(revision_ex);  i++  )
	{
		if(i == 0)
		{
			savegame_ex_rev.new_component<gui_scrolled_list_t::const_text_scrollitem_t>( ""0"", SYSCOL_TEXT );
		}
		else
		{
			savegame_ex_rev.new_component<gui_scrolled_list_t::const_text_scrollitem_t>( revision_ex[i], SYSCOL_TEXT );
		}
		if(  strcmp(revision_ex[i],QUOTEME(EX_SAVE_MINOR))==0  )
		{
			savegame_ex_rev.set_selection( i );
		}
	}
	savegame_ex_rev.set_focusable( false );
	savegame_ex_rev.set_width_fixed( true );
	savegame_ex_rev.set_size(D_EDIT_SIZE);
	add_component( &savegame_ex_rev );
	savegame_ex_rev.add_listener( this );
	INIT_LB( ""savegame Extended revision"" );

	INIT_END
	clear_dirty();
}

void settings_general_stats_t::read(settings_t* const sets)
{
	READ_INIT

	int selected = savegame.get_selection();
	if(  0 <= selected  &&  (uint32)selected < lengthof(version)  ) {
		env_t::savegame_version_str = version[ selected ];
	}

	READ_BOOL_VALUE( sets->drive_on_left );
	vehicle_base_t::set_overtaking_offsets( sets->drive_on_left );
	READ_BOOL_VALUE( sets->signals_on_left );

	READ_NUM_VALUE( env_t::autosave );
	READ_NUM_VALUE( env_t::max_acceleration );

	READ_BOOL_VALUE( sets->numbered_stations );
	READ_NUM_VALUE( env_t::show_names );

	READ_NUM_VALUE( sets->bits_per_month );
	READ_NUM_VALUE( sets->use_timeline );
	READ_NUM_VALUE_NEW( sets->starting_year );
	READ_NUM_VALUE_NEW( sets->starting_month );
	READ_NUM_VALUE( env_t::show_month );

	READ_NUM_VALUE( env_t::ground_object_probability );
	READ_NUM_VALUE( env_t::moving_object_probability );

	READ_BOOL_VALUE( env_t::road_user_info );
	READ_BOOL_VALUE( env_t::tree_info );
	READ_BOOL_VALUE( env_t::ground_info );
	READ_BOOL_VALUE( env_t::townhall_info );
	READ_BOOL_VALUE( env_t::single_info );

	READ_NUM_VALUE( env_t::compass_map_position );
	READ_NUM_VALUE( env_t::compass_screen_position );

	READ_NUM_VALUE( sets->world_maximum_height );
	READ_NUM_VALUE( sets->world_minimum_height );

	sets->calc_job_replenishment_ticks();

	const int selected_ex = savegame_ex.get_selection();
	if (selected_ex >= 0 &&  selected_ex < (sint32)lengthof(version_ex)) {
		env_t::savegame_ex_version_str = version_ex[ selected_ex ];
	}

	const int selected_ex_rev = savegame_ex_rev.get_selection();
	if (selected_ex_rev >= 0 &&  selected_ex_rev < (sint32)lengthof(revision_ex)) {
		env_t::savegame_ex_revision_str = revision_ex[ selected_ex_rev ];
	}
}

void settings_display_stats_t::init(settings_t const* const)
{
	INIT_INIT
	INIT_NUM( ""frames_per_second"",env_t::fps, env_t::min_fps, env_t::max_fps, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""fast_forward_frames_per_second"", env_t::ff_fps, env_t::min_fps, env_t::max_fps, gui_numberinput_t::AUTOLINEAR, false);
	INIT_NUM( ""simple_drawing_tile_size"",env_t::simple_drawing_default, 2, 256, gui_numberinput_t::POWER2, false );
	INIT_BOOL( ""simple_drawing_fast_forward"",env_t::simple_drawing_fast_forward );
	INIT_NUM( ""water_animation_ms"", env_t::water_animation, 0, 1000, 25, false );
	INIT_NUM( ""follow_convoi_underground"", env_t::follow_convoi_underground, 0, 2, 1, true );
	SEPERATOR
	INIT_BOOL( ""window_buttons_right"", env_t::window_buttons_right );
	INIT_BOOL( ""window_frame_active"", env_t::window_frame_active );
	INIT_NUM( ""default_window_title_color"", env_t::default_window_title_color_rgb, 0, 16777215, gui_numberinput_t::AUTOLINEAR, 0 );
	INIT_NUM( ""front_window_text_color"", env_t::front_window_text_color_rgb, 0, 16777215, gui_numberinput_t::AUTOLINEAR, 0 );
	INIT_NUM( ""bottom_window_text_color"", env_t::bottom_window_text_color_rgb, 0, 16777215, gui_numberinput_t::AUTOLINEAR, 0 );
	INIT_NUM( ""bottom_window_darkness"", env_t::bottom_window_darkness, 0, 100, gui_numberinput_t::AUTOLINEAR, 0 );
	SEPERATOR
	INIT_BOOL( ""show_tooltips"", env_t::show_tooltips );
	INIT_NUM( ""tooltip_background_color"", env_t::tooltip_color_rgb, 0, 16777215, 1, 0 );
	INIT_NUM( ""tooltip_text_color"", env_t::tooltip_textcolor_rgb, 0, 16777215, 1, 0 );
	INIT_NUM( ""tooltip_delay"", env_t::tooltip_delay, 0, 10000, gui_numberinput_t::AUTOLINEAR, 0 );
	INIT_NUM( ""tooltip_duration"", env_t::tooltip_duration, 0, 30000, gui_numberinput_t::AUTOLINEAR, 0 );
	SEPERATOR
	INIT_NUM( ""cursor_overlay_color"", env_t::cursor_overlay_color_rgb, 0, 16777215, gui_numberinput_t::AUTOLINEAR, 0 );
	INIT_BOOL( ""left_to_right_graphs"", env_t::left_to_right_graphs );
	SEPERATOR
	INIT_BOOL( ""player_finance_display_account"", env_t::player_finance_display_account );

	INIT_END
}

void settings_display_stats_t::read(settings_t* const)
{
	READ_INIT
	// all visual stuff
	READ_NUM_VALUE( env_t::fps );
	READ_NUM_VALUE( env_t::ff_fps );
	READ_NUM_VALUE( env_t::simple_drawing_default );
	READ_BOOL_VALUE( env_t::simple_drawing_fast_forward );
	READ_NUM_VALUE( env_t::water_animation );
	READ_NUM_VALUE( env_t::follow_convoi_underground );

	READ_BOOL_VALUE( env_t::window_buttons_right );
	READ_BOOL_VALUE( env_t::window_frame_active );
	READ_NUM_VALUE( env_t::default_window_title_color_rgb );
	READ_NUM_VALUE( env_t::front_window_text_color_rgb );
	READ_NUM_VALUE( env_t::bottom_window_text_color_rgb );
	READ_NUM_VALUE( env_t::bottom_window_darkness );

	READ_BOOL_VALUE( env_t::show_tooltips );
	READ_NUM_VALUE( env_t::tooltip_color_rgb );
	READ_NUM_VALUE( env_t::tooltip_textcolor_rgb );
	READ_NUM_VALUE( env_t::tooltip_delay );
	READ_NUM_VALUE( env_t::tooltip_duration );

	READ_NUM_VALUE( env_t::cursor_overlay_color_rgb );
	READ_BOOL_VALUE( env_t::left_to_right_graphs );

	READ_BOOL_VALUE( env_t::player_finance_display_account );
}

void settings_routing_stats_t::init(settings_t const* const sets)
{
	INIT_INIT
	INIT_BOOL( ""separate_halt_capacities"", sets->is_separate_halt_capacities() );
	INIT_BOOL( ""avoid_overcrowding"", sets->is_avoid_overcrowding() );
	SEPERATOR
	INIT_NUM( ""max_route_steps"", sets->get_max_route_steps(), 0, 0x7FFFFFFFul, gui_numberinput_t::POWER2, false );
	INIT_NUM( ""max_choose_route_steps"", sets->get_max_choose_route_steps(), 0, 0x7FFFFFFFul, gui_numberinput_t::POWER2, false );
	INIT_NUM( ""max_hops"", sets->get_max_hops(), 100, 65000, gui_numberinput_t::POWER2, false );
	INIT_NUM( ""max_transfers"", sets->get_max_transfers(), 1, 100, gui_numberinput_t::AUTOLINEAR, false );
	SEPERATOR
	INIT_NUM( ""way_straight"", sets->way_count_straight, 1, 1000, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""way_curve"", sets->way_count_curve, 1, 1000, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""way_double_curve"", sets->way_count_double_curve, 1, 1000, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""way_90_curve"", sets->way_count_90_curve, 1, 1000, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""way_slope"", sets->way_count_slope, 1, 1000, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""way_tunnel"", sets->way_count_tunnel, 1, 1000, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""way_max_bridge_len"", sets->way_max_bridge_len, 1, 1000, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""way_leaving_road"", sets->way_count_leaving_road, 1, 1000, gui_numberinput_t::AUTOLINEAR, false );

	INIT_END
}

void settings_routing_stats_t::read(settings_t* const sets)
{
	READ_INIT
	const sint32 old_route_steps = sets->max_route_steps;
	// routing of goods
	READ_BOOL_VALUE( sets->separate_halt_capacities );
	READ_BOOL_VALUE( sets->avoid_overcrowding );
	READ_NUM_VALUE( sets->max_route_steps );
	READ_NUM_VALUE( sets->max_choose_route_steps );
	READ_NUM_VALUE( sets->max_hops );
	READ_NUM_VALUE( sets->max_transfers );

	// routing on ways
	READ_NUM_VALUE( sets->way_count_straight );
	READ_NUM_VALUE( sets->way_count_curve );
	READ_NUM_VALUE( sets->way_count_double_curve );
	READ_NUM_VALUE( sets->way_count_90_curve );
	READ_NUM_VALUE( sets->way_count_slope );
	READ_NUM_VALUE( sets->way_count_tunnel );
	READ_NUM_VALUE( sets->way_max_bridge_len );
	READ_NUM_VALUE( sets->way_count_leaving_road );

	if(old_route_steps != sets->max_route_steps)
	{
		route_t::TERM_NODES();
		route_t::INIT_NODES(sets->max_route_steps, koord::invalid);
	}
}


void settings_economy_stats_t::init(settings_t const* const sets)
{
	INIT_INIT
	INIT_NUM( ""remove_dummy_player_months"", sets->get_remove_dummy_player_months(), 0, MAX_PLAYER_HISTORY_YEARS*12, 12, false );
	INIT_NUM( ""unprotect_abandoned_player_months"", sets->get_unprotect_abandoned_player_months(), 0, MAX_PLAYER_HISTORY_YEARS*12, 12, false );
	SEPERATOR
	INIT_COST( ""starting_money"", sets->get_starting_money(sets->get_starting_year()), 1, 0x7FFFFFFFul, 10000, false );
	INIT_BOOL_NEW( ""first_beginner"", sets->get_beginner_mode() );
	INIT_NUM( ""beginner_price_factor"", sets->get_beginner_price_factor(), 1, 25000, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""allow_buying_obsolete_vehicles"", sets->get_allow_buying_obsolete_vehicles(), 0, 2, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""used_vehicle_reduction"", sets->get_used_vehicle_reduction(), 0, 1000, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""toll_runningcost_percentage"", sets->get_way_toll_runningcost_percentage(), 0, 100, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""toll_waycost_percentage"", sets->get_way_toll_waycost_percentage(), 0, 100, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""toll_revenue_percentage"", sets->get_way_toll_revenue_percentage(), 0, 100, gui_numberinput_t::AUTOLINEAR, false );
	INIT_BOOL(""disable_make_way_public"", sets->get_disable_make_way_public());
	SEPERATOR

	INIT_NUM( ""ai_construction_speed"", sets->get_default_ai_construction_speed(), 0, 1000000000, 1000, false );
	SEPERATOR

	INIT_NUM( ""just_in_time"", sets->get_just_in_time(), 0, 255, gui_numberinput_t::PLAIN, false );
	INIT_NUM( ""maximum_intransit_percentage"", sets->get_factory_maximum_intransit_percentage(), 0, 32767, gui_numberinput_t::AUTOLINEAR, false );
	INIT_BOOL( ""crossconnect_factories"", sets->is_crossconnect_factories() );
	INIT_NUM( ""crossconnect_factories_percentage"", sets->get_crossconnect_factor(), 0, 100, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""industry_increase_every"", sets->get_industry_increase_every(), 0, 100000, 100, false );
	INIT_NUM( ""min_factory_spacing"", sets->get_min_factory_spacing(), 1, 32767, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""max_factory_spacing_percent"", sets->get_max_factory_spacing_percent(), 0, 100, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""max_factory_spacing"", sets->get_max_factory_spacing(), 1, 65535, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""electric_promille"", sets->get_electric_promille(), 0, 2000, gui_numberinput_t::AUTOLINEAR, false );
	INIT_BOOL( ""allow_underground_transformers"", sets->get_allow_underground_transformers() );
	INIT_NUM( ""way_height_clearance"", sets->get_way_height_clearance(), 1, 2, gui_numberinput_t::AUTOLINEAR, true );
	SEPERATOR

	INIT_NUM( ""city_isolation_factor"", sets->get_city_isolation_factor(), 1, 20000, 1, false );
	INIT_NUM( ""special_building_distance"", sets->get_special_building_distance(), 1, 150, 1, false );
	INIT_NUM( ""factory_arrival_periods"", sets->get_factory_arrival_periods(), 1, 16, gui_numberinput_t::AUTOLINEAR, false );
	INIT_BOOL( ""factory_enforce_demand"", sets->get_factory_enforce_demand() );
	SEPERATOR
	INIT_NUM( ""passenger_multiplier"", sets->get_passenger_multiplier(), 0, 100, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""mail_multiplier"", sets->get_mail_multiplier(), 0, 100, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM( ""goods_multiplier"", sets->get_goods_multiplier(), 0, 100, gui_numberinput_t::AUTOLINEAR, false );
	//INIT_NUM( ""electricity_multiplier"", sets->get_electricity_multiplier(), 0, 10000, 10, false );
	SEPERATOR
	INIT_NUM( ""growthfactor_villages"", sets->get_growthfactor_small(), 1, 10000, 10, false );
	INIT_NUM( ""growthfactor_cities"", sets->get_growthfactor_medium(), 1, 10000, 10, false );
	INIT_NUM( ""growthfactor_capitals"", sets->get_growthfactor_large(), 1, 10000, 10, false );
	SEPERATOR
	INIT_BOOL( ""random_pedestrians"", sets->get_random_pedestrians() );
	INIT_BOOL( ""stop_pedestrians"", sets->get_show_pax() );
	INIT_NUM( ""citycar_level"", sets->get_traffic_level(), 0, 16, 1, false );
	INIT_NUM( ""default_citycar_life"", sets->get_stadtauto_duration(), 1, 1200, 12, false );

	INIT_END
}

void settings_economy_stats_t::read(settings_t* const sets)
{
	READ_INIT
	sint64 start_money_temp;
	READ_NUM_VALUE( sets->remove_dummy_player_months );
	READ_NUM_VALUE( sets->unprotect_abandoned_player_months );
	READ_COST_VALUE( start_money_temp );
	if(  sets->get_starting_money(sets->get_starting_year())!=start_money_temp  ) {
		// because this will render the table based values invalid, we do this only when needed
		sets->starting_money = start_money_temp;
	}
	READ_BOOL_VALUE_NEW( sets->beginner_mode );
	READ_NUM_VALUE( sets->beginner_price_factor );
	READ_NUM_VALUE( sets->allow_buying_obsolete_vehicles );
	READ_NUM_VALUE( sets->used_vehicle_reduction );
	READ_NUM_VALUE( sets->way_toll_runningcost_percentage );
	READ_NUM_VALUE( sets->way_toll_waycost_percentage );
	READ_NUM_VALUE( sets->way_toll_revenue_percentage );
	READ_BOOL_VALUE(sets->disable_make_way_public);

	READ_NUM_VALUE( sets->default_ai_construction_speed );
	env_t::default_ai_construction_speed = sets->get_default_ai_construction_speed();

	READ_NUM_VALUE( sets->just_in_time );
	READ_NUM_VALUE( sets->factory_maximum_intransit_percentage );
	READ_BOOL_VALUE( sets->crossconnect_factories );
	READ_NUM_VALUE( sets->crossconnect_factor );
	READ_NUM_VALUE( sets->industry_increase );
	READ_NUM_VALUE( sets->min_factory_spacing );
	READ_NUM_VALUE( sets->max_factory_spacing_percentage );
	READ_NUM_VALUE( sets->max_factory_spacing );
	READ_NUM_VALUE( sets->electric_promille );
	READ_BOOL_VALUE( sets->allow_underground_transformers );
	READ_NUM_VALUE( sets->way_height_clearance );

	READ_NUM_VALUE( sets->city_isolation_factor );
	READ_NUM_VALUE( sets->special_building_distance );
	READ_NUM_VALUE( sets->factory_arrival_periods );
	READ_BOOL_VALUE( sets->factory_enforce_demand );
	READ_NUM_VALUE( sets->passenger_multiplier );
	READ_NUM_VALUE( sets->mail_multiplier );
	READ_NUM_VALUE( sets->goods_multiplier );
	//READ_NUM_VALUE( sets->electricity_multiplier );
	READ_NUM_VALUE( sets->growthfactor_small );
	READ_NUM_VALUE( sets->growthfactor_medium );
	READ_NUM_VALUE( sets->growthfactor_large );
	READ_BOOL( sets->set_random_pedestrians );
	READ_BOOL( sets->set_show_pax );
	READ_NUM( sets->set_traffic_level );
	READ_NUM_VALUE( sets->stadtauto_duration );
}


void settings_costs_stats_t::init(settings_t const* const sets)
{
	INIT_INIT
	INIT_NUM( ""maintenance_building"", sets->maint_building, 1, 100000000, 100, false );
	INIT_COST( ""cost_multiply_dock"", -sets->cst_multiply_dock, 1, 100000000, 10, false );
	INIT_COST( ""cost_multiply_station"", -sets->cst_multiply_station, 1, 100000000, 10, false );
	INIT_COST( ""cost_multiply_roadstop"", -sets->cst_multiply_roadstop, 1, 100000000, 10, false );
	INIT_COST( ""cost_multiply_airterminal"", -sets->cst_multiply_airterminal, 1, 100000000, 10, false );
	INIT_COST( ""cost_multiply_post"", -sets->cst_multiply_post, 1, 100000000, 10, false );
	INIT_COST( ""cost_multiply_headquarter"", -sets->cst_multiply_headquarter, 1, 100000000, 10, false );
	INIT_COST( ""cost_depot_air"", -sets->cst_depot_air, 1, 100000000, 10, false );
	INIT_COST( ""cost_depot_rail"", -sets->cst_depot_rail, 1, 100000000, 10, false );
	INIT_COST( ""cost_depot_road"", -sets->cst_depot_road, 1, 100000000, 10, false );
	INIT_COST( ""cost_depot_ship"", -sets->cst_depot_ship, 1, 100000000, 10, false );
	INIT_COST( ""cost_buy_land"", -sets->cst_buy_land, 0, 100000000, 10, false );
	INIT_COST( ""cost_alter_land"", -sets->cst_alter_land, 1, 100000000, 10, false );
	INIT_COST( ""cost_set_slope"", -sets->cst_set_slope, 1, 100000000, 10, false );
	INIT_COST( ""cost_alter_climate"", -sets->cst_alter_climate, 1, 100000000, 10, false );
	INIT_COST( ""cost_found_city"", -sets->cst_found_city, 1, 100000000, 10, false );
	INIT_COST( ""cost_multiply_found_industry"", -sets->cst_multiply_found_industry, 1, 100000000, 10, false );
	INIT_COST( ""cost_remove_tree"", -sets->cst_remove_tree, 1, 100000000, 10, false );
	INIT_COST( ""cost_multiply_remove_haus"", -sets->cst_multiply_remove_haus, 1, 100000000, 10, false );
	INIT_COST( ""cost_multiply_remove_field"", -sets->cst_multiply_remove_field, 1, 100000000, 10, false );
	INIT_COST( ""cost_transformer"", -sets->cst_transformer, 1, 100000000, 10, false );
	INIT_COST( ""cost_maintain_transformer"", -sets->cst_maintain_transformer, 1, 100000000, 10, false );
	INIT_NUM(""cost_make_public_months"", sets->cst_make_public_months, 0, 36000, gui_numberinput_t::AUTOLINEAR, false);
	INIT_END
}


void settings_costs_stats_t::read(settings_t* const sets)
{
	READ_INIT
	(void)booliter;
	READ_NUM_VALUE( sets->maint_building );
	READ_COST_VALUE( sets->cst_multiply_dock )*(-1);
	READ_COST_VALUE( sets->cst_multiply_station )*(-1);
	READ_COST_VALUE( sets->cst_multiply_roadstop )*(-1);
	READ_COST_VALUE( sets->cst_multiply_airterminal )*(-1);
	READ_COST_VALUE( sets->cst_multiply_post )*(-1);
	READ_COST_VALUE( sets->cst_multiply_headquarter )*(-1);
	READ_COST_VALUE( sets->cst_depot_air )*(-1);
	READ_COST_VALUE( sets->cst_depot_rail )*(-1);
	READ_COST_VALUE( sets->cst_depot_road )*(-1);
	READ_COST_VALUE( sets->cst_depot_ship )*(-1);
	READ_COST_VALUE( sets->cst_buy_land )*(-1);
	READ_COST_VALUE( sets->cst_alter_land )*(-1);
	READ_COST_VALUE( sets->cst_set_slope )*(-1);
	READ_COST_VALUE( sets->cst_alter_climate )*(-1);
	READ_COST_VALUE( sets->cst_found_city )*(-1);
	READ_COST_VALUE( sets->cst_multiply_found_industry )*(-1);
	READ_COST_VALUE( sets->cst_remove_tree )*(-1);
	READ_COST_VALUE( sets->cst_multiply_remove_haus )*(-1);
	READ_COST_VALUE( sets->cst_multiply_remove_field )*(-1);
	READ_COST_VALUE( sets->cst_transformer )*(-1);
	READ_COST_VALUE( sets->cst_maintain_transformer )*(-1);
	READ_NUM_VALUE(sets->cst_make_public_months);
}


#include ""../descriptor/ground_desc.h""


void settings_climates_stats_t::init(settings_t* const sets)
{
	int mountain_height_start = (int)sets->get_max_mountain_height();
	int mountain_roughness_start = (int)(sets->get_map_roughness()*20.0 + 0.5)-8;

	local_sets = sets;
	INIT_INIT
	INIT_NUM_NEW( ""height_map_conversion_version"", env_t::pak_height_conversion_factor, 1, 2, 0, false );
	if ( new_world ) {
		SEPERATOR
	}
	INIT_NUM_NEW( ""Water level"", sets->get_groundwater(), -20*(ground_desc_t::double_grounds?2:1), 20, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM_NEW( ""Mountain height"", mountain_height_start, 0, min(1000,100*(11-mountain_roughness_start)), 10, false );
	INIT_NUM_NEW( ""Map roughness"", mountain_roughness_start, 0, min(10, 11-((mountain_height_start+99)/100)), gui_numberinput_t::AUTOLINEAR, false );
	SEPERATOR
	INIT_LB( ""Summer snowline"" );
	new_component<gui_empty_t>();

	INIT_NUM( ""Winter snowline"", sets->get_winter_snowline(), sets->get_groundwater(), 127, gui_numberinput_t::AUTOLINEAR, false );
	SEPERATOR
	// other climate borders ...
	sint16 arctic = 0;
	for(  int i=desert_climate;  i!=arctic_climate;  i++  ) {
		INIT_NUM( ground_desc_t::get_climate_name_from_bit((climate)i), sets->get_climate_borders()[i], sets->get_groundwater(), 127, gui_numberinput_t::AUTOLINEAR, false );
		if(sets->get_climate_borders()[i]>arctic) {
			arctic = sets->get_climate_borders()[i];
		}
	}
	numinp.at(3)->set_limits( 0, arctic );
	buf.clear();
	buf.printf( ""%s %i"", translator::translate( ""Summer snowline"" ), arctic );
	SEPERATOR
	INIT_BOOL( ""lake"", sets->get_lake() );
	INIT_NUM_NEW( ""Number of rivers"", sets->get_river_number(), 0, 4096, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM_NEW( ""minimum length of rivers"", sets->get_min_river_length(), 0, max(16,sets->get_max_river_length())-16, gui_numberinput_t::AUTOLINEAR, false );
	INIT_NUM_NEW( ""maximum length of rivers"", sets->get_max_river_length(), sets->get_min_river_length()+16, 8196, gui_numberinput_t::AUTOLINEAR, false );
	// add listener to all of them
	FOR(slist_tpl<gui_numberinput_t*>, const n, numinp) {
		n->add_listener(this);
	}
	// the following are independent and thus need no listener
	SEPERATOR
	INIT_BOOL( ""no tree"", sets->get_no_trees() );
	INIT_NUM_NEW( ""forest_base_size"", sets->get_forest_base_size(), 10, 255, 1, false );
	INIT_NUM_NEW( ""forest_map_size_divisor"", sets->get_forest_map_size_divisor(), 2, 255, 1, false );
	INIT_NUM_NEW( ""forest_count_divisor"", sets->get_forest_count_divisor(), 2, 255, 1, false );
	INIT_NUM_NEW( ""forest_inverse_spare_tree_density"", sets->get_forest_inverse_spare_tree_density(), 33, 10000, 10, false );
	INIT_NUM( ""max_no_of_trees_on_square"", sets->get_max_no_of_trees_on_square(), 1, 5, 1, true );
	INIT_NUM_NEW( ""tree_climates"", sets->get_tree_climates(), 0, 255, 1, false );
	INIT_NUM_NEW( ""no_tree_climates"", sets->get_no_tree_climates(), 0, 255, 1, false );

	INIT_END
}


void settings_climates_stats_t::read(settings_t* const sets)
{
	READ_INIT
	READ_NUM_VALUE_NEW( env_t::pak_height_conversion_factor );
	READ_NUM_VALUE_NEW( sets->groundwater );
	READ_NUM_VALUE_NEW( sets->max_mountain_height );
	double n;
	READ_NUM_VALUE_NEW( n );
	if(  new_world  ) {
		sets->map_roughness = (n+8.0)/20.0;
	}
	READ_NUM_VALUE( sets->winter_snowline );
	// other climate borders ...
	sint16 arctic = 0;
	for(  int i=desert_climate;  i!=arctic_climate;  i++  ) {
		sint16 ch;
		READ_NUM_VALUE( ch );
		sets->climate_borders[i] = ch;
		if(  ch>arctic  ) {
			arctic = ch;
		}
	}
	numinp.at(3)->set_limits( 0, arctic );
	buf.clear();
	buf.printf( ""%s %i"", translator::translate( ""Summer snowline"" ), arctic );
	READ_BOOL_VALUE( sets->lake );
	READ_NUM_VALUE_NEW( sets->river_number );
	READ_NUM_VALUE_NEW( sets->min_river_length );
	READ_NUM_VALUE_NEW( sets->max_river_length );
	READ_BOOL_VALUE( sets->no_trees );
	READ_NUM_VALUE_NEW( sets->forest_base_size );
	READ_NUM_VALUE_NEW( sets->forest_map_size_divisor );
	READ_NUM_VALUE_NEW( sets->forest_count_divisor );
	READ_NUM_VALUE_NEW( sets->forest_inverse_spare_tree_density );
	READ_NUM_VALUE( sets->max_no_of_trees_on_square );
	READ_NUM_VALUE_NEW( sets->tree_climates );
	READ_NUM_VALUE_NEW( sets->no_tree_climates );
}


bool settings_climates_stats_t::action_triggered(gui_action_creator_t *comp, value_t)
{
	welt_gui_t *welt_gui = dynamic_cast<welt_gui_t *>(win_get_magic( magic_welt_gui_t ));
	read( local_sets );
	uint i = 0;
	FORX(slist_tpl<gui_numberinput_t*>, const n, numinp, ++i) {
		if (n == comp && i < 3 && welt_gui) {
			// update world preview
			welt_gui->update_preview();
		}
	}
	return true;
}
",16193,True,2896.7070393801187,median
"CLASS ltcl_test DEFINITION DEFERRED.
CLASS ltcl_split_text DEFINITION DEFERRED.
CLASS zcx_abapgit_exception DEFINITION LOCAL FRIENDS ltcl_test ltcl_split_text.

CLASS ltcl_test DEFINITION
  FOR TESTING
  DURATION SHORT
  RISK LEVEL HARMLESS.

  PUBLIC SECTION.
    METHODS:
      test_direct_text FOR TESTING,
      test_t100_text1 FOR TESTING,
      test_t100_text2 FOR TESTING,
      test_t100_text3 FOR TESTING,
      test_t100_text4 FOR TESTING,
      test_t100_text5 FOR TESTING,
      test_t100_text6 FOR TESTING,
      test_t100_text7 FOR TESTING,
      test_t100_text8 FOR TESTING,
      test_no_text FOR TESTING.
  PROTECTED SECTION.
  PRIVATE SECTION.
    TYPES:
      BEGIN OF ty_t100_message,
        msgid TYPE symsgid,
        msgno TYPE symsgno,
        msgv1 TYPE symsgv,
        msgv2 TYPE symsgv,
        msgv3 TYPE symsgv,
        msgv4 TYPE symsgv,
      END OF ty_t100_message.
    CLASS-METHODS:
      get_exc_text IMPORTING ix_ex          TYPE REF TO cx_root
                   RETURNING VALUE(rv_text) TYPE string,
      get_t100_text IMPORTING is_message     TYPE ty_t100_message
                    RETURNING VALUE(rv_text) TYPE string.
ENDCLASS.

CLASS ltcl_test IMPLEMENTATION.
  METHOD test_direct_text.
    CONSTANTS: lc_text1 TYPE string VALUE `This is a test error message.`,
               lc_text2 TYPE string VALUE ``.
    DATA: lx_ex       TYPE REF TO zcx_abapgit_exception,
          lx_previous TYPE REF TO cx_root.

    TRY.
        CREATE OBJECT lx_previous TYPE cx_sy_dyn_call_illegal_method
          EXPORTING
            textid     = cx_sy_dyn_call_illegal_method=>private_method
            classname  = 'CLASS'
            methodname = 'METHOD'.

        zcx_abapgit_exception=>raise( iv_text     = lx_previous->get_text( )
                                      ix_previous = lx_previous ).
        cl_abap_unit_assert=>fail( ).

      CATCH zcx_abapgit_exception INTO lx_ex.
        cl_abap_unit_assert=>assert_equals( act = get_exc_text( lx_ex )
                                            exp = lx_previous->get_text( ) ).
        cl_abap_unit_assert=>assert_equals( act = lx_ex->previous
                                            exp = lx_previous ).
    ENDTRY.

    FREE: lx_ex, lx_previous.

    TRY.
        zcx_abapgit_exception=>raise( lc_text1 ).
        cl_abap_unit_assert=>fail( ).
      CATCH zcx_abapgit_exception INTO lx_ex.
        cl_abap_unit_assert=>assert_equals( act = get_exc_text( lx_ex )
                                            exp = lc_text1 ).
    ENDTRY.

    FREE lx_ex.

    TRY.
        zcx_abapgit_exception=>raise( lc_text2 ).
        cl_abap_unit_assert=>fail( ).
      CATCH zcx_abapgit_exception INTO lx_ex.
        cl_abap_unit_assert=>assert_equals(
          act = get_exc_text( lx_ex )
          exp = zcx_abapgit_exception=>gc_generic_error_msg ).
    ENDTRY.

    FREE lx_ex.
  ENDMETHOD.

  METHOD test_no_text.
    DATA: lx_ex TYPE REF TO zcx_abapgit_exception.

    TRY.
        zcx_abapgit_exception=>raise( space ).
        cl_abap_unit_assert=>fail( ).
      CATCH zcx_abapgit_exception INTO lx_ex.
        cl_abap_unit_assert=>assert_equals(
          act = get_exc_text( lx_ex )
          exp = zcx_abapgit_exception=>gc_generic_error_msg ).
    ENDTRY.
  ENDMETHOD.

  METHOD test_t100_text1.
    CONSTANTS: BEGIN OF lc_msg1,
                 msgid TYPE symsgid VALUE '00',
                 msgno TYPE symsgno VALUE '001',
                 msgv1 TYPE symsgv VALUE IS INITIAL,
                 msgv2 TYPE symsgv VALUE IS INITIAL,
                 msgv3 TYPE symsgv VALUE IS INITIAL,
                 msgv4 TYPE symsgv VALUE IS INITIAL,
               END OF lc_msg1.

    DATA: lx_ex   TYPE REF TO zcx_abapgit_exception,
          lv_text TYPE string.

    TRY.
        lv_text = get_t100_text( lc_msg1 ).
        zcx_abapgit_exception=>raise_t100( ).
        cl_abap_unit_assert=>fail( ).
      CATCH zcx_abapgit_exception INTO lx_ex.
        cl_abap_unit_assert=>assert_equals( act = get_exc_text( lx_ex )
                                            exp = lv_text ).
    ENDTRY.
  ENDMETHOD.


  METHOD test_t100_text2.
    CONSTANTS: BEGIN OF lc_msg2,
                 msgid TYPE symsgid VALUE '00',
                 msgno TYPE symsgno VALUE '001',
                 msgv1 TYPE symsgv VALUE 'Variable 1',
                 msgv2 TYPE symsgv VALUE IS INITIAL,
                 msgv3 TYPE symsgv VALUE IS INITIAL,
                 msgv4 TYPE symsgv VALUE IS INITIAL,
               END OF lc_msg2.

    DATA: lx_ex   TYPE REF TO zcx_abapgit_exception,
          lv_text TYPE string.

    TRY.
        lv_text = get_t100_text( lc_msg2 ).
        zcx_abapgit_exception=>raise_t100( ).
        cl_abap_unit_assert=>fail( ).
      CATCH zcx_abapgit_exception INTO lx_ex.
        cl_abap_unit_assert=>assert_equals( act = get_exc_text( lx_ex )
                                            exp = lv_text ).
    ENDTRY.

  ENDMETHOD.

  METHOD test_t100_text3.
    CONSTANTS: BEGIN OF lc_msg3,
                 msgid TYPE symsgid VALUE '00',
                 msgno TYPE symsgno VALUE '001',
                 msgv1 TYPE symsgv VALUE 'Variable 1',
                 msgv2 TYPE symsgv VALUE 'Variable 2',
                 msgv3 TYPE symsgv VALUE IS INITIAL,
                 msgv4 TYPE symsgv VALUE IS INITIAL,
               END OF lc_msg3.

    DATA: lx_ex   TYPE REF TO zcx_abapgit_exception,
          lv_text TYPE string.

    TRY.
        lv_text = get_t100_text( lc_msg3 ).
        zcx_abapgit_exception=>raise_t100( ).
        cl_abap_unit_assert=>fail( ).
      CATCH zcx_abapgit_exception INTO lx_ex.
        cl_abap_unit_assert=>assert_equals( act = get_exc_text( lx_ex )
                                            exp = lv_text ).
    ENDTRY.

  ENDMETHOD.

  METHOD test_t100_text4.
    CONSTANTS: BEGIN OF lc_msg4,
                 msgid TYPE symsgid VALUE '00',
                 msgno TYPE symsgno VALUE '001',
                 msgv1 TYPE symsgv VALUE 'Variable 1',
                 msgv2 TYPE symsgv VALUE 'Variable 2',
                 msgv3 TYPE symsgv VALUE 'Variable 3',
                 msgv4 TYPE symsgv VALUE IS INITIAL,
               END OF lc_msg4.

    DATA: lx_ex   TYPE REF TO zcx_abapgit_exception,
          lv_text TYPE string.

    TRY.
        lv_text = get_t100_text( lc_msg4 ).
        zcx_abapgit_exception=>raise_t100( ).
        cl_abap_unit_assert=>fail( ).
      CATCH zcx_abapgit_exception INTO lx_ex.
        cl_abap_unit_assert=>assert_equals( act = get_exc_text( lx_ex )
                                            exp = lv_text ).
    ENDTRY.

  ENDMETHOD.

  METHOD test_t100_text5.
    CONSTANTS: BEGIN OF lc_msg5,
                 msgid TYPE symsgid VALUE '00',
                 msgno TYPE symsgno VALUE '001',
                 msgv1 TYPE symsgv VALUE 'Variable 1',
                 msgv2 TYPE symsgv VALUE 'Variable 2',
                 msgv3 TYPE symsgv VALUE 'Variable 3',
                 msgv4 TYPE symsgv VALUE 'Variable 4',
               END OF lc_msg5.

    DATA: lx_ex   TYPE REF TO zcx_abapgit_exception,
          lv_text TYPE string.

    TRY.
        lv_text = get_t100_text( lc_msg5 ).
        zcx_abapgit_exception=>raise_t100( ).
        cl_abap_unit_assert=>fail( ).
      CATCH zcx_abapgit_exception INTO lx_ex.
        cl_abap_unit_assert=>assert_equals( act = get_exc_text( lx_ex )
                                            exp = lv_text ).
    ENDTRY.

  ENDMETHOD.

  METHOD test_t100_text6.
    CONSTANTS: BEGIN OF lc_msg6,
                 msgid TYPE symsgid VALUE '00',
                 msgno TYPE symsgno VALUE '003',
                 msgv1 TYPE symsgv VALUE 'Variable 1',
                 msgv2 TYPE symsgv VALUE 'Variable 2',
                 msgv3 TYPE symsgv VALUE 'Variable 3',
                 msgv4 TYPE symsgv VALUE 'Variable 4',
               END OF lc_msg6.

    DATA: lx_ex   TYPE REF TO zcx_abapgit_exception,
          lv_text TYPE string.

    TRY.
        lv_text = get_t100_text( lc_msg6 ).
        zcx_abapgit_exception=>raise_t100( ).
        cl_abap_unit_assert=>fail( ).
      CATCH zcx_abapgit_exception INTO lx_ex.
        cl_abap_unit_assert=>assert_equals( act = get_exc_text( lx_ex )
                                            exp = lv_text ).
    ENDTRY.

  ENDMETHOD.

  METHOD test_t100_text7.
    CONSTANTS: BEGIN OF lc_msg7,
                 msgid TYPE symsgid VALUE '00',
                 msgno TYPE symsgno VALUE '003',
                 msgv1 TYPE symsgv VALUE IS INITIAL,
                 msgv2 TYPE symsgv VALUE IS INITIAL,
                 msgv3 TYPE symsgv VALUE IS INITIAL,
                 msgv4 TYPE symsgv VALUE IS INITIAL,
               END OF lc_msg7.

    DATA: lx_ex   TYPE REF TO zcx_abapgit_exception,
          lv_text TYPE string.

    TRY.
        lv_text = get_t100_text( lc_msg7 ).
        zcx_abapgit_exception=>raise_t100( ).
        cl_abap_unit_assert=>fail( ).
      CATCH zcx_abapgit_exception INTO lx_ex.
        cl_abap_unit_assert=>assert_equals( act = get_exc_text( lx_ex )
                                            exp = lv_text ).
    ENDTRY.

  ENDMETHOD.

  METHOD test_t100_text8.
    CONSTANTS: BEGIN OF lc_msg8,
                 msgid TYPE symsgid VALUE '00',
                 msgno TYPE symsgno VALUE '002',
                 msgv1 TYPE symsgv VALUE IS INITIAL,
                 msgv2 TYPE symsgv VALUE IS INITIAL,
                 msgv3 TYPE symsgv VALUE IS INITIAL,
                 msgv4 TYPE symsgv VALUE IS INITIAL,
               END OF lc_msg8.

    DATA: lx_ex   TYPE REF TO zcx_abapgit_exception,
          lv_text TYPE string.

    TRY.
        lv_text = get_t100_text( lc_msg8 ).
        zcx_abapgit_exception=>raise_t100( ).
        cl_abap_unit_assert=>fail( ).
      CATCH zcx_abapgit_exception INTO lx_ex.
        cl_abap_unit_assert=>assert_equals( act = get_exc_text( lx_ex )
                                            exp = lv_text ).
    ENDTRY.

  ENDMETHOD.

  METHOD get_exc_text.
    rv_text = ix_ex->get_text( ).
  ENDMETHOD.

  METHOD get_t100_text.
    MESSAGE ID is_message-msgid TYPE 'S' NUMBER is_message-msgno
            WITH is_message-msgv1 is_message-msgv2 is_message-msgv3 is_message-msgv4
            INTO rv_text.
  ENDMETHOD.
ENDCLASS.

CLASS ltcl_get_t100_longtext DEFINITION FOR TESTING DURATION SHORT RISK LEVEL HARMLESS.

  PUBLIC SECTION.
    METHODS test01 FOR TESTING.

ENDCLASS.

CLASS ltcl_get_t100_longtext IMPLEMENTATION.

  METHOD test01.

    DATA: lx_err    TYPE REF TO zcx_abapgit_exception,
          lv_dummy  TYPE string,
          lv_result TYPE string.

    TRY.
        MESSAGE e058(00) WITH 'Value_1' 'Value_2' 'Value_3' 'Value_4' INTO lv_dummy.
        zcx_abapgit_exception=>raise_t100( ).
      CATCH zcx_abapgit_exception INTO lx_err.
        lv_result = lx_err->get_longtext( ).
    ENDTRY.

    cl_abap_unit_assert=>assert_not_initial( lv_result ).

    IF lv_result NS 'Value_1'.
      cl_abap_unit_assert=>fail( ).
    ENDIF.
    IF lv_result NS 'Value_2'.
      cl_abap_unit_assert=>fail( ).
    ENDIF.
    IF lv_result NS 'Value_3'.
      cl_abap_unit_assert=>fail( ).
    ENDIF.
    IF lv_result NS 'Value_4'.
      cl_abap_unit_assert=>fail( ).
    ENDIF.

  ENDMETHOD.

ENDCLASS.

CLASS ltcl_split_text DEFINITION
  FOR TESTING
  DURATION SHORT
  RISK LEVEL HARMLESS.

  PUBLIC SECTION.
    METHODS:
      test_set_msg_b FOR TESTING,
      test_set_msg_c FOR TESTING,
      test_set_msg_d FOR TESTING,
      test_set_msg_e FOR TESTING,
      test_set_msg_z FOR TESTING.
  PROTECTED SECTION.
  PRIVATE SECTION.
    TYPES:
      BEGIN OF ty_msg,
        v1 TYPE sy-msgv1,
        v2 TYPE sy-msgv2,
        v3 TYPE sy-msgv3,
        v4 TYPE sy-msgv4,
      END OF ty_msg.
    CLASS-METHODS:
      test_set_msg_vars
        IMPORTING
          iv_text TYPE string
          is_msg  TYPE ty_msg.
ENDCLASS.

CLASS ltcl_split_text IMPLEMENTATION.
  METHOD test_set_msg_b.
    CONSTANTS:
      lc_text_b TYPE string VALUE '0123456789012345678901234567890123456789012345678 0123456789',
      BEGIN OF lc_msg_b,
        v1 TYPE sy-msgv1 VALUE '0123456789012345678901234567890123456789012345678',
        v2 TYPE sy-msgv2 VALUE ' 0123456789',
        v3 TYPE sy-msgv3 VALUE '',
        v4 TYPE sy-msgv4 VALUE '',
      END OF lc_msg_b.
    test_set_msg_vars( iv_text = lc_text_b
                       is_msg  = lc_msg_b ).
  ENDMETHOD.
  METHOD test_set_msg_c.
    CONSTANTS:
      lc_text_c TYPE string VALUE '01234567890123456789012345678901234567890123456789 123456789',
      BEGIN OF lc_msg_c,
        v1 TYPE sy-msgv1 VALUE '01234567890123456789012345678901234567890123456789',
        v2 TYPE sy-msgv2 VALUE ' 123456789',
        v3 TYPE sy-msgv3 VALUE '',
        v4 TYPE sy-msgv4 VALUE '',
      END OF lc_msg_c.
    test_set_msg_vars( iv_text = lc_text_c
                       is_msg  = lc_msg_c ).
  ENDMETHOD.
  METHOD test_set_msg_d.
    CONSTANTS:
      lc_text_d TYPE string VALUE '012345678901234567890123456789012345678901234567890 23456789',
      BEGIN OF lc_msg_d,
        v1 TYPE sy-msgv1 VALUE '01234567890123456789012345678901234567890123456789',
        v2 TYPE sy-msgv2 VALUE '0 23456789',
        v3 TYPE sy-msgv3 VALUE '',
        v4 TYPE sy-msgv4 VALUE '',
      END OF lc_msg_d.
    test_set_msg_vars( iv_text = lc_text_d
                       is_msg  = lc_msg_d ).
  ENDMETHOD.
  METHOD test_set_msg_e.
    CONSTANTS:
      lc_text_e TYPE string VALUE '012345678901234567890123456789012345678901234567890123456789',
      BEGIN OF lc_msg_e,
        v1 TYPE sy-msgv1 VALUE '01234567890123456789012345678901234567890123456789',
        v2 TYPE sy-msgv2 VALUE '0123456789',
        v3 TYPE sy-msgv3 VALUE '',
        v4 TYPE sy-msgv4 VALUE '',
      END OF lc_msg_e.
    test_set_msg_vars( iv_text = lc_text_e
                       is_msg  = lc_msg_e ).
  ENDMETHOD.
  METHOD test_set_msg_z.
    CONSTANTS:
      lc_text_x TYPE string VALUE `Here is a very long text more than 200 characters and we have to invent `,
      lc_text_y TYPE string VALUE `a nice story about abapGit to fill this long message. abapGit is simply `,
      lc_text_z TYPE string VALUE `the greatest! #abapGit #awesome #community #opensource`,
      BEGIN OF lc_msg_z,
        v1 TYPE sy-msgv1 VALUE `Here is a very long text more than 200 characters`,
        v2 TYPE sy-msgv2 VALUE ` and we have to invent a nice story about abapGit`,
        v3 TYPE sy-msgv3 VALUE ` to fill this long message. abapGit is simply the`,
        v4 TYPE sy-msgv4 VALUE ` greatest! #abapGit #awesome #community`,
      END OF lc_msg_z.
    test_set_msg_vars( iv_text = lc_text_x && lc_text_y && lc_text_z
                       is_msg  = lc_msg_z ).
  ENDMETHOD.
  METHOD test_set_msg_vars.

    zcx_abapgit_exception=>split_text_to_symsg( iv_text ).

    cl_abap_unit_assert=>assert_equals( act = sy-msgv1
                                        exp = is_msg-v1 ).
    cl_abap_unit_assert=>assert_equals( act = sy-msgv2
                                        exp = is_msg-v2 ).
    cl_abap_unit_assert=>assert_equals( act = sy-msgv3
                                        exp = is_msg-v3 ).
    cl_abap_unit_assert=>assert_equals( act = sy-msgv4
                                        exp = is_msg-v4 ).

  ENDMETHOD.
ENDCLASS.
",4299,False,953.6102599246875,median
"CLASS ycl_a2g_json_sheets DEFINITION
  PUBLIC
 INHERITING FROM ycl_a2g_jsonbase
  CREATE PUBLIC .

  PUBLIC SECTION.
    TYPES: BEGIN OF ty_s_json_sheets,
             properties         TYPE ycl_a2g_json_sheet_prop=>ty_s_json_sheet_prop,
             data               TYPE ycl_a2g_json_griddata=>ty_t_json_griddata,
             merges             TYPE ycl_a2g_json_gridrange=>ty_t_json_gridrange,
             conditionalformats TYPE ycl_a2g_json_cond_rule=>ty_t_json_cond_rule,
             filterviews        TYPE ycl_a2g_json_filterview=>ty_t_json_filterview,
             protectedranges    TYPE ycl_a2g_json_prot_range=>ty_t_json_prot_range,
             basicfilter        TYPE ycl_a2g_json_basicfilter=>ty_s_json_basicfilter,
             charts             TYPE ycl_a2g_json_embeddedchart=>ty_t_json_embeddedchart,
             bandedranges       TYPE ycl_a2g_json_bandedrange=>ty_t_json_bandedrange,
             developermetadata  TYPE ycl_a2g_json_developermetadata=>ty_t_json_devrmeta,
             rowgroups          TYPE ycl_a2g_json_dimensiongroup=>ty_t_json_dimensiongroup,
             columngroups       TYPE ycl_a2g_json_dimensiongroup=>ty_t_json_dimensiongroup,
           END OF ty_s_json_sheets.
    TYPES ty_t_json_sheets TYPE STANDARD TABLE OF ty_s_json_sheets WITH NON-UNIQUE DEFAULT KEY.

    CONSTANTS gc_fnam_properties         TYPE string VALUE 'PROPERTIES'.
    CONSTANTS gc_fnam_data               TYPE string VALUE 'DATA'.
    CONSTANTS gc_fnam_merges             TYPE string VALUE 'MERGES'.
    CONSTANTS gc_fnam_conditionalformats TYPE string VALUE 'CONDITIONALFORMATS'.
    CONSTANTS gc_fnam_filterviews        TYPE string VALUE 'FILTERVIEWS'.
    CONSTANTS gc_fnam_protectedranges    TYPE string VALUE 'PROTECTEDRANGES'.
    CONSTANTS gc_fnam_basicfilter        TYPE string VALUE 'BASICFILTER'.
    CONSTANTS gc_fnam_charts             TYPE string VALUE 'CHARTS'.
    CONSTANTS gc_fnam_bandedranges       TYPE string VALUE 'BANDEDRANGES'.
    CONSTANTS gc_fnam_developermetadata  TYPE string VALUE 'DEVELOPERMETADATA'.
    CONSTANTS gc_fnam_rowgroups          TYPE string VALUE 'ROWGROUPS'.
    CONSTANTS gc_fnam_columngroups       TYPE string VALUE 'COLUMNGROUPS'.

    ""! Build the class
    ""! @parameter if_msg_manager | message managere where soter alla message triggered by the applicaition
    METHODS constructor
      IMPORTING if_msg_manager TYPE REF TO yif_a2g_msg_manager.


    METHODS: yif_a2g_json~new_element        REDEFINITION.
    METHODS: yif_a2g_json~get_element        REDEFINITION.

  PROTECTED SECTION.
    METHODS generate_rules REDEFINITION.
    METHODS rebuild_data   REDEFINITION.
    METHODS push_data      REDEFINITION.

    DATA: gs_sheets  TYPE ty_s_json_sheets.

    METHODS new_properties         RETURNING VALUE(return) TYPE REF TO yif_a2g_json.
    METHODS new_data               RETURNING VALUE(return) TYPE REF TO yif_a2g_json.
    METHODS new_merges             RETURNING VALUE(return) TYPE REF TO yif_a2g_json.
    METHODS new_conditionalformats RETURNING VALUE(return) TYPE REF TO yif_a2g_json.
    METHODS new_filterviews        RETURNING VALUE(return) TYPE REF TO yif_a2g_json.
    METHODS new_protectedranges    RETURNING VALUE(return) TYPE REF TO yif_a2g_json.
    METHODS new_basicfilter        RETURNING VALUE(return) TYPE REF TO yif_a2g_json.
    METHODS new_charts             RETURNING VALUE(return) TYPE REF TO yif_a2g_json.
    METHODS new_bandedranges       RETURNING VALUE(return) TYPE REF TO yif_a2g_json.
    METHODS new_developermetadata  RETURNING VALUE(return) TYPE REF TO yif_a2g_json.
    METHODS new_rowgroups          RETURNING VALUE(return) TYPE REF TO yif_a2g_json.
    METHODS new_columngroups       RETURNING VALUE(return) TYPE REF TO yif_a2g_json.

  PRIVATE SECTION.
ENDCLASS.



CLASS ycl_a2g_json_sheets IMPLEMENTATION.


  METHOD yif_a2g_json~new_element.
    CASE i_name .
      WHEN gc_fnam_properties        . return = me->new_properties( ).
      WHEN gc_fnam_data              . return = me->new_data( ).
      WHEN gc_fnam_merges            . return = me->new_merges( ).
      WHEN gc_fnam_conditionalformats. return = me->new_conditionalformats( ).
      WHEN gc_fnam_filterviews       . return = me->new_filterviews( ).
      WHEN gc_fnam_protectedranges   . return = me->new_protectedranges( ).
      WHEN gc_fnam_basicfilter       . return = me->new_basicfilter( ).
      WHEN gc_fnam_charts            . return = me->new_charts( ).
      WHEN gc_fnam_bandedranges      . return = me->new_bandedranges( ).
      WHEN gc_fnam_developermetadata . return = me->new_developermetadata( ).
      WHEN gc_fnam_rowgroups         . return = me->new_rowgroups( ).
      WHEN gc_fnam_columngroups      . return = me->new_columngroups( ).
    ENDCASE.

  ENDMETHOD.

  METHOD yif_a2g_json~get_element.
    CASE i_name .
      WHEN gc_fnam_properties         . return ?= me->go_json_array->getinstance( me->gc_fnam_properties         ).
      WHEN gc_fnam_data               . return ?= me->go_json_array->getinstance( me->gc_fnam_data               ).
      WHEN gc_fnam_merges             . return ?= me->go_json_array->getinstance( me->gc_fnam_merges             ).
      WHEN gc_fnam_conditionalformats . return ?= me->go_json_array->getinstance( me->gc_fnam_conditionalformats ).
      WHEN gc_fnam_filterviews        . return ?= me->go_json_array->getinstance( me->gc_fnam_filterviews        ).
      WHEN gc_fnam_protectedranges    . return ?= me->go_json_array->getinstance( me->gc_fnam_protectedranges    ).
      WHEN gc_fnam_basicfilter        . return ?= me->go_json_array->getinstance( me->gc_fnam_basicfilter        ).
      WHEN gc_fnam_charts             . return ?= me->go_json_array->getinstance( me->gc_fnam_charts             ).
      WHEN gc_fnam_bandedranges       . return ?= me->go_json_array->getinstance( me->gc_fnam_bandedranges       ).
      WHEN gc_fnam_developermetadata  . return ?= me->go_json_array->getinstance( me->gc_fnam_developermetadata  ).
      WHEN gc_fnam_rowgroups          . return ?= me->go_json_array->getinstance( me->gc_fnam_rowgroups          ).
      WHEN gc_fnam_columngroups       . return ?= me->go_json_array->getinstance( me->gc_fnam_columngroups       ).
    ENDCASE.

  ENDMETHOD.


  METHOD push_data.
    DATA(lif_a2g_json) = me->new_properties( ).
    lif_a2g_json->yif_a2g_context~write_data( REF #( me->gs_sheets-properties          ) ).

    lif_a2g_json = me->new_basicfilter( ).
    lif_a2g_json->yif_a2g_context~write_data( REF #( me->gs_sheets-basicfilter         ) ).


    LOOP AT me->gs_sheets-data INTO DATA(ls_metadata).
      lif_a2g_json = me->new_data( ).
      lif_a2g_json->yif_a2g_context~write_data( REF #( ls_metadata                ) ).
    ENDLOOP.

    LOOP AT me->gs_sheets-merges INTO DATA(ls_metadata_merge).
      lif_a2g_json = me->new_merges( ).
      lif_a2g_json->yif_a2g_context~write_data( REF #( ls_metadata_merge              ) ).
    ENDLOOP.

    LOOP AT me->gs_sheets-conditionalformats INTO DATA(ls_metadata_conditionalformats).
      lif_a2g_json = me->new_conditionalformats( ).
      lif_a2g_json->yif_a2g_context~write_data( REF #( ls_metadata_conditionalformats  ) ).
    ENDLOOP.

    LOOP AT me->gs_sheets-filterviews INTO DATA(ls_metadata_filterviews).
      lif_a2g_json = me->new_filterviews( ).
      lif_a2g_json->yif_a2g_context~write_data( REF #( ls_metadata_filterviews         ) ).
    ENDLOOP.

    LOOP AT me->gs_sheets-protectedranges INTO DATA(ls_metadata_protectedranges).
      lif_a2g_json = me->new_protectedranges( ).
      lif_a2g_json->yif_a2g_context~write_data( REF #( ls_metadata_protectedranges     ) ).
    ENDLOOP.

    LOOP AT me->gs_sheets-charts INTO DATA(ls_metadata_charts).
      lif_a2g_json = me->new_charts( ).
      lif_a2g_json->yif_a2g_context~write_data( REF #( ls_metadata_charts              ) ).
    ENDLOOP.


    LOOP AT me->gs_sheets-bandedranges INTO DATA(ls_metadata_bandedranges).
      lif_a2g_json = me->new_bandedranges( ).
      lif_a2g_json->yif_a2g_context~write_data( REF #( ls_metadata_bandedranges        ) ).
    ENDLOOP.

    LOOP AT me->gs_sheets-developermetadata INTO DATA(ls_metadata_developermetadata).
      lif_a2g_json = me->new_developermetadata( ).
      lif_a2g_json->yif_a2g_context~write_data( REF #( ls_metadata_developermetadata   ) ).
    ENDLOOP.

    LOOP AT me->gs_sheets-rowgroups INTO DATA(ls_metadata_rowgroups).
      lif_a2g_json = me->new_rowgroups( ).
      lif_a2g_json->yif_a2g_context~write_data( REF #( ls_metadata_rowgroups           ) ).
    ENDLOOP.

    LOOP AT me->gs_sheets-columngroups INTO DATA(ls_metadata_columngroups).
      lif_a2g_json = me->new_columngroups( ).
      lif_a2g_json->yif_a2g_context~write_data( REF #( ls_metadata_columngroups       ) ).
    ENDLOOP.



  ENDMETHOD.

  METHOD rebuild_data.
    DATA: lif_a2g_json TYPE REF TO yif_a2g_json.
    FIELD-SYMBOLS <fs_value_range> TYPE any.
clear:  me->gs_sheets-data, me->gs_sheets-merges .
    DATA(lt_names) =  me->go_json_array->getallnamesofinstances(  ).
    LOOP AT lt_names INTO DATA(lv_name).

      lif_a2g_json ?= me->go_json_array->getinstance( lv_name ).
      DATA(dref_data) = lif_a2g_json->yif_a2g_context~read_data( ).
      ASSIGN dref_data->* TO <fs_value_range>.

      IF     lv_name CS me->gc_fnam_properties          .
        me->gs_sheets-properties  =  <fs_value_range>.              .
      ELSEIF lv_name CS me->gc_fnam_basicfilter         .
        me->gs_sheets-basicfilter =  <fs_value_range>.              .
      ELSEIF lv_name CS me->gc_fnam_data                .
        APPEND <fs_value_range> TO me->gs_sheets-data               .
      ELSEIF lv_name CS me->gc_fnam_merges              .
        APPEND <fs_value_range> TO me->gs_sheets-merges             .
      ELSEIF lv_name CS me->gc_fnam_conditionalformats  .
        APPEND <fs_value_range> TO me->gs_sheets-conditionalformats .
      ELSEIF lv_name CS me->gc_fnam_filterviews         .
        APPEND <fs_value_range> TO me->gs_sheets-filterviews        .
      ELSEIF lv_name CS me->gc_fnam_protectedranges     .
        APPEND <fs_value_range> TO me->gs_sheets-protectedranges    .
      ELSEIF lv_name CS me->gc_fnam_charts              .
        APPEND <fs_value_range> TO me->gs_sheets-charts             .
      ELSEIF lv_name CS me->gc_fnam_bandedranges        .
        APPEND <fs_value_range> TO me->gs_sheets-bandedranges       .
      ELSEIF lv_name CS me->gc_fnam_developermetadata   .
        APPEND <fs_value_range> TO me->gs_sheets-developermetadata  .
      ELSEIF lv_name CS me->gc_fnam_rowgroups           .
        APPEND <fs_value_range> TO me->gs_sheets-rowgroups          .
      ELSEIF lv_name CS me->gc_fnam_columngroups        .
        APPEND <fs_value_range> TO me->gs_sheets-columngroups       .
      ENDIF.

    ENDLOOP.
  ENDMETHOD.

  METHOD constructor.
    super->constructor( if_msg_manager ).
    me->gv_data = REF #( me->gs_sheets  ).
  ENDMETHOD.

  METHOD generate_rules.
  ENDMETHOD.


  METHOD new_properties.
    DATA: lo_object TYPE REF TO object.
    return = me->go_json_factory->build_json_instance( 'YCL_A2G_JSON_SHEET_PROP' ).

    lo_object ?= return.
    me->go_json_array->setinstance(  im_name = me->gc_fnam_properties
                                     im_object = lo_object ).
  ENDMETHOD.

  METHOD new_data.
    DATA: lo_object TYPE REF TO object.
    return = me->go_json_factory->build_json_instance( 'YCL_A2G_JSON_GRIDDATA' ).

    lo_object ?= return.
    DATA: lv_line TYPE numc4.
    DATA(lt_names) =  me->go_json_array->getpartnamesofinstances( me->gc_fnam_data ).
    lv_line = lines( lt_names ).
    me->go_json_array->setinstance(  im_name = me->gc_fnam_data && lv_line
                                     im_object = lo_object ).
  ENDMETHOD.

  METHOD new_merges.
    DATA: lo_object TYPE REF TO object.
    return = me->go_json_factory->build_json_instance( 'YCL_A2G_JSON_GRIDRANGE' ).

    lo_object ?= return.
    DATA: lv_line TYPE numc4.
    DATA(lt_names) =  me->go_json_array->getpartnamesofinstances( me->gc_fnam_merges ).
    lv_line = lines( lt_names ).
    me->go_json_array->setinstance(  im_name = me->gc_fnam_merges && lv_line
                                     im_object = lo_object ).

  ENDMETHOD.

  METHOD new_conditionalformats.
    DATA: lo_object TYPE REF TO object.
    return = me->go_json_factory->build_json_instance( 'YCL_A2G_JSON_COND_RULE' ).


    lo_object ?= return.
    DATA: lv_line TYPE numc4.
    DATA(lt_names) =  me->go_json_array->getpartnamesofinstances( me->gc_fnam_conditionalformats ).
    lv_line = lines( lt_names ).
    me->go_json_array->setinstance(  im_name = me->gc_fnam_conditionalformats && lv_line
                                     im_object = lo_object ).
  ENDMETHOD.

  METHOD new_filterviews.
    DATA: lo_object TYPE REF TO object.
    return = me->go_json_factory->build_json_instance( 'YCL_A2G_JSON_FILTERVIEW' ).

    lo_object ?= return.
    DATA: lv_line TYPE numc4.
    DATA(lt_names) =  me->go_json_array->getpartnamesofinstances( me->gc_fnam_filterviews ).
    lv_line = lines( lt_names ).
    me->go_json_array->setinstance(  im_name = me->gc_fnam_filterviews && lv_line
                                     im_object = lo_object ).
  ENDMETHOD.

  METHOD new_protectedranges.
    DATA: lo_object TYPE REF TO object.
    return = me->go_json_factory->build_json_instance( 'YCL_A2G_JSON_PROT_RANGE' ).


    lo_object ?= return.
    DATA: lv_line TYPE numc4.
    DATA(lt_names) =  me->go_json_array->getpartnamesofinstances( me->gc_fnam_protectedranges ).
    lv_line = lines( lt_names ).
    me->go_json_array->setinstance(  im_name = me->gc_fnam_protectedranges && lv_line
                                     im_object = lo_object ).
  ENDMETHOD.

  METHOD new_basicfilter.
    DATA: lo_object TYPE REF TO object.
    return = me->go_json_factory->build_json_instance( 'YCL_A2G_JSON_BASICFILTER' ).

    lo_object ?= return.
    me->go_json_array->setinstance(  im_name = me->gc_fnam_basicfilter
    im_object = lo_object ).
  ENDMETHOD.

  METHOD new_charts.
    DATA: lo_object TYPE REF TO object.
    return = me->go_json_factory->build_json_instance( 'YCL_A2G_JSON_EMBEDDEDCHART' ).

    lo_object ?= return.
    DATA: lv_line TYPE numc4.
    DATA(lt_names) =  me->go_json_array->getpartnamesofinstances( me->gc_fnam_charts ).
    lv_line = lines( lt_names ).
    me->go_json_array->setinstance(  im_name = me->gc_fnam_charts && lv_line
                                     im_object = lo_object ).
  ENDMETHOD.

  METHOD new_bandedranges.
    DATA: lo_object TYPE REF TO object.
    return = me->go_json_factory->build_json_instance( 'YCL_A2G_JSON_BANDEDRANGE' ).


    lo_object ?= return.
    DATA: lv_line TYPE numc4.
    DATA(lt_names) =  me->go_json_array->getpartnamesofinstances( me->gc_fnam_bandedranges ).
    lv_line = lines( lt_names ).
    me->go_json_array->setinstance(  im_name = me->gc_fnam_bandedranges && lv_line
                                     im_object = lo_object ).
  ENDMETHOD.

  METHOD new_developermetadata.
    DATA: lo_object TYPE REF TO object.
    return = me->go_json_factory->build_json_instance( 'YCL_A2G_JSON_DEVELOPERMETADATA' ).

    lo_object ?= return.
    DATA: lv_line TYPE numc4.
    DATA(lt_names) =  me->go_json_array->getpartnamesofinstances( me->gc_fnam_developermetadata ).
    lv_line = lines( lt_names ).
    me->go_json_array->setinstance(  im_name = me->gc_fnam_developermetadata && lv_line
                                     im_object = lo_object ).
  ENDMETHOD.

  METHOD new_rowgroups.
    DATA: lo_object TYPE REF TO object.
    return = me->go_json_factory->build_json_instance( 'YCL_A2G_JSON_DIMENSIONGROUP' ).


    lo_object ?= return.
    DATA: lv_line TYPE numc4.
    DATA(lt_names) =  me->go_json_array->getpartnamesofinstances( me->gc_fnam_rowgroups ).
    lv_line = lines( lt_names ).
    me->go_json_array->setinstance(  im_name = me->gc_fnam_rowgroups && lv_line
                                     im_object = lo_object ).
  ENDMETHOD.

  METHOD new_columngroups.
    DATA: lo_object TYPE REF TO object.
    return = me->go_json_factory->build_json_instance( 'YCL_A2G_JSON_DIMENSIONGROUP' ).

    lo_object ?= return.
    DATA: lv_line TYPE numc4.
    DATA(lt_names) =  me->go_json_array->getpartnamesofinstances( me->gc_fnam_columngroups ).
    lv_line = lines( lt_names ).
    me->go_json_array->setinstance(  im_name = me->gc_fnam_columngroups && lv_line
                                     im_object = lo_object ).
  ENDMETHOD.



ENDCLASS.
",4402,False,934.680766410055,median
"/*******************************************************************************
* Copyright 2018-2021 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.
*******************************************************************************/

/*
  General architecture

  for diff states, we have n_states + 1 as we have n_states diff
  to propagate to the previous iteration and 1 states to propagate
  to the previous layer
  index 0 is dh for cell(t-1, l) to consume // replaced by diff_src_iter
  index 1 is dc for cell(t-1, l) to consume // replaced by diff_src_iter_c
  index 2 is dh for cell(t, l-1) to consume // replace by diff_src_layer
  this indexing enables to have the same indexing for states in elemwise
  function
  only the cell execution function should be impacted

 */

#include ""common/dnnl_thread.hpp""

#include ""cpu/simple_q10n.hpp""

#include ""cpu/gemm/gemm.hpp""
#include ""cpu/gemm/gemm_pack.hpp""

#include ""cpu/rnn/ref_rnn.hpp""

namespace dnnl {
namespace impl {
namespace cpu {

using namespace dnnl::impl::utils;
using namespace dnnl::impl::memory_tracking::names;
using namespace rnn_utils;
#define AOC array_offset_calculator

// GEMM functions wrapper definitions

template <prop_kind_t aprop, data_type_t src_type, data_type_t weights_type,
        data_type_t acc_type>
rnn_gemm_sig(
        (_ref_rnn_common_t<aprop, src_type, weights_type, acc_type>::gemm)) {
    assert(!""non packed gemm is unavailable for this data type"");
    return dnnl_unimplemented;
}

template <>
rnn_gemm_sig((ref_rnn_fwd_f32_t::gemm)) {
    assert(ldA * ldB * ldC != 0);
    return extended_sgemm(&transA, &transB, &m, &n, &k, &alpha, a_, &ldA, b_,
            &ldB, &beta, c_, &ldC, nullptr, pd()->rnn_.force_nocopy);
}

template <>
rnn_gemm_sig((ref_rnn_bwd_f32_t::gemm)) {
    assert(ldA * ldB * ldC != 0);
    return extended_sgemm(&transA, &transB, &m, &n, &k, &alpha, a_, &ldA, b_,
            &ldB, &beta, c_, &ldC, nullptr, pd()->rnn_.force_nocopy);
}

template <>
rnn_gemm_sig((ref_rnn_fwd_bf16_t::gemm)) {
    assert(ldA * ldB * ldC != 0);
    return gemm_bf16bf16f32(&transA, &transB, &m, &n, &k, &alpha, a_, &ldA, b_,
            &ldB, &beta, c_, &ldC);
}

template <>
rnn_gemm_sig((ref_rnn_bwd_bf16_t::gemm)) {
    assert(ldA * ldB * ldC != 0);
    return gemm_bf16bf16f32(&transA, &transB, &m, &n, &k, &alpha, a_, &ldA, b_,
            &ldB, &beta, c_, &ldC);
}

// packed GEMM functions wrapper definitions

template <prop_kind_t aprop, data_type_t src_type, data_type_t weights_type,
        data_type_t acc_type>
rnn_gemm_sig((_ref_rnn_common_t<aprop, src_type, weights_type,
        acc_type>::packed_gemm)) {
    assert(!""packed gemm is unavailable for this datatype"");
    return dnnl_unimplemented;
}

template <>
rnn_gemm_sig(ref_rnn_fwd_f32_t::packed_gemm) {
    assert(transA == 'N' && transB == 'N' && alpha == 1.);
    return sgemm_compute(
            ""P"", ""N"", &m, &n, &k, a_, &ldA, b_, &ldB, &beta, c_, &ldC);
}

template <>
rnn_gemm_sig(ref_rnn_bwd_f32_t::packed_gemm) {
    assert(transA == 'N' && transB == 'N' && alpha == 1.);
    return sgemm_compute(
            ""P"", ""N"", &m, &n, &k, a_, &ldA, b_, &ldB, &beta, c_, &ldC);
}

template <>
rnn_gemm_sig((ref_rnn_fwd_bf16_t::packed_gemm)) {
    assert(transA == 'N' && transB == 'N' && alpha == 1.);
    return gemm_bf16bf16f32_compute(
            ""P"", ""N"", &m, &n, &k, a_, &ldA, b_, &ldB, &beta, c_, &ldC);
}

template <>
rnn_gemm_sig((ref_rnn_bwd_bf16_t::packed_gemm)) {
    assert(transA == 'N' && transB == 'N' && alpha == 1.);
    return gemm_bf16bf16f32_compute(
            ""P"", ""N"", &m, &n, &k, a_, &ldA, b_, &ldB, &beta, c_, &ldC);
}

template <>
rnn_gemm_sig(ref_rnn_fwd_u8s8_t::packed_gemm) {
    assert(transA == 'N' && transB == 'N' && alpha == 1.);
    int32_t offsetc = 0;
    return gemm_s8u8s32_compute(""P"", ""N"", ""F"", &m, &n, &k, a_, &ldA, b_, &ldB,
            &beta, c_, &ldC, &offsetc);
}

template <>
rnn_gemm_sig(ref_rnn_fwd_s8s8_t::packed_gemm) {
    assert(transA == 'N' && transB == 'N' && alpha == 1.);
    int32_t offsetc = 0;
    return gemm_s8s8s32_compute(""P"", ""N"", ""F"", &m, &n, &k, a_, &ldA, b_, &ldB,
            &beta, c_, &ldC, &offsetc);
}

//*************** Grid computations strategy: linear ***************//
template <prop_kind_t aprop, data_type_t src_type, data_type_t weights_type,
        data_type_t acc_type>
rnn_grid_execution_sig((_ref_rnn_common_t<aprop, src_type, weights_type,
        acc_type>::linear_execution)) {
    AOC<src_layer_t, 4> ws_states_layer(ws_states_layer_, rnn.n_layer + 1,
            rnn.n_dir, rnn.n_iter + 1,
            rnn.ws_states_layer_nld * rnn.ws_states_layer_ld);
    AOC<src_iter_t, 4> ws_states_iter(ws_states_iter_, rnn.n_layer + 1,
            rnn.n_dir, rnn.n_iter + 1,
            rnn.ws_states_iter_nld * rnn.ws_states_iter_ld);
    AOC<float, 4> ws_states_iter_c(ws_states_iter_c_, rnn.n_layer + 1,
            rnn.n_dir, rnn.n_iter + 1,
            rnn.ws_states_iter_c_nld * rnn.ws_states_iter_c_ld);
    AOC<gemm_acc_t, 4> ws_diff_states_layer(ws_diff_states_layer_,
            rnn.n_layer + 1, rnn.n_dir, rnn.n_iter + 1,
            rnn.ws_diff_states_layer_nld * rnn.ws_diff_states_layer_ld);
    AOC<gemm_acc_t, 4> ws_diff_states_iter(ws_diff_states_iter_,
            rnn.n_layer + 1, rnn.n_dir, rnn.n_iter + 1,
            rnn.ws_diff_states_iter_nld * rnn.ws_diff_states_iter_ld);
    AOC<gemm_acc_t, 4> ws_diff_states_iter_c(ws_diff_states_iter_c_,
            rnn.n_layer + 1, rnn.n_dir, rnn.n_iter + 1,
            rnn.ws_diff_states_iter_c_nld * rnn.ws_diff_states_iter_c_ld);
    AOC<gates_t, 4> ws_gates(ws_gates_, rnn.n_layer, rnn.n_dir, rnn.n_iter,
            rnn.ws_gates_nld * rnn.ws_gates_ld);
    AOC<dst_iter_t, 4> ws_ht(ws_ht_, rnn.n_layer, rnn.n_dir, rnn.n_iter,
            rnn.ws_ht_nld * rnn.ws_ht_ld);
    AOC<weights_t *, 3> weights_layer(
            weights_layer_, rnn.n_layer, rnn.n_dir, rnn.n_parts_weights_layer);
    AOC<weights_t *, 3> weights_iter(
            weights_iter_, rnn.n_layer, rnn.n_dir, rnn.n_parts_weights_iter);
    AOC<weights_t *, 2> weights_projection(
            weights_projection_, rnn.n_layer, rnn.n_dir);
    AOC<const float, 3> weights_peephole(
            weights_peephole_, rnn.n_layer, rnn.n_dir, 3 * rnn.dhc);
    AOC<float *, 3> bias(bias_, rnn.n_layer, rnn.n_dir, rnn.n_parts_bias);
    AOC<gemm_acc_t, 3> diff_weights_layer(diff_weights_layer_, rnn.n_layer,
            rnn.n_dir, rnn.diff_weights_layer_nld * rnn.diff_weights_layer_ld);
    AOC<gemm_acc_t, 3> diff_weights_iter(diff_weights_iter_, rnn.n_layer,
            rnn.n_dir, rnn.diff_weights_iter_nld * rnn.diff_weights_iter_ld);
    AOC<float, 3> diff_weights_peephole(
            diff_weights_peephole_, rnn.n_layer, rnn.n_dir, 3 * rnn.dhc);
    AOC<float, 3> diff_weights_projection(diff_weights_projection_, rnn.n_layer,
            rnn.n_dir,
            rnn.diff_weights_projection_nld * rnn.diff_weights_projection_ld);
    AOC<float, 3> diff_bias(
            diff_bias_, rnn.n_layer, rnn.n_dir, rnn.n_bias * rnn.dhc);
    AOC<gates_t, 4> ws_grid(
            ws_grid_, rnn.n_layer, rnn.n_dir, rnn.n_iter, (int)rnn.ws_per_cell);

    /* Raw inputs/outputs coming from the user */
    // Here we cannot use AOC as user's input can have arbitrary strides, so we use desc_wrapper.
    auto src_layer_mdw = memory_desc_wrapper(pd()->src_md(0));
    auto dst_layer_mdw = memory_desc_wrapper(pd()->dst_md(0));
    auto src_iter_mdw = memory_desc_wrapper(pd()->src_md(1));
    auto dst_iter_mdw = memory_desc_wrapper(pd()->dst_md(1));
    auto src_iter_c_mdw = memory_desc_wrapper(pd()->src_md(2));
    auto dst_iter_c_mdw = memory_desc_wrapper(pd()->dst_md(2));

    // We run the grid of computation
    for (int dir = 0; dir < rnn.n_dir; dir++) {
        for (int j = 0; j < rnn.n_layer; j++) {
            int lay = (aprop == prop_kind::forward) ? j : rnn.n_layer - j - 1;

            if ((aprop == prop_kind::forward) && rnn.merge_gemm_layer) {
                const src_layer_t *src_layer
                        = &(ws_states_layer(lay, dir, 1, 0));
                auto src_layer_ld = rnn.ws_states_layer_ld;
                // If we avoid copying the last iteration, the corresponding
                // input states appear in `dst_iter_` instead of `ws_states_layer`,
                // hence we cannot merge all iterations.
                // This is not applicable for the first layer though, since
                // all the states come from user's `src_layer_`.
                int n_iter = rnn.n_iter - (rnn.skip_dst_iter_copy() ? 1 : 0);

                if ((lay == 0) && rnn.skip_src_layer_copy()) {
                    src_layer = src_layer_;
                    src_layer_ld = rnn.src_layer_ld_;
                    n_iter = rnn.n_iter;
                }

                CHECK((this->*gemm_layer_func)('N', 'N', rnn.n_gates * rnn.dhc,
                        rnn.mb * n_iter, rnn.slc, 1.0,
                        weights_layer(lay, dir, 0), rnn.weights_layer_ld,
                        src_layer, src_layer_ld, 0.0,
                        (gemm_acc_t *)scratch_gates_, rnn.scratch_gates_ld));
            }

            // TODO: enable merging projection gemm in bwd lstm projection

            for (int i = 0; i < rnn.n_iter; i++) {
                int iter = (aprop == prop_kind::forward) ? i
                                                         : rnn.n_iter - i - 1;

                // We set the FWD parameters to the cell execution
                // call

                // dst_layer is equal to dst_iter. To avoid
                // duplication of memory access we hence use only
                // dst_layer and set dst_iter to nullptr, unless we
                // cannot for one of the following condition:
                // - in the last layer and last iteration, we need to
                //   copy ht in two tensors (dst_layer and dst_iter)
                dst_layer_t *cell_dst_layer
                        = &(ws_states_layer(lay + 1, dir, iter + 1, 0));
                dst_iter_t *cell_dst_iter = nullptr;
                const src_layer_t *cell_src_layer
                        = &(ws_states_layer(lay, dir, iter + 1, 0));
                const src_iter_t *cell_src_iter
                        = &(ws_states_iter(lay + 1, dir, iter, 0));

                float *cell_dst_iter_c
                        = &(ws_states_iter_c(lay + 1, dir, iter + 1, 0));
                const float *cell_src_iter_c
                        = &(ws_states_iter_c(lay + 1, dir, iter, 0));

                // the cell_position is used only when skip_data_copy is
                // supported currently supported only for forward
                cell_position_t cell_position = middle_cell;
                if (iter == 0) cell_position |= first_iter;
                if (lay == 0) cell_position |= first_layer;
                if (iter == rnn.n_iter - 1) cell_position |= last_iter;
                if (lay == rnn.n_layer - 1) cell_position |= last_layer;

                // The dst_* paths should be before the src_* paths as
                // the later will override cell_src_layer and
                // cell_src_iter appropriately for 1st layer and 1st
                // iter.
                bool last_iter_skip_copy = rnn.skip_dst_iter_copy()
                        && (cell_position & last_iter);
                if (last_iter_skip_copy) {
                    cell_dst_layer
                            = dst_iter_ + dst_iter_mdw.off(lay, dir, 0, 0);
                    cell_src_layer
                            = dst_iter_ + dst_iter_mdw.off(lay - 1, dir, 0, 0);
                }

                if (rnn.skip_dst_layer_copy() && (cell_position & last_layer)) {
                    // Note: for last layer and last iter, the output is in dst_layer
                    // and still need to be copied to dst_iter
                    cell_dst_layer = dst_layer_ + dst_layer_mdw.off(iter, 0, 0);
                    cell_dst_iter = last_iter_skip_copy
                            ? dst_iter_ + dst_iter_mdw.off(lay, dir, 0, 0)
                            : nullptr;
                    cell_src_iter = (iter != 0)
                            ? dst_layer_ + dst_layer_mdw.off(iter - 1, 0, 0)
                            : cell_src_iter;
                }
                if (rnn.skip_src_iter_copy() && (cell_position & first_iter))
                    cell_src_iter
                            = src_iter_ + src_iter_mdw.off(lay, dir, 0, 0);

                if (rnn.skip_src_layer_copy() && (cell_position & first_layer))
                    cell_src_layer = src_layer_ + src_layer_mdw.off(iter, 0, 0);

                // because the c state is always f32 and require no
                // conversion, we can always skip to copy for the 1st
                // and last iteration
                if (iter == 0 && src_iter_c_) {
                    cell_src_iter_c
                            = src_iter_c_ + src_iter_c_mdw.off(lay, dir, 0, 0);
                    cell_position |= c_state_first_iter;
                }
                if (iter == rnn.n_iter - 1 && dst_iter_c_) {
                    cell_dst_iter_c
                            = dst_iter_c_ + dst_iter_c_mdw.off(lay, dir, 0, 0);
                    cell_position |= c_state_last_iter;
                }

                auto cell_scratch_gates = rnn.n_iter_scratch_gates == 1
                        ? scratch_gates_
                        : scratch_gates_
                                + iter * rnn.scratch_gates_nld
                                        * rnn.scratch_gates_ld;

                dst_iter_t *proj_ht = nullptr;
                if (rnn.is_lstm_projection) {
                    if (rnn.is_training)
                        proj_ht = &(ws_ht(lay, dir, iter, 0));
                    else
                        proj_ht = scratch_ht_;
                }

#if DNNL_X64
                CHECK((this->*cell_func)(rnn, cell_position, cell_dst_layer,
                        cell_dst_iter_c,
                        &(ws_diff_states_layer(lay, dir, iter, 0)),
                        &(ws_diff_states_iter(lay, dir, iter, 0)),
                        &(ws_diff_states_iter_c(lay, dir, iter, 0)),
                        &(weights_layer(lay, dir, 0)),
                        &(weights_iter(lay, dir, 0)),
                        &(weights_projection(lay, dir)),
                        &(weights_peephole(lay, dir, 0)),
                        w_proj_comp + (j * rnn.n_dir + dir) * rnn.dic,
                        &(bias(lay, dir, 0)), cell_src_layer, cell_src_iter,
                        cell_src_iter_c,
                        &(ws_diff_states_layer(lay + 1, dir, iter, 0)),
                        &(ws_diff_states_iter(lay, dir, iter + 1, 0)),
                        &(ws_diff_states_iter_c(lay, dir, iter + 1, 0)),
                        &(diff_weights_layer(lay, dir, 0)),
                        &(diff_weights_iter(lay, dir, 0)),
                        &(diff_weights_projection(lay, dir, 0)),
                        &(diff_weights_peephole(lay, dir, 0)),
                        &(diff_bias(lay, dir, 0)),
                        &(ws_gates(lay, dir, iter, 0)), cell_scratch_gates,
                        proj_ht, scratch_diff_ht_,
                        &(ws_grid(lay, dir, iter, 0)), scratch_cell_,
                        cell_dst_iter, amx_scratchpad, addr_batch_global));
#else
                CHECK((this->*cell_func)(rnn, cell_position, cell_dst_layer,
                        cell_dst_iter_c,
                        &(ws_diff_states_layer(lay, dir, iter, 0)),
                        &(ws_diff_states_iter(lay, dir, iter, 0)),
                        &(ws_diff_states_iter_c(lay, dir, iter, 0)),
                        &(weights_layer(lay, dir, 0)),
                        &(weights_iter(lay, dir, 0)),
                        &(weights_projection(lay, dir)),
                        &(weights_peephole(lay, dir, 0)),
                        w_proj_comp + (j * rnn.n_dir + dir) * rnn.dic,
                        &(bias(lay, dir, 0)), cell_src_layer, cell_src_iter,
                        cell_src_iter_c,
                        &(ws_diff_states_layer(lay + 1, dir, iter, 0)),
                        &(ws_diff_states_iter(lay, dir, iter + 1, 0)),
                        &(ws_diff_states_iter_c(lay, dir, iter + 1, 0)),
                        &(diff_weights_layer(lay, dir, 0)),
                        &(diff_weights_iter(lay, dir, 0)),
                        &(diff_weights_projection(lay, dir, 0)),
                        &(diff_weights_peephole(lay, dir, 0)),
                        &(diff_bias(lay, dir, 0)),
                        &(ws_gates(lay, dir, iter, 0)), cell_scratch_gates,
                        proj_ht, scratch_diff_ht_,
                        &(ws_grid(lay, dir, iter, 0)), scratch_cell_,
                        cell_dst_iter, amx_scratchpad));
#endif
            }

            if ((aprop == prop_kind::backward) && rnn.merge_gemm_layer) {
                const src_layer_t *src_layer
                        = &(ws_states_layer(lay, dir, 1, 0));
                auto src_layer_ld = rnn.ws_states_layer_ld;
                // If we avoid copying the last iteration, the corresponding
                // input states appear in `dst_iter_` instead of `ws_states_layer`,
                // hence we cannot merge all iterations.
                // This is not applicable for the first layer though, since
                // all the states come from user's `src_layer_`.
                int n_iter = rnn.n_iter - rnn.skip_dst_iter_copy();

                if ((lay == 0) && rnn.skip_src_layer_copy()) {
                    src_layer = src_layer_;
                    src_layer_ld = rnn.src_layer_ld_;
                    n_iter = rnn.n_iter;
                }

                CHECK((this->*gemm_layer_func)('N', 'N', rnn.slc,
                        rnn.mb * rnn.n_iter, rnn.n_gates * rnn.dhc, 1.0,
                        weights_layer(lay, dir, 0), rnn.weights_layer_ld,
                        (gates_t *)scratch_gates_, rnn.scratch_gates_ld, 0.0,
                        &(ws_diff_states_layer(lay, dir, 0, 0)),
                        rnn.ws_diff_states_layer_ld));
                CHECK(gemm('N', 'T', rnn.n_gates * rnn.dhc, rnn.slc,
                        rnn.mb * n_iter, 1.0, (weights_t *)scratch_gates_,
                        rnn.scratch_gates_ld, src_layer, src_layer_ld, 1.0,
                        &(diff_weights_layer(lay, dir, 0)),
                        rnn.diff_weights_layer_ld));
            }
            if ((aprop == prop_kind::backward) && rnn.merge_gemm_iter) {
                // This is split in 3 pieces if we skip copies.
                // last iter in user mem, middle iters in ws, first iter in user mem
                // Note 1: here we assume no change in datatypes for src_iter, ws_iter and dst_iter

                const dst_iter_t *states_iter = nullptr;
                int states_iter_ld = 0;
                int niter_merge_gemm_iter = 0;

                states_iter = &(ws_states_iter(
                        lay + 1, dir, rnn.skip_src_iter_copy(), 0));
                states_iter_ld = rnn.ws_states_iter_ld;
                if (rnn.skip_dst_layer_copy()
                        && (lay == rnn.n_layer - 1)) { // last layer
                    states_iter = dst_layer_;
                    states_iter_ld = rnn.dst_layer_ld_;
                }
                niter_merge_gemm_iter = rnn.n_iter - rnn.skip_src_iter_copy();
                if (niter_merge_gemm_iter > 0) {
                    CHECK(gemm('N', 'T', rnn.n_gates * rnn.dhc, rnn.sic,
                            rnn.mb * niter_merge_gemm_iter, 1.0,
                            (weights_t *)scratch_gates_
                                    + rnn.skip_src_iter_copy()
                                            * rnn.scratch_gates_nld
                                            * rnn.scratch_gates_ld,
                            rnn.scratch_gates_ld, states_iter, states_iter_ld,
                            1.0, &(diff_weights_iter(lay, dir, 0)),
                            rnn.diff_weights_iter_ld));
                }

                if (rnn.skip_src_iter_copy()) {
                    states_iter = src_iter_ + src_iter_mdw.off(lay, dir, 0, 0);
                    states_iter_ld = rnn.src_iter_ld_;
                    niter_merge_gemm_iter = 1;
                    CHECK(gemm('N', 'T', rnn.n_gates * rnn.dhc, rnn.sic,
                            rnn.mb * niter_merge_gemm_iter, 1.0,
                            (weights_t *)scratch_gates_, rnn.scratch_gates_ld,
                            states_iter, states_iter_ld, 1.0,
                            &(diff_weights_iter(lay, dir, 0)),
                            rnn.diff_weights_iter_ld));
                }
            }
        }
    }
    return dnnl_success;
}

//********* GRID computations strategy: utility functions **********//

template <typename src_data_t>
void copy_init_layer_fwd_template(const rnn_conf_t &rnn,
        src_data_t *__restrict ws_states_layer_,
        const src_data_t *__restrict xt_, const memory_desc_wrapper &xt_d) {

    AOC<src_data_t, 4> ws_states_layer(ws_states_layer_, rnn.n_dir,
            rnn.n_iter + 1, rnn.mb, rnn.ws_states_layer_ld);

    parallel_nd(rnn.n_iter, rnn.mb, [&](int it, int b) {
        auto xxt = xt_ + xt_d.blk_off(it, b);
        src_data_t *ws_l2r_ptr = &(ws_states_layer(0, it + 1, b, 0));
        src_data_t *ws_r2l_ptr
                = &(ws_states_layer(rnn.n_dir - 1, rnn.n_iter - it, b, 0));
        if (rnn.exec_dir != r2l) {
            PRAGMA_OMP_SIMD()
            for (int c = 0; c < rnn.slc; c++)
                ws_l2r_ptr[c] = xxt[c];
        }
        if (rnn.exec_dir != l2r) {
            PRAGMA_OMP_SIMD()
            for (int c = 0; c < rnn.slc; c++)
                ws_r2l_ptr[c] = xxt[c];
        }
    });
}

template <typename acc_data_t>
void copy_init_layer_bwd_template(const rnn_conf_t &rnn,
        acc_data_t *ws_diff_states_layer_, const acc_data_t *diff_dst_layer_,
        const memory_desc_wrapper &diff_dst_layer_d) {
    AOC<acc_data_t, 5> ws_diff_states_layer(ws_diff_states_layer_,
            rnn.n_layer + 1, rnn.n_dir, rnn.n_iter + 1, rnn.mb,
            rnn.ws_diff_states_layer_ld);

    switch (rnn.exec_dir) {
        case bi_concat:
            parallel_nd(rnn.n_iter, rnn.mb, [&](int it, int b) {
                auto diff_dst_layer_x
                        = diff_dst_layer_ + diff_dst_layer_d.blk_off(it, b);
                for (int s = 0; s < rnn.dlc; s++) {
                    ws_diff_states_layer(rnn.n_layer, 0, it, b, s)
                            = diff_dst_layer_x[s];
                    ws_diff_states_layer(
                            rnn.n_layer, 1, rnn.n_iter - it - 1, b, s)
                            = diff_dst_layer_x[rnn.dlc + s];
                }
            });
            break;
        case bi_sum:
            parallel_nd(rnn.n_iter, rnn.mb, [&](int it, int b) {
                auto diff_dst_layer_x
                        = diff_dst_layer_ + diff_dst_layer_d.blk_off(it, b);
                for (int s = 0; s < rnn.dlc; s++) {
                    ws_diff_states_layer(rnn.n_layer, 0, it, b, s)
                            = diff_dst_layer_x[s];
                    ws_diff_states_layer(
                            rnn.n_layer, 1, rnn.n_iter - it - 1, b, s)
                            = diff_dst_layer_x[s];
                }
            });
            break;
        case l2r:
            parallel_nd(rnn.n_iter, rnn.mb, [&](int it, int b) {
                auto diff_dst_layer_x
                        = diff_dst_layer_ + diff_dst_layer_d.blk_off(it, b);
                for (int s = 0; s < rnn.dlc; s++) {
                    ws_diff_states_layer(rnn.n_layer, 0, it, b, s)
                            = diff_dst_layer_x[s];
                }
            });
            break;
        case r2l:
            parallel_nd(rnn.n_iter, rnn.mb, [&](int it, int b) {
                auto diff_dst_layer_x = diff_dst_layer_
                        + diff_dst_layer_d.blk_off(rnn.n_iter - it - 1, b);
                for (int s = 0; s < rnn.dlc; s++) {
                    ws_diff_states_layer(rnn.n_layer, 0, it, b, s)
                            = diff_dst_layer_x[s];
                }
            });
            break;
        default: assert(!""Unsupported direction""); break;
    }
}

#define RNN_DECL_COPY_INIT_LAYER_FWD(cname) \\
    template <> \\
    void cname::copy_init_layer(const rnn_conf_t &rnn, \\
            src_layer_t *ws_states_layer_, gemm_acc_t *ws_diff_states_layer_, \\
            const src_layer_t *xt_, const gemm_acc_t *diff_dst_layer_) const { \\
        copy_init_layer_fwd_template(rnn, ws_states_layer_, xt_, \\
                memory_desc_wrapper(pd()->src_md(0))); \\
    }

RNN_DECL_COPY_INIT_LAYER_FWD(ref_rnn_fwd_f32_t)
RNN_DECL_COPY_INIT_LAYER_FWD(ref_rnn_fwd_bf16_t)
RNN_DECL_COPY_INIT_LAYER_FWD(ref_rnn_fwd_u8s8_t)
RNN_DECL_COPY_INIT_LAYER_FWD(ref_rnn_fwd_s8s8_t)

#define RNN_DECL_COPY_INIT_LAYER_BWD(cname) \\
    template <> \\
    void cname::copy_init_layer(const rnn_conf_t &rnn, \\
            src_layer_t *ws_states_layer_, gemm_acc_t *ws_diff_states_layer_, \\
            const src_layer_t *xt_, const gemm_acc_t *diff_dst_layer_) const { \\
        copy_init_layer_bwd_template(rnn, ws_diff_states_layer_, \\
                diff_dst_layer_, memory_desc_wrapper(pd()->diff_dst_md(0))); \\
    }

RNN_DECL_COPY_INIT_LAYER_BWD(ref_rnn_bwd_f32_t)
RNN_DECL_COPY_INIT_LAYER_BWD(ref_rnn_bwd_bf16_t)

/* For int8 configuration, input iteration states may be of types f32 or u8
 * Internally h_state is always stored in u8 and c_state is always stored in f32
 * If input states are of type u8 then h state is copied and c state is dequantized
 * If input states are of type f32 then h state is quantized and c_state is copied
 * */
template <typename src_data_t, typename input_data_t>
void copy_init_iter_fwd_template(const rnn_conf_t &rnn, const rnn_pd_t *pd,
        src_data_t *__restrict ws_states_iter_,
        float *__restrict ws_states_iter_c_,
        const input_data_t *__restrict src_iter_,
        const memory_desc_wrapper &src_iter_d,
        const float *__restrict src_iter_c_,
        const memory_desc_wrapper &src_iter_c_d) {
    AOC<src_data_t, 5> ws_states_iter(ws_states_iter_, rnn.n_layer + 1,
            rnn.n_dir, rnn.n_iter + 1, rnn.mb, rnn.ws_states_iter_ld);
    AOC<float, 5> ws_states_iter_c(ws_states_iter_c_, rnn.n_layer + 1,
            rnn.n_dir, rnn.n_iter + 1, rnn.mb, rnn.ws_states_iter_c_ld);
    const float data_shift = pd->attr()->rnn_data_qparams_.shift_;
    const float data_scale = pd->attr()->rnn_data_qparams_.scale_;

    const bool quantize = rnn.is_int8()
            && IMPLICATION(pd->with_src_iter(),
                    pd->src_md(1)->data_type == data_type::f32);
    auto maybe_q = [&](input_data_t f) {
        if (quantize) {
            float qf = f * data_scale + data_shift;
            return qz_a1b0<float, src_data_t>()(qf);
        } else
            return (src_data_t)f;
    };
    const src_data_t zero = maybe_q(0.f);

    if (src_iter_) {
        parallel_nd(
                rnn.n_layer, rnn.n_dir, rnn.mb, [&](int lay, int dir, int b) {
                    const auto *ss
                            = &src_iter_[src_iter_d.blk_off(lay, dir, b, 0)];
                    auto *dd = &ws_states_iter(lay + 1, dir, 0, b, 0);
                    PRAGMA_OMP_SIMD()
                    for (int s = 0; s < rnn.sic; s++)
                        dd[s] = maybe_q(ss[s]);
                });
    } else {
        parallel_nd(
                rnn.n_layer, rnn.n_dir, rnn.mb, [&](int lay, int dir, int b) {
                    for (int j = 0; j < rnn.sic; j++)
                        ws_states_iter(lay + 1, dir, 0, b, j) = zero;
                    if (pd->cell_kind() == alg_kind::vanilla_lstm)
                        for (int j = 0; j < rnn.dhc; j++)
                            ws_states_iter_c(lay + 1, dir, 0, b, j) = 0.0f;
                });
    }
}

template <typename acc_data_t>
void copy_init_iter_bwd_template(const rnn_conf_t &rnn, const rnn_pd_t *pd,
        acc_data_t *ws_diff_states_iter_, acc_data_t *ws_diff_states_iter_c_,
        const acc_data_t *diff_dst_iter_,
        const memory_desc_wrapper diff_dst_iter_d,
        const float *diff_dst_iter_c_,
        const memory_desc_wrapper diff_dst_iter_c_d) {
    AOC<acc_data_t, 5> ws_diff_states_iter(ws_diff_states_iter_,
            rnn.n_layer + 1, rnn.n_dir, rnn.n_iter + 1, rnn.mb,
            rnn.ws_diff_states_iter_ld);
    AOC<acc_data_t, 5> ws_diff_states_iter_c(ws_diff_states_iter_c_,
            rnn.n_layer + 1, rnn.n_dir, rnn.n_iter + 1, rnn.mb,
            rnn.ws_diff_states_iter_c_ld);
    if (diff_dst_iter_) {
        parallel_nd(
                rnn.n_layer, rnn.n_dir, rnn.mb, [&](int lay, int dir, int b) {
                    array_copy(
                            &(ws_diff_states_iter(lay, dir, rnn.n_iter, b, 0)),
                            diff_dst_iter_
                                    + diff_dst_iter_d.blk_off(lay, dir, b),
                            rnn.dic);
                    if (pd->cell_kind() == alg_kind::vanilla_lstm)
                        array_copy(&(ws_diff_states_iter_c(
                                           lay, dir, rnn.n_iter, b, 0)),
                                diff_dst_iter_c_
                                        + diff_dst_iter_c_d.blk_off(
                                                lay, dir, b),
                                rnn.dhc);
                });
    } else {
        parallel_nd(
                rnn.n_layer, rnn.n_dir, rnn.mb, [&](int lay, int dir, int i) {
                    for (int j = 0; j < rnn.dic; j++)
                        ws_diff_states_iter(lay, dir, rnn.n_iter, i, j) = 0.0f;
                    if (pd->cell_kind() == alg_kind::vanilla_lstm)
                        for (int j = 0; j < rnn.dhc; j++)
                            ws_diff_states_iter_c(lay, dir, rnn.n_iter, i, j)
                                    = 0.0f;
                });
    }
}

#define RNN_DECL_COPY_INIT_ITER_FWD(cname) \\
    template <> \\
    template <typename input_data_t> \\
    void cname::copy_init_iter(const rnn_conf_t &rnn, \\
            src_layer_t *__restrict ws_states_iter_, \\
            float *__restrict ws_states_iter_c_, \\
            gemm_acc_t *__restrict ws_diff_states_iter_, \\
            gemm_acc_t *__restrict ws_diff_states_iter_c_, \\
            const input_data_t *__restrict src_iter_, \\
            const float *__restrict src_iter_c_, \\
            const gemm_acc_t *__restrict diff_dst_iter_, \\
            const float *__restrict diff_dst_iter_c_) const { \\
        auto src_iter_d = memory_desc_wrapper(pd()->src_md(1)); \\
        auto src_iter_c_d = memory_desc_wrapper(pd()->src_md(2)); \\
        copy_init_iter_fwd_template(rnn, pd(), ws_states_iter_, \\
                ws_states_iter_c_, src_iter_, src_iter_d, src_iter_c_, \\
                src_iter_c_d); \\
    }

RNN_DECL_COPY_INIT_ITER_FWD(ref_rnn_fwd_f32_t)
RNN_DECL_COPY_INIT_ITER_FWD(ref_rnn_fwd_bf16_t)
RNN_DECL_COPY_INIT_ITER_FWD(ref_rnn_fwd_u8s8_t)
RNN_DECL_COPY_INIT_ITER_FWD(ref_rnn_fwd_s8s8_t)

#define RNN_DECL_COPY_INIT_ITER_BWD(cname) \\
    template <> \\
    template <typename input_data_t> \\
    void cname::copy_init_iter(const rnn_conf_t &rnn, \\
            src_layer_t *ws_states_iter_, float *ws_states_iter_c_, \\
            gemm_acc_t *ws_diff_states_iter_, \\
            gemm_acc_t *ws_diff_states_iter_c_, const input_data_t *src_iter_, \\
            const float *src_iter_c_, const gemm_acc_t *diff_dst_iter_, \\
            const float *diff_dst_iter_c_) const { \\
        auto diff_dst_iter_d = memory_desc_wrapper(pd()->diff_dst_md(1)); \\
        auto diff_dst_iter_c_d = memory_desc_wrapper(pd()->diff_dst_md(2)); \\
        copy_init_iter_bwd_template(rnn, pd(), ws_diff_states_iter_, \\
                ws_diff_states_iter_c_, diff_dst_iter_, diff_dst_iter_d, \\
                diff_dst_iter_c_, diff_dst_iter_c_d); \\
    }

RNN_DECL_COPY_INIT_ITER_BWD(ref_rnn_bwd_f32_t)
RNN_DECL_COPY_INIT_ITER_BWD(ref_rnn_bwd_bf16_t)

template <typename src_data_t, typename dst_layer_dt, typename dst_iter_dt>
void copy_res_layer_fwd_template(const rnn_conf_t &rnn, const rnn_pd_t *pd,
        dst_layer_dt *dst_layer_, memory_desc_wrapper &dst_layer_d,
        const dst_iter_dt *dst_iter_, const memory_desc_wrapper &dst_iter_d,
        const src_data_t *ws_states_layer_) {

    AOC<const src_data_t, 5> ws_states_layer(ws_states_layer_, rnn.n_layer + 1,
            rnn.n_dir, rnn.n_iter + 1, rnn.mb, rnn.ws_states_layer_ld);
    const float shift = (pd->attr()->rnn_data_qparams_.shift_);
    const float scale = (pd->attr()->rnn_data_qparams_.scale_);

    const bool dequantize
            = pd->dst_md(0)->data_type == data_type::f32 && rnn.is_int8();
    const bool dequantize_at_copy = dequantize && rnn.exec_dir != bi_sum;

    // minor optimization helper for a compiler
    static constexpr bool rnn_u8u8_case
            = std::is_same<dst_layer_dt, uint8_t>::value
            && std::is_same<src_data_t, uint8_t>::value;
    static constexpr bool rnn_s8s8_case
            = std::is_same<dst_layer_dt, int8_t>::value
            && std::is_same<src_data_t, int8_t>::value;

    auto copy_vec = [&](dst_layer_dt *dd, const src_data_t *ss) {
        if (dequantize_at_copy) {
            PRAGMA_OMP_SIMD()
            for (int s = 0; s < rnn.dlc; s++)
                dd[s] = (dst_layer_dt)(((float)ss[s] - shift) / scale);
        } else {
            PRAGMA_OMP_SIMD()
            for (int s = 0; s < rnn.dlc; s++)
                dd[s] = (dst_layer_dt)ss[s];
        }
    };

    auto acc_vec = [&](dst_layer_dt *dd, const src_data_t *ss) {
        if (dequantize) {
            PRAGMA_OMP_SIMD()
            for (int s = 0; s < rnn.dlc; s++) {
                float val = (float)ss[s] + dd[s];
                val = qz_a1b0<float, src_data_t>()(val);
                dd[s] = (dst_layer_dt)((val - 2 * shift) / scale);
            }
        } else if (rnn_u8u8_case
                || rnn_s8s8_case) { // instead of checking for rnn.is_int8()
            PRAGMA_OMP_SIMD()
            for (int s = 0; s < rnn.dlc; s++)
                dd[s] = saturate<dst_layer_dt, int16_t>(
                        (int16_t)dd[s] + (int16_t)ss[s]);
        } else {
            PRAGMA_OMP_SIMD()
            for (int s = 0; s < rnn.dlc; s++)
                dd[s] += (dst_layer_dt)ss[s];
        }
    };

    // if skip_dst_iter_copy, then the data for the last iteration is
    // in dst_iter, not in workspace
    parallel_nd(rnn.n_iter - (rnn.skip_dst_iter_copy() ? 1 : 0), rnn.mb,
            [&](int it, int b) {
                int dir = 0;
                if (rnn.exec_dir != r2l) {
                    const auto *ss
                            = &ws_states_layer(rnn.n_layer, dir, it + 1, b, 0);
                    auto *dd = &dst_layer_[dst_layer_d.blk_off(
                            it, b, dir * rnn.dlc)];
                    copy_vec(dd, ss);
                    dir = 1;
                }
                if (rnn.exec_dir != l2r) {
                    const auto *ss = &ws_states_layer(
                            rnn.n_layer, dir, rnn.n_iter - it, b, 0);
                    if (rnn.exec_dir == bi_sum) {
                        auto *dd = &dst_layer_[dst_layer_d.blk_off(it, b, 0)];
                        acc_vec(dd, ss);
                    } else {
                        auto *dd = &dst_layer_[dst_layer_d.blk_off(
                                it, b, dir * rnn.dlc)];
                        copy_vec(dd, ss);
                    }
                }
            });
    if (rnn.skip_dst_iter_copy()) {
        parallel_nd(rnn.mb, [&](int b) {
            const int it = rnn.n_iter - 1;
            int dir = 0;
            if (rnn.exec_dir != r2l) {
                const auto *ss = dst_iter_
                        + dst_iter_d.blk_off(rnn.n_layer - 1, dir, b, 0);
                auto *dd = &dst_layer_[dst_layer_d.blk_off(
                        it, b, dir * rnn.dlc)];
                copy_vec(dd, (src_data_t *)ss);
                dir = 1;
            }
            if (rnn.exec_dir != l2r) {
                const auto *ss = dst_iter_
                        + dst_iter_d.blk_off(rnn.n_layer - 1, dir, b, 0);
                if (rnn.exec_dir == bi_sum) {
                    auto *dd = &dst_layer_[dst_layer_d.blk_off(it, b, 0)];
                    acc_vec(dd, (src_data_t *)ss);
                } else {
                    auto *dd = &dst_layer_[dst_layer_d.blk_off(
                            it, b, dir * rnn.dlc)];
                    copy_vec(dd, (src_data_t *)ss);
                }
            }
        });
    }
}

template <typename acc_data_t>
void copy_res_layer_bwd_template(const rnn_conf_t &rnn,
        acc_data_t *diff_src_layer_, memory_desc_wrapper &diff_src_layer_d,
        const acc_data_t *ws_diff_states_layer_) {
    AOC<const acc_data_t, 5> ws_diff_states_layer(ws_diff_states_layer_,
            rnn.n_layer + 1, rnn.n_dir, rnn.n_iter + 1, rnn.mb,
            rnn.ws_diff_states_layer_ld);

    parallel_nd(rnn.n_iter, rnn.mb, [&](int it, int b) {
        int dir = 0;
        for (int s = 0; s < rnn.slc; s++) {
            acc_data_t *dst_addr = diff_src_layer_
                    + diff_src_layer_d.blk_off(
                            (rnn.exec_dir == r2l) ? rnn.n_iter - 1 - it : it, b,
                            dir * rnn.slc + s);
            acc_data_t res = ws_diff_states_layer(0, 0, it, b, s);
            if (rnn.n_dir - 1)
                res += ws_diff_states_layer(0, 1, rnn.n_iter - 1 - it, b, s);
            dst_addr[0] = res;
        }
    });
}

#define RNN_DECL_COPY_RES_LAYER_FWD(cname) \\
    template <> \\
    template <typename dst_layer_dt, typename dst_iter_dt> \\
    void cname::copy_res_layer(const rnn_conf_t &rnn, \\
            dst_layer_dt *dst_layer_, gemm_acc_t *diff_src_layer, \\
            const dst_iter_dt *dst_iter_, const src_layer_t *ws_states_layer_, \\
            const gemm_acc_t *ws_diff_states_layer_) const { \\
        auto dst_layer_d = memory_desc_wrapper(pd()->dst_md(0)); \\
        auto dst_iter_d = memory_desc_wrapper(pd()->dst_md(1)); \\
        copy_res_layer_fwd_template(rnn, pd(), dst_layer_, dst_layer_d, \\
                dst_iter_, dst_iter_d, ws_states_layer_); \\
    }

RNN_DECL_COPY_RES_LAYER_FWD(ref_rnn_fwd_f32_t)
RNN_DECL_COPY_RES_LAYER_FWD(ref_rnn_fwd_bf16_t)
RNN_DECL_COPY_RES_LAYER_FWD(ref_rnn_fwd_u8s8_t)
RNN_DECL_COPY_RES_LAYER_FWD(ref_rnn_fwd_s8s8_t)

#define RNN_DECL_COPY_RES_LAYER_BWD(cname) \\
    template <> \\
    template <typename dst_layer_dt, typename dst_iter_dt> \\
    void cname::copy_res_layer(const rnn_conf_t &rnn, \\
            dst_layer_dt *dst_layer_, gemm_acc_t *diff_src_layer_, \\
            const dst_iter_dt *dst_iter_, const src_layer_t *ws_states_layer_, \\
            const gemm_acc_t *ws_diff_states_layer_) const { \\
        auto diff_src_layer_d = memory_desc_wrapper(pd()->diff_src_md(0)); \\
        copy_res_layer_bwd_template(rnn, diff_src_layer_, diff_src_layer_d, \\
                ws_diff_states_layer_); \\
    }

RNN_DECL_COPY_RES_LAYER_BWD(ref_rnn_bwd_f32_t)
RNN_DECL_COPY_RES_LAYER_BWD(ref_rnn_bwd_bf16_t)

template <typename src_data_t, typename dst_iter_dt, typename dst_layer_dt>
void copy_res_iter_fwd_template(const rnn_conf_t &rnn, const rnn_pd_t *pd,
        dst_iter_dt *dst_iter_, memory_desc_wrapper &dst_iter_d,
        float *dst_iter_c_, memory_desc_wrapper dst_iter_c_d,
        const dst_layer_dt *dst_layer_, memory_desc_wrapper dst_layer_d,
        const src_data_t *ws_states_iter_, const float *ws_states_iter_c_) {
    if (dst_iter_ == nullptr) return;

    AOC<const src_data_t, 5> ws_states_iter(ws_states_iter_, rnn.n_layer + 1,
            rnn.n_dir, rnn.n_iter + 1, rnn.mb, rnn.ws_states_iter_ld);
    AOC<const float, 5> ws_states_iter_c(ws_states_iter_c_, rnn.n_layer + 1,
            rnn.n_dir, rnn.n_iter + 1, rnn.mb, rnn.ws_states_iter_c_ld);

    const float data_shift = pd->attr()->rnn_data_qparams_.shift_;
    const float data_scale = pd->attr()->rnn_data_qparams_.scale_;

    const bool dequantize = pd->with_dst_iter()
            && pd->dst_md(1)->data_type == data_type::f32 && rnn.is_int8();
    auto copy_vec = [&](dst_iter_dt *dd, const src_data_t *ss) {
        if (dequantize) {
            PRAGMA_OMP_SIMD()
            for (int s = 0; s < rnn.dic; s++)
                dd[s] = (dst_iter_dt)(((float)ss[s] - data_shift) / data_scale);
        } else {
            PRAGMA_OMP_SIMD()
            for (int s = 0; s < rnn.dic; s++)
                dd[s] = (dst_iter_dt)ss[s];
        }
    };

    // If skip_dst_layer_copy, then the data to copy for the last
    // layer is in dst_layer, not in workspace.
    auto n_layer_in_ws = rnn.n_layer - rnn.skip_dst_layer_copy();

    parallel_nd(n_layer_in_ws, rnn.n_dir, rnn.mb, [&](int lay, int dir, int b) {
        const auto *ss = &ws_states_iter(lay + 1, dir, rnn.n_iter, b, 0);
        auto *dd = dst_iter_ + dst_iter_d.blk_off(lay, dir, b, 0);
        copy_vec(dd, ss);
    });

    if (rnn.skip_dst_layer_copy()) {
        parallel_nd(rnn.n_dir, rnn.mb, [&](int dir, int b) {
            const auto *ss
                    = &dst_layer_[dst_layer_d.blk_off(rnn.n_iter - 1, b, dir)];
            auto *dd = &dst_iter_[dst_iter_d.blk_off(
                    rnn.n_layer - 1, dir, b, 0)];
            copy_vec(dd, (src_data_t *)ss);
        });
    }
}

template <typename acc_data_t>
void copy_res_iter_bwd_template(const rnn_conf_t &rnn, const rnn_pd_t *pd,
        acc_data_t *diff_src_iter_, memory_desc_wrapper &diff_src_iter_d,
        float *diff_src_iter_c_, memory_desc_wrapper &diff_src_iter_c_d,
        const acc_data_t *ws_diff_states_iter_,
        const acc_data_t *ws_diff_states_iter_c_) {
    AOC<const acc_data_t, 5> ws_diff_states_iter(ws_diff_states_iter_,
            rnn.n_layer + 1, rnn.n_dir, rnn.n_iter + 1, rnn.mb,
            rnn.ws_diff_states_iter_ld);
    AOC<const acc_data_t, 5> ws_diff_states_iter_c(ws_diff_states_iter_c_,
            rnn.n_layer + 1, rnn.n_dir, rnn.n_iter + 1, rnn.mb,
            rnn.ws_diff_states_iter_c_ld);
    if (diff_src_iter_) {
        parallel_nd(
                rnn.n_layer, rnn.n_dir, rnn.mb, [&](int lay, int dir, int b) {
                    for (int s = 0; s < rnn.sic; s++) {
                        diff_src_iter_[diff_src_iter_d.blk_off(lay, dir, b, s)]
                                = ws_diff_states_iter(lay, dir, 0, b, s);
                    }
                    if (pd->cell_kind() == alg_kind::vanilla_lstm)
                        for (int s = 0; s < rnn.dhc; s++) {
                            diff_src_iter_c_[diff_src_iter_c_d.blk_off(
                                    lay, dir, b, s)]
                                    = ws_diff_states_iter_c(lay, dir, 0, b, s);
                        }
                });
    }
}

#define RNN_DECL_COPY_RES_ITER_FWD(cname) \\
    template <> \\
    template <typename dst_iter_dt, typename dst_layer_dt> \\
    void cname::copy_res_iter(const rnn_conf_t &rnn, dst_iter_dt *dst_iter_, \\
            float *dst_iter_c_, gemm_acc_t *diff_src_iter_, \\
            float *diff_src_iter_c_, const dst_layer_dt *dst_layer_, \\
            const src_layer_t *ws_states_layer_, \\
            const float *ws_states_iter_c_, \\
            const gemm_acc_t *ws_diff_states_iter_, \\
            const gemm_acc_t *ws_diff_states_iter_c_) const { \\
        auto dst_layer_d = memory_desc_wrapper(pd()->dst_md(0)); \\
        auto dst_iter_d = memory_desc_wrapper(pd()->dst_md(1)); \\
        auto dst_iter_c_d = memory_desc_wrapper(pd()->dst_md(2)); \\
        copy_res_iter_fwd_template(rnn, pd(), dst_iter_, dst_iter_d, \\
                dst_iter_c_, dst_iter_c_d, dst_layer_, dst_layer_d, \\
                ws_states_layer_, ws_states_iter_c_); \\
    }

RNN_DECL_COPY_RES_ITER_FWD(ref_rnn_fwd_f32_t)
RNN_DECL_COPY_RES_ITER_FWD(ref_rnn_fwd_bf16_t)
RNN_DECL_COPY_RES_ITER_FWD(ref_rnn_fwd_u8s8_t)
RNN_DECL_COPY_RES_ITER_FWD(ref_rnn_fwd_s8s8_t)

#define RNN_DECL_COPY_RES_ITER_BWD(cname) \\
    template <> \\
    template <typename output_data_t, typename dst_data_t> \\
    void cname::copy_res_iter(const rnn_conf_t &rnn, output_data_t *dst_iter_, \\
            float *dst_iter_c_, gemm_acc_t *diff_src_iter_, \\
            float *diff_src_iter_c_, const dst_data_t *dst_layer_, \\
            const src_layer_t *ws_states_layer_, \\
            const float *ws_states_iter_c_, \\
            const gemm_acc_t *ws_diff_states_iter_, \\
            const gemm_acc_t *ws_diff_states_iter_c_) const { \\
        auto diff_src_iter_d = memory_desc_wrapper(pd()->diff_src_md(1)); \\
        auto diff_src_iter_c_d = memory_desc_wrapper(pd()->diff_src_md(2)); \\
        copy_res_iter_bwd_template(rnn, pd(), diff_src_iter_, diff_src_iter_d, \\
                diff_src_iter_c_, diff_src_iter_c_d, ws_diff_states_iter_, \\
                ws_diff_states_iter_c_); \\
    }

RNN_DECL_COPY_RES_ITER_BWD(ref_rnn_bwd_f32_t)
RNN_DECL_COPY_RES_ITER_BWD(ref_rnn_bwd_bf16_t)

template <prop_kind_t aprop, data_type_t src_type, data_type_t weights_type,
        data_type_t acc_type>
rnn_bias_prepare_sig((_ref_rnn_common_t<aprop, src_type, weights_type,
        acc_type>::bias_prepare)) {
    /* Original set of bias provided by the user */
    AOC<const float, 5> b(b_, rnn.n_layer, rnn.n_dir, rnn.n_bias * rnn.dhc);
    /* Array of pointers initialized in packing */
    AOC<float *, 3> bias(bias_, rnn.n_layer, rnn.n_dir, rnn.n_parts_bias);
    AOC<float, 3> scratch_bias(
            scratch_bias_, rnn.n_layer, rnn.n_dir, rnn.n_bias * rnn.dhc);

    if (rnn.copy_bias) {
        parallel_nd(rnn.n_layer * rnn.n_dir, [&](int i) {
            int off = i * rnn.n_bias * rnn.dhc;
            PRAGMA_OMP_SIMD()
            for (int j = 0; j < rnn.n_bias * rnn.dhc; j++)
                scratch_bias_[off + j] = b_[off + j];
        });
    }

    for (int i = 0; i < rnn.n_layer; i++) {
        for (int d = 0; d < rnn.n_dir; d++) {
            int offset_bias = 0;
            for (int p = 0; p < rnn.n_parts_bias; p++) {
                bias(i, d, p) = rnn.copy_bias
                        ? (float *)&scratch_bias(i, d, offset_bias)
                        : (float *)&b(i, d, offset_bias);
                offset_bias += rnn.parts_bias[p] * rnn.dhc;
            }
        }
    }
}

template <prop_kind_t aprop, data_type_t src_type, data_type_t weights_type,
        data_type_t acc_type>
rnn_bias_finalize_sig((_ref_rnn_common_t<aprop, src_type, weights_type,
        acc_type>::bias_finalize)) {
    if (rnn.is_unsigned_int8()) {
        float data_shift = pd()->attr()->rnn_data_qparams_.shift_;
        float data_scale = pd()->attr()->rnn_data_qparams_.scale_;
        float *weights_scales = pd()->attr()->rnn_weights_qparams_.scales_;
        bool scale_per_oc = pd()->attr()->rnn_weights_qparams_.mask_ != 0;
        for (int i = 0; i < rnn.n_layer * rnn.n_dir; i++)
            for (int j = 0; j < rnn.n_bias * rnn.dhc; j++) {
                size_t off = i * rnn.n_bias * rnn.dhc + j;
                float weights_scale
                        = scale_per_oc ? weights_scales[j] : weights_scales[0];
                scratch_bias_[off] -= (w_iter_comp[off] + w_layer_comp[off])
                        * data_shift / (weights_scale * data_scale);
            }
    }
}

template <prop_kind_t aprop, data_type_t src_type, data_type_t weights_type,
        data_type_t acc_type>
rnn_weights_assign_sig((_ref_rnn_common_t<aprop, src_type, weights_type,
        acc_type>::assign_packed_weights)) {
    assert(md->format_kind == format_kind::rnn_packed);
    const auto packed_desc = md->format_desc.rnn_packed_desc;
    AOC<weights_t *, 3> weights(
            weights_, rnn.n_layer, rnn.n_dir, packed_desc.n_parts);

    size_t offset_packed = 0;
    for (int l = 0; l < rnn.n_layer; l++)
        for (int d = 0; d < rnn.n_dir; d++) {
            for (int p = 0; p < packed_desc.n_parts; p++) {
                weights(l, d, p) = (weights_t *)&w_[offset_packed];
                offset_packed
                        += packed_desc.part_pack_size[p] / sizeof(weights_t);
            }
        }
}

template <prop_kind_t aprop, data_type_t src_type, data_type_t weights_type,
        data_type_t acc_type>
rnn_weights_assign_sig((_ref_rnn_common_t<aprop, src_type, weights_type,
        acc_type>::assign_weights)) {
    assert(md->format_kind == format_kind::blocked);
    const auto &blk = md->format_desc.blocking;
    /* Original set of weights provided by the user */
    AOC<const weights_t, 3> w(w_, rnn.n_layer, rnn.n_dir, (int)blk.strides[1]);
    /* Array of pointers for each part of weights */
    AOC<weights_t *, 3> weights(weights_, rnn.n_layer, rnn.n_dir, n_parts);

    for (int i = 0; i < rnn.n_layer; i++)
        for (int d = 0; d < rnn.n_dir; d++) {
            size_t offset_weights = 0;
            for (int p = 0; p < n_parts; p++) {
                weights(i, d, p) = (weights_t *)&w(i, d, offset_weights);
                offset_weights += gates_per_part[p] * blk.strides[3];
            }
        }
}

//********************* Execution function *********************//
template <prop_kind_t aprop, data_type_t src_type, data_type_t weights_type,
        data_type_t acc_type>
void _ref_rnn_common_t<aprop, src_type, weights_type, acc_type>::execute_(
        const exec_ctx_t &ctx) const {
    const rnn_conf_t &rnn = this->pd()->rnn_;
    auto src_layer = CTX_IN_MEM(const src_layer_t *, DNNL_ARG_SRC_LAYER);
    auto src_iter = CTX_IN_MEM(const char *, DNNL_ARG_SRC_ITER);
    auto src_iter_c = CTX_IN_MEM(const float *, DNNL_ARG_SRC_ITER_C);
    auto layer_weights_n_comp
            = CTX_IN_MEM(const char *, DNNL_ARG_WEIGHTS_LAYER);
    auto iter_weights_n_comp = CTX_IN_MEM(const char *, DNNL_ARG_WEIGHTS_ITER);
    auto weights_peephole
            = CTX_IN_MEM(const float *, DNNL_ARG_WEIGHTS_PEEPHOLE);
    auto projection_weights_n_comp
            = CTX_IN_MEM(const char *, DNNL_ARG_WEIGHTS_PROJECTION);
    auto bias = CTX_IN_MEM(const float *, DNNL_ARG_BIAS);

    auto dst_layer = rnn.is_fwd
            ? CTX_OUT_MEM(char *, DNNL_ARG_DST_LAYER)
            : const_cast<char *>(CTX_IN_MEM(const char *, DNNL_ARG_DST_LAYER));
    auto dst_iter = rnn.is_fwd
            ? CTX_OUT_MEM(char *, DNNL_ARG_DST_ITER)
            : const_cast<char *>(CTX_IN_MEM(const char *, DNNL_ARG_DST_ITER));
    auto dst_iter_c = rnn.is_fwd ? CTX_OUT_MEM(float *, DNNL_ARG_DST_ITER_C)
                                 : const_cast<float *>(CTX_IN_MEM(
                                         const float *, DNNL_ARG_DST_ITER_C));

    auto diff_dst_layer
            = CTX_IN_MEM(const gemm_acc_t *, DNNL_ARG_DIFF_DST_LAYER);
    auto diff_dst_iter = CTX_IN_MEM(const gemm_acc_t *, DNNL_ARG_DIFF_DST_ITER);
    auto diff_dst_iter_c = CTX_IN_MEM(const float *, DNNL_ARG_DIFF_DST_ITER_C);

    auto w_layer = reinterpret_cast<const weights_t *>(layer_weights_n_comp);
    auto w_iter = reinterpret_cast<const weights_t *>(iter_weights_n_comp);
    auto w_projection
            = reinterpret_cast<const weights_t *>(projection_weights_n_comp);
    auto w_layer_comp = reinterpret_cast<const float *>(
            layer_weights_n_comp + rnn.weights_layer_comp_offset);
    auto w_iter_comp = reinterpret_cast<const float *>(
            iter_weights_n_comp + rnn.weights_iter_comp_offset);
    auto w_projection_comp = reinterpret_cast<const float *>(
            projection_weights_n_comp + rnn.weights_projection_comp_offset);
    auto scratchpad = ctx.get_scratchpad_grantor();

    auto ptr_wei_layer
            = scratchpad.template get<weights_t *>(key_rnn_ptrs_wei_layer);
    auto ptr_wei_iter
            = scratchpad.template get<weights_t *>(key_rnn_ptrs_wei_iter);
    auto ptr_wei_projection
            = scratchpad.template get<weights_t *>(key_rnn_ptrs_wei_projection);
    auto ptr_bias = scratchpad.template get<float *>(key_rnn_ptrs_bia);
    // Here we use scratch_gates for the output of GEMMs on FWD and on input of GEMMs for BWD.
    // None of the values are kept for bwd
    auto scratch_gates = scratchpad.template get<scratch_t>(key_rnn_gates);
    auto scratch_ht = scratchpad.template get<ht_t>(key_rnn_ht);
    auto scratch_diff_ht = scratchpad.template get<gemm_acc_t>(key_rnn_diff_ht);
    auto scratch_cell = scratchpad.template get<scratch_t>(key_rnn_cell);

    gemm_acc_t *amx_scratchpad = nullptr;
#if DNNL_X64
    x64::brgemm_batch_element_t *addr_batch_global = nullptr;
    if (rnn.is_brgemm && (rnn.is_int8_amx() || rnn.is_bf16_amx())) {
        amx_scratchpad = scratchpad.template get<gemm_acc_t>(
                key_brgemm_primitive_buffer);
    }
    addr_batch_global = scratchpad.template get<x64::brgemm_batch_element_t>(
            key_brgemm_primitive_batch);
#endif
    // Fetching buffers from the workspace
    // if no workspace was provided we use the scratchpad
    char *scratch_ptr = scratchpad.template get<char>(key_rnn_space);
    char *ws_ptr = nullptr;
    if (rnn.use_workspace)
        ws_ptr = rnn.is_fwd ? CTX_OUT_MEM(char *, DNNL_ARG_WORKSPACE)
                            : const_cast<char *>(CTX_IN_MEM(
                                    const char *, DNNL_ARG_WORKSPACE));

    char *base_ptr = rnn.use_workspace ? ws_ptr : scratch_ptr;
    // ws_gates is only used to pass data from FWD to BWD.
    // assumption: in training, src_data_t and weights_t match
    gates_t *ws_gates = (gates_t *)(base_ptr + ws_gates_offset_);
    dst_iter_t *ws_ht = (dst_iter_t *)(base_ptr + ws_ht_offset_);
    src_layer_t *ws_states_layer
            = (src_layer_t *)(base_ptr + ws_states_layer_offset_);
    src_iter_t *ws_states_iter
            = (src_iter_t *)(base_ptr + ws_states_iter_offset_);
    float *ws_states_iter_c = (float *)(base_ptr + ws_states_iter_c_offset_);
    gemm_acc_t *ws_diff_states_layer
            = (gemm_acc_t *)(base_ptr + ws_diff_states_layer_offset_);
    gemm_acc_t *ws_diff_states_iter
            = (gemm_acc_t *)(base_ptr + ws_diff_states_iter_offset_);
    gemm_acc_t *ws_diff_states_iter_c
            = (gemm_acc_t *)(base_ptr + ws_diff_states_iter_c_offset_);
    gates_t *ws_grid = (gates_t *)(base_ptr + ws_grid_comp_offset_);

    auto diff_src_layer = CTX_OUT_MEM(gemm_acc_t *, DNNL_ARG_DIFF_SRC_LAYER);
    auto diff_src_iter = CTX_OUT_MEM(gemm_acc_t *, DNNL_ARG_DIFF_SRC_ITER);
    auto diff_src_iter_c = CTX_OUT_MEM(float *, DNNL_ARG_DIFF_SRC_ITER_C);

    auto diff_weights_layer
            = CTX_OUT_MEM(gemm_acc_t *, DNNL_ARG_DIFF_WEIGHTS_LAYER);
    auto diff_weights_iter
            = CTX_OUT_MEM(gemm_acc_t *, DNNL_ARG_DIFF_WEIGHTS_ITER);
    auto diff_weights_projection
            = CTX_OUT_MEM(float *, DNNL_ARG_DIFF_WEIGHTS_PROJECTION);
    auto diff_weights_peephole
            = CTX_OUT_MEM(float *, DNNL_ARG_DIFF_WEIGHTS_PEEPHOLE);
    auto diff_bias = CTX_OUT_MEM(float *, DNNL_ARG_DIFF_BIAS);

    // Fetching extra buffers from scratchpad
    float *ws_bias = (float *)(scratch_ptr + ws_bias_offset_);

    // initialize diff_states to 0
    if (aprop == prop_kind::backward) {
        // TODO: parallelize across layer, iter and iter_c
        auto zero_ws = [](int ithr, int nthr, gemm_acc_t *ws, size_t size) {
            size_t start = 0, end = 0;
            balance211(size, nthr, ithr, start, end);
            array_set(ws + start, 0.f, end - start);
        };
        parallel(0, [&](const int ithr, const int nthr) {
            zero_ws(ithr, nthr, ws_diff_states_layer,
                    rnn.ws_diff_states_layer_size / sizeof(gemm_acc_t));
            zero_ws(ithr, nthr, ws_diff_states_iter,
                    rnn.ws_diff_states_iter_size / sizeof(gemm_acc_t));
            if (this->pd()->cell_kind() == alg_kind::vanilla_lstm)
                zero_ws(ithr, nthr, ws_diff_states_iter_c,
                        rnn.ws_diff_states_iter_c_size / sizeof(gemm_acc_t));
        });
    }

    /* Pack(if using packed gemm API) or copy(if input arrays have bad leading
     * dimension */
    (this->*bias_preparation_func)(rnn, ptr_bias, bias, ws_bias);

    (this->*weights_iter_assign_func)(rnn, pd()->weights_md(1),
            rnn.n_parts_weights_iter, rnn.parts_weights_iter, ptr_wei_iter,
            w_iter);
    (this->*weights_layer_assign_func)(rnn, pd()->weights_md(0),
            rnn.n_parts_weights_layer, rnn.parts_weights_layer, ptr_wei_layer,
            w_layer);

    if (rnn.is_lstm_projection) {
        (this->*weights_projection_assign_func)(rnn,
                pd()->arg_md(DNNL_ARG_WEIGHTS_PROJECTION),
                rnn.n_parts_weights_projection, rnn.parts_weights_projection,
                ptr_wei_projection, w_projection);
    }

    (this->*bias_finalization_func)(rnn, ws_bias, w_iter_comp, w_layer_comp);

    // we first need to copy the initial states and input into ws
    if (!(rnn.skip_src_layer_copy() && rnn.is_fwd))
        copy_init_layer(rnn, ws_states_layer, ws_diff_states_layer, src_layer,
                diff_dst_layer);

    if (!(rnn.skip_src_iter_copy() && rnn.is_fwd)) {
        if (pd()->src_md(1)->data_type == data_type::f32)
            copy_init_iter(rnn, ws_states_iter, ws_states_iter_c,
                    ws_diff_states_iter, ws_diff_states_iter_c,
                    (const float *)src_iter, src_iter_c, diff_dst_iter,
                    diff_dst_iter_c);
        else
            copy_init_iter(rnn, ws_states_iter, ws_states_iter_c,
                    ws_diff_states_iter, ws_diff_states_iter_c,
                    (const src_iter_t *)src_iter, src_iter_c, diff_dst_iter,
                    diff_dst_iter_c);
    }

    // run the execution on the grid
    (this->*grid_computation)(
            rnn, ptr_wei_layer, ptr_wei_iter, ptr_wei_projection,
            weights_peephole, w_projection_comp, ptr_bias, src_layer,
            (const src_iter_t *)src_iter, src_iter_c, (dst_layer_t *)dst_layer,
            (dst_iter_t *)dst_iter, dst_iter_c, ws_states_layer, ws_states_iter,
            ws_states_iter_c, ws_diff_states_layer, ws_diff_states_iter,
            ws_diff_states_iter_c, ws_gates, ws_ht, ws_grid, scratch_gates,
            scratch_ht, scratch_diff_ht, scratch_cell, diff_weights_layer,
            diff_weights_iter, diff_weights_projection, diff_weights_peephole,
            diff_bias, amx_scratchpad
#if DNNL_X64
            ,
            addr_batch_global
#endif
    );

    // Finally we copy the results to the result buffers
    if (!(rnn.skip_dst_layer_copy() && rnn.is_fwd)) {
        if (pd()->dst_md(0)->data_type == data_type::f32)
            copy_res_layer(rnn, (float *)dst_layer, diff_src_layer, dst_iter,
                    ws_states_layer, ws_diff_states_layer);
        else
            copy_res_layer(rnn, (dst_layer_t *)dst_layer, diff_src_layer,
                    dst_iter, ws_states_layer, ws_diff_states_layer);
    }

    if (!(rnn.skip_dst_iter_copy() && rnn.is_fwd)) {
        if (pd()->dst_md(1)->data_type == data_type::f32)
            copy_res_iter(rnn, (float *)dst_iter, dst_iter_c, diff_src_iter,
                    diff_src_iter_c, dst_layer, ws_states_iter,
                    ws_states_iter_c, ws_diff_states_iter,
                    ws_diff_states_iter_c);
        else
            copy_res_iter(rnn, (dst_iter_t *)dst_iter, dst_iter_c,
                    diff_src_iter, diff_src_iter_c, dst_layer, ws_states_iter,
                    ws_states_iter_c, ws_diff_states_iter,
                    ws_diff_states_iter_c);
    }
};

/* Fix for MSVS warning C4661 */
template <>
rnn_cell_execution_sig(ref_rnn_fwd_f32_t::cell_execution_ref);
template <>
rnn_cell_execution_sig(ref_rnn_fwd_f32_t::cell_execution_brgemm);
template <>
rnn_cell_execution_sig(ref_rnn_fwd_f32_t::cell_execution_gru);
template <>
rnn_cell_execution_sig(ref_rnn_fwd_f32_t::cell_execution_gru_lbr);
template <>
rnn_cell_execution_sig(ref_rnn_bwd_f32_t::cell_execution_ref);
template <>
rnn_cell_execution_sig(ref_rnn_bwd_f32_t::cell_execution_brgemm);
template <>
rnn_cell_execution_sig(ref_rnn_bwd_f32_t::cell_execution_gru);
template <>
rnn_cell_execution_sig(ref_rnn_bwd_f32_t::cell_execution_gru_lbr);

template <>
rnn_cell_execution_sig(ref_rnn_fwd_bf16_t::cell_execution_ref);
template <>
rnn_cell_execution_sig(ref_rnn_fwd_bf16_t::cell_execution_brgemm);
template <>
rnn_cell_execution_sig(ref_rnn_fwd_bf16_t::cell_execution_gru);
template <>
rnn_cell_execution_sig(ref_rnn_fwd_bf16_t::cell_execution_gru_lbr);
template <>
rnn_cell_execution_sig(ref_rnn_bwd_bf16_t::cell_execution_ref);
template <>
rnn_cell_execution_sig(ref_rnn_bwd_bf16_t::cell_execution_brgemm);
template <>
rnn_cell_execution_sig(ref_rnn_bwd_bf16_t::cell_execution_gru);
template <>
rnn_cell_execution_sig(ref_rnn_bwd_bf16_t::cell_execution_gru_lbr);

template <>
rnn_cell_execution_sig(ref_rnn_fwd_u8s8_t::cell_execution_ref);
template <>
rnn_cell_execution_sig(ref_rnn_fwd_u8s8_t::cell_execution_brgemm);
template <>
rnn_cell_execution_sig(ref_rnn_fwd_u8s8_t::cell_execution_gru);
template <>
rnn_cell_execution_sig(ref_rnn_fwd_u8s8_t::cell_execution_gru_lbr);

template <>
rnn_cell_execution_sig(ref_rnn_fwd_s8s8_t::cell_execution_ref);
template <>
rnn_cell_execution_sig(ref_rnn_fwd_s8s8_t::cell_execution_brgemm);
template <>
rnn_cell_execution_sig(ref_rnn_fwd_s8s8_t::cell_execution_gru);
template <>
rnn_cell_execution_sig(ref_rnn_fwd_s8s8_t::cell_execution_gru_lbr);

template struct _ref_rnn_common_t<prop_kind::forward, data_type::f32,
        data_type::f32, data_type::f32>;
template struct _ref_rnn_common_t<prop_kind::backward, data_type::f32,
        data_type::f32, data_type::f32>;

template struct _ref_rnn_common_t<prop_kind::forward, data_type::bf16,
        data_type::bf16, data_type::f32>;
template struct _ref_rnn_common_t<prop_kind::backward, data_type::bf16,
        data_type::bf16, data_type::f32>;

template struct _ref_rnn_common_t<prop_kind::forward, data_type::u8,
        data_type::s8, data_type::s32>;
template struct _ref_rnn_common_t<prop_kind::forward, data_type::s8,
        data_type::s8, data_type::s32>;

#undef AOC

} // namespace cpu
} // namespace impl
} // namespace dnnl
",16381,True,3102.491746246929,median
"////////////////////////////////////////////////////////////////////////////////
/// DISCLAIMER
///
/// Copyright 2014-2016 ArangoDB GmbH, Cologne, Germany
/// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany
///
/// 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.
///
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
///
/// @author Dr. Frank Celler
////////////////////////////////////////////////////////////////////////////////

#include ""vocbase.h""

#include <velocypack/Builder.h>
#include <velocypack/Collection.h>
#include <velocypack/Parser.h>
#include <velocypack/velocypack-aliases.h>
#include <iostream>

#include ""ApplicationFeatures/ApplicationServer.h""
#include ""Aql/PlanCache.h""
#include ""Aql/QueryCache.h""
#include ""Aql/QueryList.h""
#include ""Basics/ConditionLocker.h""
#include ""Basics/Exceptions.h""
#include ""Basics/FileUtils.h""
#include ""Basics/HybridLogicalClock.h""
#include ""Basics/NumberUtils.h""
#include ""Basics/ReadLocker.h""
#include ""Basics/StaticStrings.h""
#include ""Basics/StringUtils.h""
#include ""Basics/VelocyPackHelper.h""
#include ""Basics/WriteLocker.h""
#include ""Basics/conversions.h""
#include ""Basics/files.h""
#include ""Basics/locks.h""
#include ""Basics/memory-map.h""
#include ""Basics/threads.h""
#include ""Basics/tri-strings.h""
#include ""Cluster/ClusterInfo.h""
#include ""Cluster/ServerState.h""
#include ""Logger/Logger.h""
#include ""Replication/DatabaseReplicationApplier.h""
#include ""Replication/utilities.h""
#include ""RestServer/DatabaseFeature.h""
#include ""StorageEngine/EngineSelectorFeature.h""
#include ""StorageEngine/PhysicalCollection.h""
#include ""StorageEngine/StorageEngine.h""
#include ""Utils/CollectionKeysRepository.h""
#include ""Utils/CursorRepository.h""
#include ""Utils/Events.h""
#include ""Utils/ExecContext.h""
#include ""Utils/VersionTracker.h""
#include ""V8Server/v8-user-structures.h""
#include ""VocBase/LogicalCollection.h""
#include ""VocBase/LogicalView.h""
#include ""VocBase/ticks.h""

#include <thread>

namespace {

  template<typename T>
  class RecursiveReadLocker {
   public:
    RecursiveReadLocker(
        T& mutex,
        std::atomic<std::thread::id>& owner,
        char const* file,
        int line
    ): _locker(&mutex, arangodb::basics::LockerType::TRY, true, file, line) {
      if (!_locker.isLocked() && owner.load() != std::this_thread::get_id()) {
        _locker.lock();
      }
    }

   private:
    arangodb::basics::ReadLocker<T> _locker;
  };

  template<typename T>
  class RecursiveWriteLocker {
   public:
    RecursiveWriteLocker(
        T& mutex,
        std::atomic<std::thread::id>& owner,
        arangodb::basics::LockerType type,
        bool aquire,
        char const* file,
        int line
    ): _locker(&mutex, type, false, file, line), _owner(owner), _update(noop) {
      if (aquire) {
        lock();
      }
    }

    ~RecursiveWriteLocker() {
      unlock();
    }

    bool isLocked() {
      return _locker.isLocked();
    }

    void lock() {
      // recursive locking of the same instance is not yet supported (create a new instance instead)
      TRI_ASSERT(_update != owned);

      if (std::this_thread::get_id() != _owner.load()) { // not recursive
        _locker.lock();
        _owner.store(std::this_thread::get_id());
        _update = owned;
      }
    }

    void unlock() {
      _update(*this);
    }

   private:
    arangodb::basics::WriteLocker<T> _locker;
    std::atomic<std::thread::id>& _owner;
    void (*_update)(RecursiveWriteLocker& locker);

    static void noop(RecursiveWriteLocker&) {}
    static void owned(RecursiveWriteLocker& locker) {
      static std::thread::id unowned;
      locker._owner.store(unowned);
      locker._locker.unlock();
      locker._update = noop;
    }
  };

  #define NAME__(name, line) name ## line
  #define NAME_EXPANDER__(name, line) NAME__(name, line)
  #define NAME(name) NAME_EXPANDER__(name, __LINE__)
  #define RECURSIVE_READ_LOCKER(lock, owner) RecursiveReadLocker<typename std::decay<decltype (lock)>::type> NAME(RecursiveLocker)(lock, owner, __FILE__, __LINE__)
  #define RECURSIVE_WRITE_LOCKER_NAMED(name, lock, owner, aquire) RecursiveWriteLocker<typename std::decay<decltype (lock)>::type> name(lock, owner, arangodb::basics::LockerType::BLOCKING, aquire, __FILE__, __LINE__)
  #define RECURSIVE_WRITE_LOCKER(lock, owner) RECURSIVE_WRITE_LOCKER_NAMED(NAME(RecursiveLocker), lock, owner, true)

}

using namespace arangodb;
using namespace arangodb::basics;

/// @brief increase the reference counter for a database
bool TRI_vocbase_t::use() {
  auto expected = _refCount.load(std::memory_order_relaxed);
  while (true) {
    if ((expected & 1) != 0) {
      // deleted bit is set
      return false;
    }
    // increase the reference counter by 2.
    // this is because we use odd values to indicate that the database has been
    // marked as deleted
    auto updated = expected + 2;
    TRI_ASSERT((updated & 1) == 0);
    if (_refCount.compare_exchange_weak(expected, updated,
                                        std::memory_order_release,
                                        std::memory_order_relaxed)) {
      // compare-exchange worked. we're done
      return true;
    }
    // compare-exchange failed. try again!
    expected = _refCount.load(std::memory_order_relaxed);
  }
}

void TRI_vocbase_t::forceUse() { _refCount += 2; }

/// @brief decrease the reference counter for a database
void TRI_vocbase_t::release() {
  // decrease the reference counter by 2.
  // this is because we use odd values to indicate that the database has been
  // marked as deleted
  auto oldValue = _refCount.fetch_sub(2);
  TRI_ASSERT(oldValue >= 2);
}

/// @brief returns whether the database can be dropped
bool TRI_vocbase_t::isDangling() const {
  if (isSystem()) {
    return false;
  }
  auto refCount = _refCount.load();
  // we are intentionally comparing with exactly 1 here, because a 1 means
  // that noone else references the database but it has been marked as deleted
  return (refCount == 1);
}

/// @brief whether or not the vocbase has been marked as deleted
bool TRI_vocbase_t::isDropped() const {
  auto refCount = _refCount.load();
  // if the stored value is odd, it means the database has been marked as
  // deleted
  return (refCount % 2 == 1);
}

/// @brief marks a database as deleted
bool TRI_vocbase_t::markAsDropped() {
  TRI_ASSERT(!isSystem());

  auto oldValue = _refCount.fetch_or(1);
  // if the previously stored value is odd, it means the database has already
  // been marked as deleted
  return (oldValue % 2 == 0);
}

/// @brief signal the cleanup thread to wake up
void TRI_vocbase_t::signalCleanup() {
  StorageEngine* engine = EngineSelectorFeature::ENGINE;

  engine->signalCleanup(*this);
}

void TRI_vocbase_t::checkCollectionInvariants() const {
  TRI_ASSERT(_dataSourceByName.size() == _dataSourceById.size());
  TRI_ASSERT(_dataSourceByUuid.size() == _dataSourceById.size());
}

/// @brief adds a new collection
/// caller must hold _dataSourceLock in write mode or set doLock
void TRI_vocbase_t::registerCollection(
    bool doLock,
    std::shared_ptr<arangodb::LogicalCollection> const& collection
) {
  std::string name = collection->name();
  TRI_voc_cid_t cid = collection->id();
  {
    RECURSIVE_WRITE_LOCKER_NAMED(writeLocker, _dataSourceLock, _dataSourceLockWriteOwner, doLock);

    checkCollectionInvariants();
    TRI_DEFER(checkCollectionInvariants());

    // check name
    auto it = _dataSourceByName.emplace(name, collection);

    if (!it.second) {
      std::string msg;
      msg.append(std::string(""duplicate entry for collection name '"") + name + ""'. collection id "" + std::to_string(cid) + "" has same name as already added collection "" + std::to_string(_dataSourceByName[name]->id()));
      LOG_TOPIC(ERR, arangodb::Logger::FIXME) << msg;

      THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_ARANGO_DUPLICATE_NAME, msg);
    }

    // check collection identifier
    try {
      auto it2 = _dataSourceById.emplace(cid, collection);

      if (!it2.second) {
        std::string msg;
        msg.append(std::string(""duplicate collection identifier "") + std::to_string(collection->id()) + "" for name '"" + name + ""'"");
        LOG_TOPIC(ERR, arangodb::Logger::FIXME) << msg;

        THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_ARANGO_DUPLICATE_IDENTIFIER, msg);
      }
    } catch (...) {
      _dataSourceByName.erase(name);
      throw;
    }

    try {
      auto it2 = _dataSourceByUuid.emplace(collection->guid(), collection);

      if (!it2.second) {
        std::string msg;
        msg.append(std::string(""duplicate entry for collection uuid '"") + collection->guid() + ""'"");
        LOG_TOPIC(ERR, arangodb::Logger::FIXME) << msg;

        THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_ARANGO_DUPLICATE_IDENTIFIER, msg);
      }
    } catch (...) {
      _dataSourceByName.erase(name);
      _dataSourceById.erase(cid);
      throw;
    }

    try {
      _collections.emplace_back(collection);
    } catch (...) {
      _dataSourceByName.erase(name);
      _dataSourceById.erase(cid);
      _dataSourceByUuid.erase(collection->guid());
      throw;
    }

    collection->setStatus(TRI_VOC_COL_STATUS_UNLOADED);
  }
}

/// @brief removes a collection name from the global list of collections
/// This function is called when a collection is dropped.
/// NOTE: You need a writelock on _dataSourceLock
bool TRI_vocbase_t::unregisterCollection(
    arangodb::LogicalCollection* collection) {
  TRI_ASSERT(collection != nullptr);

  // pre-condition
  checkCollectionInvariants();

  auto itr = _dataSourceById.find(collection->id());

  if (itr == _dataSourceById.end()
      || itr->second->category() != LogicalCollection::category()) {
    return true; // no such collection
  }

  TRI_ASSERT(std::dynamic_pointer_cast<arangodb::LogicalCollection>(itr->second));

  // only if we find the collection by its id, we can delete it by name
  _dataSourceById.erase(itr);

    // this is because someone else might have created a new collection with the
    // same name, but with a different id
  _dataSourceByName.erase(collection->name());
  _dataSourceByUuid.erase(collection->guid());

  // post-condition
  checkCollectionInvariants();

  return true;
}

/// @brief adds a new view
/// caller must hold _viewLock in write mode or set doLock
void TRI_vocbase_t::registerView(
    bool doLock,
    std::shared_ptr<arangodb::LogicalView> const& view
) {
  TRI_ASSERT(false == !view);
  auto& name = view->name();
  auto id = view->id();

  {
    RECURSIVE_WRITE_LOCKER_NAMED(writeLocker, _dataSourceLock, _dataSourceLockWriteOwner, doLock);

    // check name
    auto it = _dataSourceByName.emplace(name, view);

    if (!it.second) {
      LOG_TOPIC(ERR, arangodb::Logger::FIXME)
          << ""duplicate entry for view name '"" << name << ""'"";
      LOG_TOPIC(ERR, arangodb::Logger::FIXME)
          << ""view id "" << id << "" has same name as already added view ""
          << _dataSourceByName[name]->id();

      THROW_ARANGO_EXCEPTION(TRI_ERROR_ARANGO_DUPLICATE_NAME);
    }

    // check id
    try {
      auto it2 = _dataSourceById.emplace(id, view);

      if (!it2.second) {
        _dataSourceByName.erase(name);

        LOG_TOPIC(ERR, arangodb::Logger::FIXME)
            << ""duplicate view identifier '"" << view->id() << ""' for name '""
            << name << ""'"";

        THROW_ARANGO_EXCEPTION(TRI_ERROR_ARANGO_DUPLICATE_IDENTIFIER);
      }
    } catch (...) {
      _dataSourceByName.erase(name);
      throw;
    }

    try {
      auto it2 = _dataSourceByUuid.emplace(view->guid(), view);

      if (!it2.second) {
        LOG_TOPIC(ERR, arangodb::Logger::FIXME)
          << ""duplicate view globally-unique identifier '"" << view->guid() << ""' for name '"" << name << ""'"";

        THROW_ARANGO_EXCEPTION(TRI_ERROR_ARANGO_DUPLICATE_IDENTIFIER);
      }
    } catch (...) {
      _dataSourceByName.erase(name);
      _dataSourceById.erase(id);
      throw;
    }

    checkCollectionInvariants();
  }
}

/// @brief removes a views name from the global list of views
/// This function is called when a view is dropped.
/// NOTE: You need a writelock on _dataSourceLock
bool TRI_vocbase_t::unregisterView(arangodb::LogicalView const& view) {
  // pre-condition
  checkCollectionInvariants();

  auto itr = _dataSourceById.find(view.id());

  if (itr == _dataSourceById.end()
      || itr->second->category() != arangodb::LogicalView::category()) {
    return true; // no such view
  }

  TRI_ASSERT(std::dynamic_pointer_cast<arangodb::LogicalView>(itr->second));

  // only if we find the collection by its id, we can delete it by name
  _dataSourceById.erase(itr);

    // this is because someone else might have created a new view with the
    // same name, but with a different id
  _dataSourceByName.erase(view.name());
  _dataSourceByUuid.erase(view.guid());

  // post-condition
  checkCollectionInvariants();

  return true;
}

/// @brief drops a collection
/*static */ bool TRI_vocbase_t::DropCollectionCallback(
    arangodb::LogicalCollection* collection) {
  std::string const name(collection->name());

  {
    WRITE_LOCKER_EVENTUAL(statusLock, collection->_lock);

    if (collection->status() != TRI_VOC_COL_STATUS_DELETED) {
      LOG_TOPIC(ERR, arangodb::Logger::FIXME)
          << ""someone resurrected the collection '"" << name << ""'"";
      return false;
    }
  }  // release status lock

  // remove from list of collections
  auto& vocbase = collection->vocbase();

  {
    RECURSIVE_WRITE_LOCKER(vocbase._dataSourceLock, vocbase._dataSourceLockWriteOwner);
    auto it = vocbase._collections.begin();

    for (auto end = vocbase._collections.end(); it != end; ++it) {
      if (it->get() == collection) {
        break;
      }
    }

    if (it != vocbase._collections.end()) {
      auto col = *it;

      vocbase._collections.erase(it);

      // we need to clean up the pointers later so we insert it into this vector
      try {
        vocbase._deadCollections.emplace_back(col);
      } catch (...) {
      }
    }
  }

  collection->drop();

  return true;
}

/// @brief creates a new collection, worker function
std::shared_ptr<arangodb::LogicalCollection> TRI_vocbase_t::createCollectionWorker(
    VPackSlice parameters) {
  std::string name = arangodb::basics::VelocyPackHelper::getStringValue(
      parameters, ""name"", """");
  TRI_ASSERT(!name.empty());

  // Try to create a new collection. This is not registered yet

  auto collection =
    std::make_shared<arangodb::LogicalCollection>(*this, parameters, false);
  TRI_ASSERT(collection != nullptr);

  RECURSIVE_WRITE_LOCKER(_dataSourceLock, _dataSourceLockWriteOwner);

  // reserve room for the new collection
  _collections.reserve(_collections.size() + 1);
  _deadCollections.reserve(_deadCollections.size() + 1);

  auto it = _dataSourceByName.find(name);

  if (it != _dataSourceByName.end()) {
    events::CreateCollection(name, TRI_ERROR_ARANGO_DUPLICATE_NAME);
    THROW_ARANGO_EXCEPTION(TRI_ERROR_ARANGO_DUPLICATE_NAME);
  }

  registerCollection(basics::ConditionalLocking::DoNotLock, collection);

  try {
    collection->setStatus(TRI_VOC_COL_STATUS_LOADED);
    // set collection version to 3.1, as the collection is just created
    collection->setVersion(LogicalCollection::VERSION_31);

    // Let's try to persist it.
    collection->persistPhysicalCollection();

    events::CreateCollection(name, TRI_ERROR_NO_ERROR);

    return collection;
  } catch (...) {
    unregisterCollection(collection.get());
    throw;
  }
}

/// @brief loads an existing collection
/// Note that this will READ lock the collection. You have to release the
/// collection lock by yourself.
int TRI_vocbase_t::loadCollection(arangodb::LogicalCollection* collection,
                                  TRI_vocbase_col_status_e& status,
                                  bool setStatus) {
  TRI_ASSERT(collection->id() != 0);

  // read lock
  // check if the collection is already loaded
  {
    ExecContext const* exec = ExecContext::CURRENT;
    if (exec != nullptr &&
        !exec->canUseCollection(_name, collection->name(), auth::Level::RO)) {
      return TRI_set_errno(TRI_ERROR_FORBIDDEN);
    }


    READ_LOCKER_EVENTUAL(locker, collection->_lock);

    // return original status to the caller
    if (setStatus) {
      status = collection->status();
    }

    if (collection->status() == TRI_VOC_COL_STATUS_LOADED) {
      // DO NOT release the lock
      locker.steal();
      return TRI_ERROR_NO_ERROR;
    }

    if (collection->status() == TRI_VOC_COL_STATUS_DELETED) {
      return TRI_set_errno(TRI_ERROR_ARANGO_DATA_SOURCE_NOT_FOUND);
    }

    if (collection->status() == TRI_VOC_COL_STATUS_CORRUPTED) {
      return TRI_set_errno(TRI_ERROR_ARANGO_CORRUPTED_COLLECTION);
    }
  }
  // release the read lock and acquire a write lock, we have to do some work

  // .............................................................................
  // write lock
  // .............................................................................

  WRITE_LOCKER_EVENTUAL(locker, collection->_lock);

  // someone else loaded the collection, release the WRITE lock and try again
  if (collection->status() == TRI_VOC_COL_STATUS_LOADED) {
    locker.unlock();
    return loadCollection(collection, status, false);
  }

  // someone is trying to unload the collection, cancel this,
  // release the WRITE lock and try again
  if (collection->status() == TRI_VOC_COL_STATUS_UNLOADING) {
    // check if the collection is dropped
    if (collection->deleted()) {
      // drop call going on, we must abort
      locker.unlock();

      // someone requested the collection to be dropped, so it's not there
      // anymore
      return TRI_set_errno(TRI_ERROR_ARANGO_DATA_SOURCE_NOT_FOUND);
    }

    // no drop action found, go on
    collection->setStatus(TRI_VOC_COL_STATUS_LOADED);
    locker.unlock();

    return loadCollection(collection, status, false);
  }

  // deleted, give up
  if (collection->status() == TRI_VOC_COL_STATUS_DELETED) {
    return TRI_set_errno(TRI_ERROR_ARANGO_DATA_SOURCE_NOT_FOUND);
  }

  // corrupted, give up
  if (collection->status() == TRI_VOC_COL_STATUS_CORRUPTED) {
    return TRI_set_errno(TRI_ERROR_ARANGO_CORRUPTED_COLLECTION);
  }

  // currently loading
  if (collection->status() == TRI_VOC_COL_STATUS_LOADING) {
    locker.unlock();

    // loop until the status changes
    while (true) {
      TRI_vocbase_col_status_e status;
      {
        READ_LOCKER_EVENTUAL(readLocker, collection->_lock);
        status = collection->status();
      }

      if (status != TRI_VOC_COL_STATUS_LOADING) {
        break;
      }

      // only throw this particular error if the server is configured to do so
      auto databaseFeature =
          application_features::ApplicationServer::getFeature<DatabaseFeature>(
              ""Database"");
      if (databaseFeature->throwCollectionNotLoadedError()) {
        return TRI_ERROR_ARANGO_COLLECTION_NOT_LOADED;
      }

      std::this_thread::sleep_for(std::chrono::microseconds(collectionStatusPollInterval()));
    }

    return loadCollection(collection, status, false);
  }

  // unloaded, load collection
  if (collection->status() == TRI_VOC_COL_STATUS_UNLOADED) {
    // set the status to loading
    collection->setStatus(TRI_VOC_COL_STATUS_LOADING);

    // release the lock on the collection temporarily
    // this will allow other threads to check the collection's
    // status while it is loading (loading may take a long time because of
    // disk activity, index creation etc.)
    locker.unlock();

    bool ignoreDatafileErrors = false;
    if (DatabaseFeature::DATABASE != nullptr) {
      ignoreDatafileErrors = DatabaseFeature::DATABASE->ignoreDatafileErrors();
    }

    try {
      collection->open(ignoreDatafileErrors);
    } catch (arangodb::basics::Exception const& ex) {
      LOG_TOPIC(ERR, arangodb::Logger::FIXME)
          << ""caught exception while opening collection '"" << collection->name()
          << ""': "" << ex.what();
      collection->setStatus(TRI_VOC_COL_STATUS_CORRUPTED);
      return TRI_ERROR_ARANGO_CORRUPTED_COLLECTION;
    } catch (std::exception const& ex) {
      LOG_TOPIC(ERR, arangodb::Logger::FIXME)
          << ""caught exception while opening collection '"" << collection->name()
          << ""': "" << ex.what();
      collection->setStatus(TRI_VOC_COL_STATUS_CORRUPTED);
      return TRI_ERROR_ARANGO_CORRUPTED_COLLECTION;
    } catch (...) {
      LOG_TOPIC(ERR, arangodb::Logger::FIXME)
          << ""caught unknown exception while opening collection '""
          << collection->name() << ""'"";
      collection->setStatus(TRI_VOC_COL_STATUS_CORRUPTED);
      return TRI_ERROR_ARANGO_CORRUPTED_COLLECTION;
    }

    // lock again to adjust the status
    locker.lockEventual();

    // no one else must have changed the status
    TRI_ASSERT(collection->status() == TRI_VOC_COL_STATUS_LOADING);

    collection->setStatus(TRI_VOC_COL_STATUS_LOADED);
    collection->load();

    // release the WRITE lock and try again
    locker.unlock();

    return loadCollection(collection, status, false);
  }

  std::string const colName(collection->name());
  LOG_TOPIC(ERR, arangodb::Logger::FIXME)
      << ""unknown collection status "" << collection->status() << "" for '""
      << colName << ""'"";

  return TRI_set_errno(TRI_ERROR_INTERNAL);
}

/// @brief drops a collection, worker function
int TRI_vocbase_t::dropCollectionWorker(arangodb::LogicalCollection* collection,
                                        DropState& state, double timeout) {
  state = DROP_EXIT;
  std::string const colName(collection->name());

  double startTime = TRI_microtime();

  // do not acquire these locks instantly
  RECURSIVE_WRITE_LOCKER_NAMED(
    writeLocker,
    _dataSourceLock,
    _dataSourceLockWriteOwner,
    basics::ConditionalLocking::DoNotLock
  );
  CONDITIONAL_WRITE_LOCKER(locker, collection->_lock,
                           basics::ConditionalLocking::DoNotLock);

  while (true) {
    TRI_ASSERT(!writeLocker.isLocked());
    TRI_ASSERT(!locker.isLocked());

    // block until we have acquired this lock
    writeLocker.lock();
    // we now have the one lock

    TRI_ASSERT(writeLocker.isLocked());

    if (locker.tryLock()) {
      // we now have both locks and can continue outside of this loop
      break;
    }

    // unlock the write locker so we don't block other operations
    writeLocker.unlock();

    TRI_ASSERT(!writeLocker.isLocked());
    TRI_ASSERT(!locker.isLocked());

    if (timeout >= 0.0 && TRI_microtime() > startTime + timeout) {
      events::DropCollection(colName, TRI_ERROR_LOCK_TIMEOUT);
      return TRI_ERROR_LOCK_TIMEOUT;
    }

    // sleep for a while
    std::this_thread::yield();
    std::this_thread::sleep_for(std::chrono::microseconds(10000));
  }

  TRI_ASSERT(writeLocker.isLocked());
  TRI_ASSERT(locker.isLocked());

#if USE_PLAN_CACHE
  arangodb::aql::PlanCache::instance()->invalidate(this);
#endif
  arangodb::aql::QueryCache::instance()->invalidate(this);

  switch (collection->status()) {
    case TRI_VOC_COL_STATUS_DELETED: {
      // collection already deleted
      // mark collection as deleted
      unregisterCollection(collection);
      break;
    }
    case TRI_VOC_COL_STATUS_LOADING: {
      // collection is loading
      // loop until status changes
      // try again later
      state = DROP_AGAIN;
      break;
    }
    case TRI_VOC_COL_STATUS_UNLOADED: {
      // collection is unloaded
      StorageEngine* engine = EngineSelectorFeature::ENGINE;
      bool doSync =
          !engine->inRecovery() &&
          application_features::ApplicationServer::getFeature<DatabaseFeature>(
              ""Database"")
              ->forceSyncProperties();

      if (!collection->deleted()) {
        collection->deleted(true);

        try {
          engine->changeCollection(
            *this, collection->id(), *collection, doSync
          );
        } catch (arangodb::basics::Exception const& ex) {
          collection->deleted(false);
          events::DropCollection(colName, ex.code());
          return ex.code();
        } catch (std::exception const&) {
          collection->deleted(false);
          events::DropCollection(colName, TRI_ERROR_INTERNAL);
          return TRI_ERROR_INTERNAL;
        }
      }

      collection->setStatus(TRI_VOC_COL_STATUS_DELETED);
      unregisterCollection(collection);

      locker.unlock();

      writeLocker.unlock();

      TRI_ASSERT(engine != nullptr);
      engine->dropCollection(*this, *collection);

      DropCollectionCallback(collection);
      break;
    }
    case TRI_VOC_COL_STATUS_LOADED:
    case TRI_VOC_COL_STATUS_UNLOADING: {
      // collection is loaded
      collection->deleted(true);

      StorageEngine* engine = EngineSelectorFeature::ENGINE;
      bool doSync =
          !engine->inRecovery() &&
          application_features::ApplicationServer::getFeature<DatabaseFeature>(
              ""Database"")
              ->forceSyncProperties();

      VPackBuilder builder;
      engine->getCollectionInfo(*this, collection->id(), builder, false, 0);
      arangodb::Result res = collection->updateProperties(
          builder.slice().get(""parameters""), doSync);

      if (!res.ok()) {
        return res.errorNumber();
      }

      collection->setStatus(TRI_VOC_COL_STATUS_DELETED);
      unregisterCollection(collection);

      locker.unlock();
      writeLocker.unlock();

      engine->dropCollection(*this, *collection);
      state = DROP_PERFORM;
      break;
    }
    default: {
      // unknown status
      events::DropCollection(colName, TRI_ERROR_INTERNAL);
      return TRI_ERROR_INTERNAL;
    }
  }
  events::DropCollection(colName, TRI_ERROR_NO_ERROR);
  return TRI_ERROR_NO_ERROR;
}

/// @brief closes a database and all collections
void TRI_vocbase_t::shutdown() {
  // stop replication
  if (_replicationApplier != nullptr) {
    _replicationApplier->stopAndJoin();
  }

  // mark all cursors as deleted so underlying collections can be freed soon
  _cursorRepository->garbageCollect(true);

  // mark all collection keys as deleted so underlying collections can be freed
  // soon
  _collectionKeys->garbageCollect(true);

  std::vector<std::shared_ptr<arangodb::LogicalCollection>> collections;

  {
    RECURSIVE_READ_LOCKER(_dataSourceLock, _dataSourceLockWriteOwner);
    collections = _collections;
  }

  // from here on, the vocbase is unusable, i.e. no collections can be
  // created/loaded etc.

  // starts unloading of collections
  for (auto& collection : collections) {
    collection->close(); // required to release indexes
    unloadCollection(collection.get(), true);
  }

  // this will signal the compactor thread to do one last iteration
  setState(TRI_vocbase_t::State::SHUTDOWN_COMPACTOR);

  StorageEngine* engine = EngineSelectorFeature::ENGINE;

  engine->shutdownDatabase(*this); // shutdownDatabase() stops all threads

  // this will signal the cleanup thread to do one last iteration
  setState(TRI_vocbase_t::State::SHUTDOWN_CLEANUP);

  {
    RECURSIVE_WRITE_LOCKER(_dataSourceLock, _dataSourceLockWriteOwner);

    checkCollectionInvariants();
    _dataSourceByName.clear();
    _dataSourceById.clear();
    _dataSourceByUuid.clear();
    checkCollectionInvariants();
  }

  _deadCollections.clear();

  // free collections
  for (auto& collection : _collections) {
    collection->getPhysical()->close();
  }

  _collections.clear();
}

/// @brief returns names of all known (document) collections
std::vector<std::string> TRI_vocbase_t::collectionNames() {
  std::vector<std::string> result;

  RECURSIVE_READ_LOCKER(_dataSourceLock, _dataSourceLockWriteOwner);

  result.reserve(_dataSourceByName.size());

  for (auto& entry: _dataSourceByName) {
      TRI_ASSERT(entry.second);

      if (entry.second->category() != LogicalCollection::category()) {
        continue;
      }

#ifdef ARANGODB_ENABLE_MAINTAINER_MODE
      auto view = std::dynamic_pointer_cast<arangodb::LogicalCollection>(entry.second);
      TRI_ASSERT(view);
#else
      auto view = std::static_pointer_cast<arangodb::LogicalCollection>(entry.second);
#endif

      result.emplace_back(entry.first);
  }

  return result;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief returns all known (document) collections with their parameters
/// and indexes, up to a specific tick value
/// while the collections are iterated over, there will be a global lock so
/// that there will be consistent view of collections & their properties
/// The list of collections will be sorted if sort function is given
////////////////////////////////////////////////////////////////////////////////

void TRI_vocbase_t::inventory(
    VPackBuilder& result,
    TRI_voc_tick_t maxTick, std::function<bool(arangodb::LogicalCollection const*)> const& nameFilter) {
  TRI_ASSERT(result.isOpenObject());

  // cycle on write-lock
  WRITE_LOCKER_EVENTUAL(writeLock, _inventoryLock);

  std::vector<std::shared_ptr<arangodb::LogicalCollection>> collections;
  std::unordered_map<TRI_voc_cid_t, std::shared_ptr<LogicalDataSource>> dataSourceById;

  // copy collection pointers into vector so we can work with the copy without
  // the global lock
  {
    RECURSIVE_READ_LOCKER(_dataSourceLock, _dataSourceLockWriteOwner);
    collections = _collections;
    dataSourceById = _dataSourceById;
  }

  if (collections.size() > 1) {
    // sort by type first and then only name
    // sorting by type ensures that document collections are reported before edge collections
    std::sort(
      collections.begin(),
      collections.end(),
      [](
        std::shared_ptr<LogicalCollection> const& lhs,
        std::shared_ptr<LogicalCollection> const& rhs
      )->bool {
      if (lhs->type() != rhs->type()) {
        return lhs->type() < rhs->type();
      }

      return lhs->name() < rhs->name();
    });
  }

  ExecContext const* exec = ExecContext::CURRENT;
  result.add(""collections"", VPackValue(VPackValueType::Array));
  for (auto& collection : collections) {
    READ_LOCKER(readLocker, collection->_lock);

    if (collection->status() == TRI_VOC_COL_STATUS_DELETED ||
        collection->status() == TRI_VOC_COL_STATUS_CORRUPTED) {
      // we do not need to care about deleted or corrupted collections
      continue;
    }

    // In cluster case cids are not created by ticks but by cluster uniqIds
    if (!ServerState::instance()->isRunningInCluster() &&
        collection->id() > maxTick) {
      // collection is too new
      continue;
    }

    // check if we want this collection
    if (!nameFilter(collection.get())) {
      continue;
    }

    if (exec != nullptr &&
        !exec->canUseCollection(_name, collection->name(), auth::Level::RO)) {
      continue;
    }

    if (collection->id() <= maxTick) {
      result.openObject();

      result.add(VPackValue(""indexes""));
      collection->getIndexesVPack(result, false, false, [](arangodb::Index const* idx) {
        // we have to exclude the primary and the edge index here, because otherwise
        // at least the MMFiles engine will try to create it
        return (idx->type() != arangodb::Index::TRI_IDX_TYPE_PRIMARY_INDEX &&
                idx->type() != arangodb::Index::TRI_IDX_TYPE_EDGE_INDEX);
      });
      result.add(""parameters"", VPackValue(VPackValueType::Object));
      collection->toVelocyPackIgnore(result, { ""objectId"", ""path"", ""statusString"" }, true, false);
      result.close();

      result.close();
    }
  }
  result.close(); // </collection>
  
  result.add(""views"", VPackValue(VPackValueType::Array, true));
  for (auto const& dataSource : dataSourceById) {
    if (dataSource.second->category() != LogicalView::category()) {
      continue;
    }
    LogicalView const* view = static_cast<LogicalView*>(dataSource.second.get());
    result.openObject();
    view->toVelocyPack(result, /*details*/false, /*forPersistence*/true);
    result.close();
  }
  result.close(); // </views>
}

/// @brief looks up a collection by identifier
std::shared_ptr<arangodb::LogicalCollection> TRI_vocbase_t::lookupCollection(
    TRI_voc_cid_t id
) const noexcept {
  #ifdef ARANGODB_ENABLE_MAINTAINER_MODE
    return std::dynamic_pointer_cast<arangodb::LogicalCollection>(
      lookupDataSource(id)
    );
  #else
    auto dataSource = lookupDataSource(id);

    return dataSource && dataSource->category() == LogicalCollection::category()
      ? std::static_pointer_cast<LogicalCollection>(dataSource) : nullptr;
  #endif
}

/// @brief looks up a collection by name or stringified cid or uuid
std::shared_ptr<arangodb::LogicalCollection> TRI_vocbase_t::lookupCollection(
    std::string const& nameOrId
) const noexcept {
  #ifdef ARANGODB_ENABLE_MAINTAINER_MODE
    return std::dynamic_pointer_cast<arangodb::LogicalCollection>(
      lookupDataSource(nameOrId)
    );
  #else
    auto dataSource = lookupDataSource(nameOrId);

    return dataSource && dataSource->category() == LogicalCollection::category()
      ? std::static_pointer_cast<LogicalCollection>(dataSource) : nullptr;
  #endif
}

/// @brief looks up a collection by uuid
std::shared_ptr<arangodb::LogicalCollection> TRI_vocbase_t::lookupCollectionByUuid(
    std::string const& uuid
) const noexcept {
  // otherwise we'll look up the collection by name
  RECURSIVE_READ_LOCKER(_dataSourceLock, _dataSourceLockWriteOwner);
  auto itr = _dataSourceByUuid.find(uuid);

  #ifdef ARANGODB_ENABLE_MAINTAINER_MODE
    return itr == _dataSourceByUuid.end()
      ? nullptr
      : std::dynamic_pointer_cast<arangodb::LogicalCollection>(itr->second)
      ;
  #else
    return itr == _dataSourceByUuid.end()
           || itr->second->category() != LogicalCollection::category()
      ? nullptr
      : std::static_pointer_cast<LogicalCollection>(itr->second)
      ;
  #endif
}

/// @brief looks up a data-source by identifier
std::shared_ptr<arangodb::LogicalDataSource> TRI_vocbase_t::lookupDataSource(
    TRI_voc_cid_t id
) const noexcept {
  RECURSIVE_READ_LOCKER(_dataSourceLock, _dataSourceLockWriteOwner);
  auto itr = _dataSourceById.find(id);

  return itr == _dataSourceById.end() ? nullptr : itr->second;
}

/// @brief looks up a data-source by name
std::shared_ptr<arangodb::LogicalDataSource> TRI_vocbase_t::lookupDataSource(
    std::string const& nameOrId
) const noexcept {
  if (nameOrId.empty()) {
    return nullptr;
  }

  // lookup by id if the data-source name is passed as a stringified id
  bool success = false;
  auto id = arangodb::NumberUtils::atoi<TRI_voc_cid_t>(
    nameOrId.data(), nameOrId.data() + nameOrId.size(), success
  );

  if (success) {
    return lookupDataSource(id);
  }

  RECURSIVE_READ_LOCKER(_dataSourceLock, _dataSourceLockWriteOwner);

  // otherwise look up the data-source by name
  auto itr = _dataSourceByName.find(nameOrId);

  if (itr != _dataSourceByName.end()) {
    return itr->second;
  }

  // otherwise look up the data-source by UUID
  auto itrUuid = _dataSourceByUuid.find(nameOrId);

  return itrUuid == _dataSourceByUuid.end() ? nullptr : itrUuid->second;
}

/// @brief looks up a view by identifier
std::shared_ptr<arangodb::LogicalView> TRI_vocbase_t::lookupView(
  TRI_voc_cid_t id
) const {
  if (ServerState::instance()->isCoordinator()) {
    std::string const viewId = StringUtils::itoa(id);
    return ClusterInfo::instance()->getView(name(), viewId);
  }

  #ifdef ARANGODB_ENABLE_MAINTAINER_MODE
    return std::dynamic_pointer_cast<arangodb::LogicalView>(
      lookupDataSource(id)
    );
  #else
    auto dataSource = lookupDataSource(id);

    return dataSource && dataSource->category() == LogicalView::category()
      ? std::static_pointer_cast<LogicalView>(dataSource) : nullptr;
  #endif
}

/// @brief looks up a view by name or stringified cid or uuid
std::shared_ptr<arangodb::LogicalView> TRI_vocbase_t::lookupView(
  std::string const& nameOrId
) const {
  if (ServerState::instance()->isCoordinator()) {
    return ClusterInfo::instance()->getView(name(), nameOrId);
  }

  #ifdef ARANGODB_ENABLE_MAINTAINER_MODE
    return std::dynamic_pointer_cast<arangodb::LogicalView>(
      lookupDataSource(nameOrId)
    );
  #else
    auto dataSource = lookupDataSource(nameOrId);

    return dataSource && dataSource->category() == LogicalView::category()
      ? std::static_pointer_cast<LogicalView>(dataSource) : nullptr;
  #endif
}

/// @brief creates a new collection from parameter set
/// collection id (cid) is normally passed with a value of 0
/// this means that the system will assign a new collection id automatically
/// using a cid of > 0 is supported to import dumps from other servers etc.
/// but the functionality is not advertised
arangodb::LogicalCollection* TRI_vocbase_t::createCollection(
    VPackSlice parameters) {
  // check that the name does not contain any strange characters
  if (!IsAllowedName(parameters)) {
    THROW_ARANGO_EXCEPTION(TRI_ERROR_ARANGO_ILLEGAL_NAME);
  }

  // augment creation parameters
  StorageEngine* engine = EngineSelectorFeature::ENGINE;
  TRI_ASSERT(engine != nullptr);

  VPackBuilder merge;
  merge.openObject();
  engine->addParametersForNewCollection(merge, parameters);
  merge.close();

  merge = VPackCollection::merge(parameters, merge.slice(), true, false);
  parameters = merge.slice();

  READ_LOCKER(readLocker, _inventoryLock);

  // note: cid may be modified by this function call
  auto collection = createCollectionWorker(parameters);

  if (collection == nullptr) {
    // something went wrong... must not continue
    return nullptr;
  }

  auto res2 = engine->persistCollection(*this, *collection);
  // API compatibility, we always return the collection, even if creation
  // failed.

  if (DatabaseFeature::DATABASE != nullptr &&
      DatabaseFeature::DATABASE->versionTracker() != nullptr) {
    DatabaseFeature::DATABASE->versionTracker()->track(""create collection"");
  }

  return collection.get();
}

/// @brief unloads a collection
int TRI_vocbase_t::unloadCollection(arangodb::LogicalCollection* collection,
                                    bool force) {
  {
    WRITE_LOCKER_EVENTUAL(locker, collection->_lock);

    // cannot unload a corrupted collection
    if (collection->status() == TRI_VOC_COL_STATUS_CORRUPTED) {
      return TRI_set_errno(TRI_ERROR_ARANGO_CORRUPTED_COLLECTION);
    }

    // an unloaded collection is unloaded
    if (collection->status() == TRI_VOC_COL_STATUS_UNLOADED) {
      return TRI_ERROR_NO_ERROR;
    }

    // an unloading collection is treated as unloaded
    if (collection->status() == TRI_VOC_COL_STATUS_UNLOADING) {
      return TRI_ERROR_NO_ERROR;
    }

    // a loading collection
    if (collection->status() == TRI_VOC_COL_STATUS_LOADING) {
      // throw away the write locker. we're going to switch to a read locker now
      locker.unlock();

      // loop until status changes
      while (1) {
        TRI_vocbase_col_status_e status;

        {
          READ_LOCKER_EVENTUAL(readLocker, collection->_lock);
          status = collection->status();
        }

        if (status != TRI_VOC_COL_STATUS_LOADING) {
          break;
        }
        // sleep without lock
        std::this_thread::sleep_for(std::chrono::microseconds(collectionStatusPollInterval()));
      }
      // if we get here, the status has changed
      return unloadCollection(collection, force);
    }

    // a deleted collection is treated as unloaded
    if (collection->status() == TRI_VOC_COL_STATUS_DELETED) {
      return TRI_ERROR_NO_ERROR;
    }

    // must be loaded
    if (collection->status() != TRI_VOC_COL_STATUS_LOADED) {
      return TRI_ERROR_INTERNAL;
    }

    // mark collection as unloading
    collection->setStatus(TRI_VOC_COL_STATUS_UNLOADING);
  }  // release locks

  collection->unload();

  // wake up the cleanup thread
  StorageEngine* engine = EngineSelectorFeature::ENGINE;

  engine->unloadCollection(*this, *collection);

  return TRI_ERROR_NO_ERROR;
}

/// @brief drops a collection
arangodb::Result TRI_vocbase_t::dropCollection(
    TRI_voc_cid_t cid,
    bool allowDropSystem,
    double timeout
) {
  auto* collection = lookupCollection(cid).get();

  if (!collection) {
    return TRI_ERROR_ARANGO_DATA_SOURCE_NOT_FOUND;
  }

  StorageEngine* engine = EngineSelectorFeature::ENGINE;

  if (!engine) {
    return arangodb::Result(
      TRI_ERROR_INTERNAL,
      std::string(""failed to find StorageEngine while dropping collection '"") + collection->name() + ""'""
    );
  }

  if (!allowDropSystem && collection->system() && !engine->inRecovery()) {
    // prevent dropping of system collections
    return TRI_set_errno(TRI_ERROR_FORBIDDEN);
  }

  while (true) {
    DropState state = DROP_EXIT;
    int res;
    {
      READ_LOCKER(readLocker, _inventoryLock);
      res = dropCollectionWorker(collection, state, timeout);
    }

    if (state == DROP_PERFORM) {
      if (engine->inRecovery()) {
        DropCollectionCallback(collection);
      } else {
        collection->deferDropCollection(DropCollectionCallback);
        engine->signalCleanup(collection->vocbase()); // wake up the cleanup thread
      }

      if (DatabaseFeature::DATABASE != nullptr &&
          DatabaseFeature::DATABASE->versionTracker() != nullptr) {
        DatabaseFeature::DATABASE->versionTracker()->track(""drop collection"");
      }
    }

    if (state == DROP_PERFORM || state == DROP_EXIT) {
      return res;
    }

    // try again in next iteration
    TRI_ASSERT(state == DROP_AGAIN);
    std::this_thread::sleep_for(std::chrono::microseconds(collectionStatusPollInterval()));
  }
}

/// @brief renames a view
int TRI_vocbase_t::renameView(
    std::shared_ptr<arangodb::LogicalView> const& view,
    std::string const& newName
) {
  // lock collection because we are going to copy its current name
  std::string oldName = view->name();

  // old name should be different

  // check if names are actually different
  if (oldName == newName) {
    return TRI_ERROR_NO_ERROR;
  }

  if (!IsAllowedName(IsSystemName(newName), arangodb::velocypack::StringRef(newName))) {
    return TRI_set_errno(TRI_ERROR_ARANGO_ILLEGAL_NAME);
  }

  READ_LOCKER(readLocker, _inventoryLock);

  RECURSIVE_WRITE_LOCKER(_dataSourceLock, _dataSourceLockWriteOwner);

  // Check for duplicate name
  auto it = _dataSourceByName.find(newName);

  if (it != _dataSourceByName.end()) {
    // new name already in use
    return TRI_ERROR_ARANGO_DUPLICATE_NAME;
  }

  // get the original pointer and ensure it's a LogicalView
  auto itr1 = _dataSourceByName.find(oldName);

  if (itr1 == _dataSourceByName.end()
      || arangodb::LogicalView::category() != itr1->second->category()) {
    return TRI_ERROR_ARANGO_DATA_SOURCE_NOT_FOUND;
  }

  TRI_ASSERT(std::dynamic_pointer_cast<arangodb::LogicalView>(itr1->second));

  _dataSourceByName.emplace(newName, view);
  _dataSourceByName.erase(oldName);

  // stores the parameters on disk
  auto* databaseFeature =
    application_features::ApplicationServer::getFeature<DatabaseFeature>(""Database"");
  TRI_ASSERT(databaseFeature);
  auto doSync = databaseFeature->forceSyncProperties();
  auto res = view->rename(std::string(newName), doSync);

  return res.errorNumber();
}

/// @brief renames a collection
int TRI_vocbase_t::renameCollection(
    arangodb::LogicalCollection* collection,
    std::string const& newName,
    bool doOverride
) {
  if (collection->system()) {
    return TRI_set_errno(TRI_ERROR_FORBIDDEN);
  }

  // lock collection because we are going to copy its current name
  std::string oldName = collection->name();

  // old name should be different

  // check if names are actually different
  if (oldName == newName) {
    return TRI_ERROR_NO_ERROR;
  }

  if (!doOverride) {
    auto isSystem = IsSystemName(oldName);

    if (isSystem && !IsSystemName(newName)) {
      // a system collection shall not be renamed to a non-system collection
      // name
      return TRI_set_errno(TRI_ERROR_ARANGO_ILLEGAL_NAME);
    } else if (!isSystem && IsSystemName(newName)) {
      // a non-system collection shall not be renamed to a system collection
      // name
      return TRI_set_errno(TRI_ERROR_ARANGO_ILLEGAL_NAME);
    }

    if (!IsAllowedName(isSystem, arangodb::velocypack::StringRef(newName))) {
      return TRI_set_errno(TRI_ERROR_ARANGO_ILLEGAL_NAME);
    }
  }

  READ_LOCKER(readLocker, _inventoryLock);

  RECURSIVE_WRITE_LOCKER_NAMED(writeLocker, _dataSourceLock, _dataSourceLockWriteOwner, false);
  CONDITIONAL_WRITE_LOCKER(locker, collection->_lock, false);

  while (true) {
    TRI_ASSERT(!writeLocker.isLocked());
    TRI_ASSERT(!locker.isLocked());

    // block until we have acquired this lock
    writeLocker.lock();
    // we now have the one lock

    TRI_ASSERT(writeLocker.isLocked());

    if (locker.tryLock()) {
      // we now have both locks and can continue outside of this loop
      break;
    }

    // unlock the write locker so we don't block other operations
    writeLocker.unlock();

    TRI_ASSERT(!writeLocker.isLocked());
    TRI_ASSERT(!locker.isLocked());

    // sleep for a while
    std::this_thread::yield();
    std::this_thread::sleep_for(std::chrono::microseconds(10000));
  }

  TRI_ASSERT(writeLocker.isLocked());
  TRI_ASSERT(locker.isLocked());

  // Check for duplicate name
  auto itr = _dataSourceByName.find(newName);

  if (itr != _dataSourceByName.end()) {
    return TRI_ERROR_ARANGO_DUPLICATE_NAME;
  }

  // get the original pointer and ensure it's a LogicalCollection
  auto itr1 = _dataSourceByName.find(oldName);

  if (itr1 == _dataSourceByName.end()
      || arangodb::LogicalCollection::category() != itr1->second->category()) {
    return TRI_ERROR_ARANGO_DATA_SOURCE_NOT_FOUND;
  }

  TRI_ASSERT(std::dynamic_pointer_cast<arangodb::LogicalCollection>(itr1->second));

  auto* databaseFeature =
    application_features::ApplicationServer::getFeature<DatabaseFeature>(""Database"");
  TRI_ASSERT(databaseFeature);
  auto doSync = databaseFeature->forceSyncProperties();
  auto res = collection->rename(std::string(newName), doSync);

  if (!res.ok()) {
    return res.errorNumber(); // rename failed
  }

  // The collection is renamed. Now swap cache entries.
  auto it2 = _dataSourceByName.emplace(newName, itr1->second);
  TRI_ASSERT(it2.second);

  try {
    _dataSourceByName.erase(oldName);
  } catch (...) {
    _dataSourceByName.erase(newName);
    throw;
  }

  checkCollectionInvariants();
  locker.unlock();
  writeLocker.unlock();

  if (DatabaseFeature::DATABASE != nullptr &&
      DatabaseFeature::DATABASE->versionTracker() != nullptr) {
    DatabaseFeature::DATABASE->versionTracker()->track(""rename collection"");
  }

  // invalidate all entries for the two collections
  arangodb::aql::PlanCache::instance()->invalidate(this);
  arangodb::aql::QueryCache::instance()->invalidate(
      this, std::vector<std::string>{oldName, newName});

  // Tell the engine.
  StorageEngine* engine = EngineSelectorFeature::ENGINE;

  TRI_ASSERT(engine != nullptr);

  auto res2 = engine->renameCollection(*this, *collection, oldName);

  return res2.errorNumber();
}

/// @brief locks a collection for usage, loading or manifesting it
int TRI_vocbase_t::useCollection(arangodb::LogicalCollection* collection,
                                 TRI_vocbase_col_status_e& status) {
  return loadCollection(collection, status);
}

/// @brief locks a (document) collection for usage by id
arangodb::LogicalCollection* TRI_vocbase_t::useCollection(
    TRI_voc_cid_t cid, TRI_vocbase_col_status_e& status) {
  auto collection = lookupCollection(cid);

  return useCollectionInternal(collection.get(), status);
}

/// @brief locks a collection for usage by name
arangodb::LogicalCollection* TRI_vocbase_t::useCollection(
    std::string const& name, TRI_vocbase_col_status_e& status) {
  // check that we have an existing name
  arangodb::LogicalCollection* collection = nullptr;

  {
    RECURSIVE_READ_LOCKER(_dataSourceLock, _dataSourceLockWriteOwner);

    auto it = _dataSourceByName.find(name);

    if (it != _dataSourceByName.end()
        && it->second->category() == LogicalCollection::category()) {
      TRI_ASSERT(std::dynamic_pointer_cast<LogicalCollection>(it->second));
      collection = static_cast<LogicalCollection*>(it->second.get());
    }
  }

  return useCollectionInternal(collection, status);
}

/// @brief locks a collection for usage by name
arangodb::LogicalCollection* TRI_vocbase_t::useCollectionByUuid(
    std::string const& uuid, TRI_vocbase_col_status_e& status) {
  auto collection = lookupCollectionByUuid(uuid);

  return useCollectionInternal(collection.get(), status);
}

arangodb::LogicalCollection* TRI_vocbase_t::useCollectionInternal(
    arangodb::LogicalCollection* collection, TRI_vocbase_col_status_e& status) {
  if (collection == nullptr) {
    TRI_set_errno(TRI_ERROR_ARANGO_DATA_SOURCE_NOT_FOUND);
    return nullptr;
  }

  // try to load the collection
  int res = loadCollection(collection, status);

  if (res == TRI_ERROR_NO_ERROR) {
    return collection;
  }

  TRI_set_errno(res);
  return nullptr;
}

/// @brief releases a collection from usage
void TRI_vocbase_t::releaseCollection(arangodb::LogicalCollection* collection) {
  collection->_lock.unlock();
}

/// @brief creates a new view from parameter set
/// view id is normally passed with a value of 0
/// this means that the system will assign a new id automatically
/// using a cid of > 0 is supported to import dumps from other servers etc.
/// but the functionality is not advertised
std::shared_ptr<arangodb::LogicalView> TRI_vocbase_t::createView(
    arangodb::velocypack::Slice parameters
) {
  // check that the name does not contain any strange characters
  if (!IsAllowedName(parameters)) {
    THROW_ARANGO_EXCEPTION(TRI_ERROR_ARANGO_ILLEGAL_NAME);
  }

  std::shared_ptr<arangodb::LogicalView> view;

  if (ServerState::instance()->isCoordinator()) {
    auto* ci = ClusterInfo::instance();

    if (!ci) {
      THROW_ARANGO_EXCEPTION_MESSAGE(
        TRI_ERROR_INTERNAL,
        std::string(""failed to find ClusterInfo while creating view"")
      );
    }

    view = LogicalView::create(*this, parameters, true);

    if (!view) {
      THROW_ARANGO_EXCEPTION_MESSAGE(
        TRI_ERROR_BAD_PARAMETER,
        std::string(""failed to instantiate view in agency'"")
      );
    }

    view = ci->getView(name(), std::to_string(view->id())); // refresh view from Agency
  } else {
    std::shared_ptr<arangodb::LogicalView> registeredView;
    auto callback = [this, &registeredView](
      std::shared_ptr<arangodb::LogicalView> const& view
    )->bool {
      TRI_ASSERT(false == !view);
      RECURSIVE_WRITE_LOCKER(_dataSourceLock, _dataSourceLockWriteOwner);
      auto itr = _dataSourceByName.find(view->name());

      if (itr != _dataSourceByName.end()) {
        events::CreateView(view->name(), TRI_ERROR_ARANGO_DUPLICATE_NAME);

        THROW_ARANGO_EXCEPTION(TRI_ERROR_ARANGO_DUPLICATE_NAME);
      }

      registerView(basics::ConditionalLocking::DoNotLock, view);
      registeredView = view;

      return true;
    };

    READ_LOCKER(readLocker, _inventoryLock);

    // Try to create a new view. This is not registered yet
    view = LogicalView::create(*this, parameters, true, 0, callback);

    if (!view) {
      if (registeredView) {
        unregisterView(*registeredView);
      }

      auto name = arangodb::basics::VelocyPackHelper::getStringValue(
        parameters, StaticStrings::DataSourceName, """"
      );

      THROW_ARANGO_EXCEPTION_MESSAGE(
        TRI_ERROR_BAD_PARAMETER,
        std::string(""failed to instantiate view '"") + name + ""'""
      );
    }

    events::CreateView(view->name(), TRI_ERROR_NO_ERROR);

    if (DatabaseFeature::DATABASE != nullptr &&
        DatabaseFeature::DATABASE->versionTracker() != nullptr) {
      DatabaseFeature::DATABASE->versionTracker()->track(""create view"");
    }
  }

  // And lets open it.
  if (view) {
    view->open();
  }

  return view;
}

/// @brief drops a view
arangodb::Result TRI_vocbase_t::dropView(
    TRI_voc_cid_t cid,
    bool allowDropSystem
) {
  auto const view = lookupView(cid);

  if (!view) {
    return TRI_ERROR_ARANGO_DATA_SOURCE_NOT_FOUND;
  }

  if (!allowDropSystem && view->system()) {
    StorageEngine* engine = EngineSelectorFeature::ENGINE;

    if (!engine) {
      return arangodb::Result(
        TRI_ERROR_INTERNAL,
        std::string(""failed to find StorageEngine while dropping view '"") + view->name() + ""'""
      );
    }

    if (!engine->inRecovery()) {
      return TRI_ERROR_FORBIDDEN; // prevent dropping of system views
    }
  }

  if (ServerState::instance()->isCoordinator()) {
    return view->drop(); // will internally drop view from ClusterInfo
  }

  READ_LOCKER(readLocker, _inventoryLock);

  // do not acquire these locks instantly
  RECURSIVE_WRITE_LOCKER_NAMED(writeLocker, _dataSourceLock, _dataSourceLockWriteOwner,
                           basics::ConditionalLocking::DoNotLock);
  CONDITIONAL_WRITE_LOCKER(
    locker, view->_lock, basics::ConditionalLocking::DoNotLock
  );

  while (true) {
    TRI_ASSERT(!writeLocker.isLocked());
    TRI_ASSERT(!locker.isLocked());

    // block until we have acquired this lock
    writeLocker.lock();
    // we now have the one lock

    TRI_ASSERT(writeLocker.isLocked());

    if (locker.tryLock()) {
      // we now have both locks and can continue outside of this loop
      break;
    }

    // unlock the write locker so we don't block other operations
    writeLocker.unlock();

    TRI_ASSERT(!writeLocker.isLocked());
    TRI_ASSERT(!locker.isLocked());

    // sleep for a while
    std::this_thread::yield();
    std::this_thread::sleep_for(std::chrono::microseconds(10000));
  }

  TRI_ASSERT(writeLocker.isLocked());
  TRI_ASSERT(locker.isLocked());

  arangodb::aql::PlanCache::instance()->invalidate(this);
  arangodb::aql::QueryCache::instance()->invalidate(this);

  auto res = view->drop();

  if (!res.ok()) {
    return res;
  }

  unregisterView(*view);

  locker.unlock();
  writeLocker.unlock();

  events::DropView(view->name(), TRI_ERROR_NO_ERROR);

  if (DatabaseFeature::DATABASE != nullptr &&
      DatabaseFeature::DATABASE->versionTracker() != nullptr) {
    DatabaseFeature::DATABASE->versionTracker()->track(""drop view"");
  }

  return TRI_ERROR_NO_ERROR;
}

/// @brief create a vocbase object
TRI_vocbase_t::TRI_vocbase_t(TRI_vocbase_type_e type, TRI_voc_tick_t id,
                             std::string const& name)
    : _id(id),
      _name(name),
      _type(type),
      _refCount(0),
      _state(TRI_vocbase_t::State::NORMAL),
      _isOwnAppsDirectory(true),
      _deadlockDetector(false),
      _userStructures(nullptr) {
  _queries.reset(new arangodb::aql::QueryList(this));
  _cursorRepository.reset(new arangodb::CursorRepository(*this));
  _collectionKeys.reset(new arangodb::CollectionKeysRepository());

  // init collections
  _collections.reserve(32);
  _deadCollections.reserve(32);

  TRI_CreateUserStructuresVocBase(this);
}

/// @brief destroy a vocbase object
TRI_vocbase_t::~TRI_vocbase_t() {
  if (_userStructures != nullptr) {
    TRI_FreeUserStructuresVocBase(this);
  }

  StorageEngine* engine = EngineSelectorFeature::ENGINE;

  engine->shutdownDatabase(*this);

  // do a final cleanup of collections
  for (auto& it : _collections) {
    it->close(); // required to release indexes
  }
}

std::string TRI_vocbase_t::path() const {
  StorageEngine* engine = EngineSelectorFeature::ENGINE;
  return engine->databasePath(this);
}

bool TRI_vocbase_t::IsAllowedName(arangodb::velocypack::Slice slice) noexcept {
  return !slice.isObject()
    ? false
    : IsAllowedName(
        arangodb::basics::VelocyPackHelper::readBooleanValue(
          slice, StaticStrings::DataSourceSystem, false
        ),
        arangodb::basics::VelocyPackHelper::getStringRef(
          slice, StaticStrings::DataSourceName, """"
        )
      )
    ;
}

/// @brief checks if a database name is allowed
/// returns true if the name is allowed and false otherwise
bool TRI_vocbase_t::IsAllowedName(
    bool allowSystem,
    arangodb::velocypack::StringRef const& name
) noexcept {
  size_t length = 0;

  // check allow characters: must start with letter or underscore if system is
  // allowed
  for (char const* ptr = name.data(); length < name.size(); ++ptr, ++length) {
    bool ok;
    if (length == 0) {
      if (allowSystem) {
        ok = (*ptr == '_') || ('a' <= *ptr && *ptr <= 'z') ||
             ('A' <= *ptr && *ptr <= 'Z');
      } else {
        ok = ('a' <= *ptr && *ptr <= 'z') || ('A' <= *ptr && *ptr <= 'Z');
      }
    } else {
      ok = (*ptr == '_') || (*ptr == '-') || ('0' <= *ptr && *ptr <= '9') ||
           ('a' <= *ptr && *ptr <= 'z') || ('A' <= *ptr && *ptr <= 'Z');
    }

    if (!ok) {
      return false;
    }
  }

  // invalid name length
  if (length == 0 || length > TRI_COL_NAME_LENGTH) {
    return false;
  }

  return true;
}

/// @brief determine whether a collection name is a system collection name
/*static*/ bool TRI_vocbase_t::IsSystemName(std::string const& name) noexcept {
  return !name.empty() && name[0] == '_';
}

void TRI_vocbase_t::addReplicationApplier() {
  TRI_ASSERT(_type != TRI_VOCBASE_TYPE_COORDINATOR);
  auto* applier = DatabaseReplicationApplier::create(*this);
  _replicationApplier.reset(applier);
}

/// @brief note the progress of a connected replication client
/// this only updates the ttl
void TRI_vocbase_t::updateReplicationClient(TRI_server_id_t serverId, double ttl) {
  if (ttl <= 0.0) {
    ttl = replutils::BatchInfo::DefaultTimeout;
  }

  double const timestamp = TRI_microtime();
  double const expires = timestamp + ttl;

  WRITE_LOCKER(writeLocker, _replicationClientsLock);

  auto it = _replicationClients.find(serverId);

  if (it != _replicationClients.end()) {
    LOG_TOPIC(TRACE, Logger::REPLICATION) << ""updating replication client entry for server '"" << serverId << ""' using TTL "" << ttl;
    std::get<0>((*it).second) = timestamp;
    std::get<1>((*it).second) = expires;
  } else {
    LOG_TOPIC(TRACE, Logger::REPLICATION) << ""replication client entry for server '"" << serverId << ""' not found"";
  }
}

/// @brief note the progress of a connected replication client
void TRI_vocbase_t::updateReplicationClient(TRI_server_id_t serverId,
                                            TRI_voc_tick_t lastFetchedTick,
                                            double ttl) {
  if (ttl <= 0.0) {
    ttl = replutils::BatchInfo::DefaultTimeout;
  }
  double const timestamp = TRI_microtime();
  double const expires = timestamp + ttl;

  WRITE_LOCKER(writeLocker, _replicationClientsLock);

  try {
    auto it = _replicationClients.find(serverId);

    if (it == _replicationClients.end()) {
      // insert new client entry
      _replicationClients.emplace(
          serverId, std::make_tuple(timestamp, expires, lastFetchedTick));
      LOG_TOPIC(TRACE, Logger::REPLICATION) << ""inserting replication client entry for server '"" << serverId << ""' using TTL "" << ttl << "", last tick: "" << lastFetchedTick;
    } else {
      // update an existing client entry
      std::get<0>((*it).second) = timestamp;
      std::get<1>((*it).second) = expires;
      if (lastFetchedTick > 0) {
        std::get<2>((*it).second) = lastFetchedTick;
        LOG_TOPIC(TRACE, Logger::REPLICATION) << ""updating replication client entry for server '"" << serverId << ""' using TTL "" << ttl << "", last tick: "" << lastFetchedTick;
      } else {
        LOG_TOPIC(TRACE, Logger::REPLICATION) << ""updating replication client entry for server '"" << serverId << ""' using TTL "" << ttl;
      }
    }
  } catch (...) {
    // silently fail...
    // all we would be missing is the progress information of a slave
  }
}

/// @brief return the progress of all replication clients
std::vector<std::tuple<TRI_server_id_t, double, double, TRI_voc_tick_t>>
TRI_vocbase_t::getReplicationClients() {
  std::vector<std::tuple<TRI_server_id_t, double, double, TRI_voc_tick_t>> result;

  READ_LOCKER(readLocker, _replicationClientsLock);

  for (auto& it : _replicationClients) {
    result.emplace_back(
        std::make_tuple(it.first,
                        std::get<0>(it.second),
                        std::get<1>(it.second),
                        std::get<2>(it.second)
                        )
    );
  }
  return result;
}

void TRI_vocbase_t::garbageCollectReplicationClients(double expireStamp) {
  LOG_TOPIC(TRACE, Logger::REPLICATION) << ""garbage collecting replication client entries"";

  WRITE_LOCKER(writeLocker, _replicationClientsLock);

  try {
    auto it = _replicationClients.begin();

    while (it != _replicationClients.end()) {
      double const expires = std::get<1>((*it).second);
      if (expireStamp > expires) {
        LOG_TOPIC(DEBUG, Logger::REPLICATION) << ""removing expired replication client for server id "" << it->first;
        it = _replicationClients.erase(it);
      } else {
        ++it;
      }
    }
  } catch (...) {
    // silently fail...
    // all we would be missing is the progress information of a slave
  }
}

std::vector<std::shared_ptr<arangodb::LogicalView>> TRI_vocbase_t::views() {
  if (ServerState::instance()->isCoordinator()) {
    return ClusterInfo::instance()->getViews(name());
  }

  std::vector<std::shared_ptr<arangodb::LogicalView>> views;

  {
    RECURSIVE_READ_LOCKER(_dataSourceLock, _dataSourceLockWriteOwner);
    views.reserve(_dataSourceById.size());

    for (auto& entry: _dataSourceById) {
      TRI_ASSERT(entry.second);

      if (entry.second->category() != LogicalView::category()) {
        continue;
      }

#ifdef ARANGODB_ENABLE_MAINTAINER_MODE
      auto view = std::dynamic_pointer_cast<arangodb::LogicalView>(entry.second);
      TRI_ASSERT(view);
#else
      auto view = std::static_pointer_cast<arangodb::LogicalView>(entry.second);
#endif

      views.emplace_back(view);
    }
  }

  return views;
}

void TRI_vocbase_t::processCollections(
    std::function<void(LogicalCollection*)> const& cb, bool includeDeleted) {
  RECURSIVE_READ_LOCKER(_dataSourceLock, _dataSourceLockWriteOwner);

  if (includeDeleted) {
    for (auto const& it : _collections) {
      cb(it.get());
    }
  } else {
    for (auto& entry: _dataSourceById) {
      TRI_ASSERT(entry.second);

      if (entry.second->category() != LogicalCollection::category()) {
        continue;
      }

#ifdef ARANGODB_ENABLE_MAINTAINER_MODE
      auto collection = std::dynamic_pointer_cast<arangodb::LogicalCollection>(entry.second);
      TRI_ASSERT(collection);
#else
      auto collection = std::static_pointer_cast<arangodb::LogicalCollection>(entry.second);
#endif

      cb(collection.get());
    }
  }
}

std::vector<arangodb::LogicalCollection*> TRI_vocbase_t::collections(
    bool includeDeleted
) {
  std::vector<arangodb::LogicalCollection*> collections;

  {
    RECURSIVE_READ_LOCKER(_dataSourceLock, _dataSourceLockWriteOwner);
    if (includeDeleted) {
      // return deleted collections as well. the cleanup thread needs them
      collections.reserve(_collections.size());

      for (auto const& it : _collections) {
        collections.emplace_back(it.get());
      }
    } else {
      collections.reserve(_dataSourceById.size());

      for (auto& entry: _dataSourceById) {
        TRI_ASSERT(entry.second);

        if (entry.second->category() != LogicalCollection::category()) {
          continue;
        }

#ifdef ARANGODB_ENABLE_MAINTAINER_MODE
        auto collection = std::dynamic_pointer_cast<arangodb::LogicalCollection>(entry.second);
        TRI_ASSERT(collection);
#else
        auto collection = std::static_pointer_cast<arangodb::LogicalCollection>(entry.second);
#endif

        collections.emplace_back(collection.get());
      }
    }
  }

  return collections;
}

/// @brief extract the _rev attribute from a slice
TRI_voc_rid_t TRI_ExtractRevisionId(VPackSlice slice) {
  slice = slice.resolveExternal();
  TRI_ASSERT(slice.isObject());

  VPackSlice r(slice.get(StaticStrings::RevString));
  if (r.isString()) {
    VPackValueLength l;
    char const* p = r.getString(l);
    return TRI_StringToRid(p, l, false);
  }
  if (r.isInteger()) {
    return r.getNumber<TRI_voc_rid_t>();
  }
  return 0;
}

/// @brief extract the _rev attribute from a slice as a slice
VPackSlice TRI_ExtractRevisionIdAsSlice(VPackSlice const slice) {
  if (!slice.isObject()) {
    return VPackSlice();
  }

  return slice.get(StaticStrings::RevString);
}

/// @brief sanitize an object, given as slice, builder must contain an
/// open object which will remain open
/// the result is the object excluding _id, _key and _rev
void TRI_SanitizeObject(VPackSlice const slice, VPackBuilder& builder) {
  TRI_ASSERT(slice.isObject());
  VPackObjectIterator it(slice);
  while (it.valid()) {
    StringRef key(it.key());
    if (key.empty() || key[0] != '_' ||
        (key != StaticStrings::KeyString && key != StaticStrings::IdString &&
         key != StaticStrings::RevString)) {
      builder.add(key.data(), key.size(), it.value());
    }
    it.next();
  }
}

/// @brief sanitize an object, given as slice, builder must contain an
/// open object which will remain open. also excludes _from and _to
void TRI_SanitizeObjectWithEdges(VPackSlice const slice,
                                 VPackBuilder& builder) {
  TRI_ASSERT(slice.isObject());
  VPackObjectIterator it(slice, true);
  while (it.valid()) {
    StringRef key(it.key());
    if (key.empty() || key[0] != '_' ||
        (key != StaticStrings::KeyString && key != StaticStrings::IdString &&
         key != StaticStrings::RevString && key != StaticStrings::FromString &&
         key != StaticStrings::ToString)) {
      builder.add(key.data(), key.length(), it.value());
    }
    it.next();
  }
}

/// @brief Convert a revision ID to a string
constexpr static TRI_voc_rid_t tickLimit =
    static_cast<TRI_voc_rid_t>(2016ULL - 1970ULL) * 1000ULL * 60ULL * 60ULL *
    24ULL * 365ULL;

std::string TRI_RidToString(TRI_voc_rid_t rid) {
  if (rid <= tickLimit) {
    return arangodb::basics::StringUtils::itoa(rid);
  }
  return HybridLogicalClock::encodeTimeStamp(rid);
}

/// @brief Convert a string into a revision ID, no check variant
TRI_voc_rid_t TRI_StringToRid(char const* p, size_t len, bool warn) {
  bool isOld;
  return TRI_StringToRid(p, len, isOld, warn);
}

/// @brief Convert a string into a revision ID, returns 0 if format invalid
TRI_voc_rid_t TRI_StringToRid(std::string const& ridStr, bool& isOld,
                              bool warn) {
  return TRI_StringToRid(ridStr.c_str(), ridStr.size(), isOld, warn);
}

/// @brief Convert a string into a revision ID, returns 0 if format invalid
TRI_voc_rid_t TRI_StringToRid(char const* p, size_t len, bool& isOld,
                              bool warn) {
  if (len > 0 && *p >= '1' && *p <= '9') {
    auto r = NumberUtils::atoi_positive_unchecked<TRI_voc_rid_t>(p, p + len);
    if (warn && r > tickLimit) {
      // An old tick value that could be confused with a time stamp
      LOG_TOPIC(WARN, arangodb::Logger::FIXME)
          << ""Saw old _rev value that could be confused with a time stamp!"";
    }
    isOld = true;
    return r;
  }
  isOld = false;
  return HybridLogicalClock::decodeTimeStamp(p, len);
}

// -----------------------------------------------------------------------------
// --SECTION--                                                       END-OF-FILE
// -----------------------------------------------------------------------------
",16355,True,3103.9708918945885,median
"// Copyright 2017 the original author or 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
//
// 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.

[[native_software]]
= Building native software


[NOTE]
====

Support for building native software is currently <<feature_lifecycle.adoc#feature_lifecycle,incubating>>. Please be aware that the DSL, APIs and other configuration may change in later Gradle versions.

====

The native software plugins add support for building native software components, such as executables or shared libraries, from code written in C++, C and other languages. While many excellent build tools exist for this space of software development, Gradle offers developers its trademark power and flexibility together with dependency management practices more traditionally found in the JVM development space.

The native software plugins make use of the Gradle <<software_model.adoc#software_model,software model>>.


[[sec:native_features]]
== Features

The native software plugins provide:

* Support for building native libraries and applications on Windows, Linux, macOS and other platforms.
* Support for several source languages.
* Support for building different variants of the same software, for different architectures, operating systems, or for any purpose.
* Incremental parallel compilation, precompiled headers.
* Dependency management between native software components.
* Unit test execution.
* Generate Visual studio solution and project files.
* Deep integration with various tool chain, including discovery of installed tool chains.


[[sec:supported_languages]]
== Supported languages

The following source languages are currently supported:

* C
* C++
* Objective-C
* Objective-C++
* Assembly
* Windows resources


[[native-binaries:tool-chain-support]]
== Tool chain support

Gradle offers the ability to execute the same build using different tool chains. When you build a native binary, Gradle will attempt to locate a tool chain installed on your machine that can build the binary. You can fine tune exactly how this works, see <<#native_binaries:tool_chain,Tool chain support>> for details.

The following tool chains are supported:

[%header%autowidth,compact]
|===
| Operating System | Tool Chain | Notes

| Linux
| http://gcc.gnu.org/[GCC]
|

| Linux
| http://clang.llvm.org[Clang]
|

| macOS
| XCode
| Uses the Clang tool chain bundled with XCode.

| Windows
| https://visualstudio.microsoft.com/[Visual C++]
| Windows XP and later, Visual C++ 2010/2012/2013/2015/2017.

| Windows
| http://gcc.gnu.org/[GCC] with http://cygwin.com[Cygwin 32]
| Windows XP and later.

| Windows
| http://gcc.gnu.org/[GCC] with http://www.mingw.org/[MinGW]
| Windows XP and later. http://mingw-w64.sourceforge.net[Mingw-w64] is currently not supported.
|===

The following tool chains are unofficially supported. They generally work fine, but are not tested continuously:

[%header%autowidth,compact]
|===
| Operating System | Tool Chain | Notes

| macOS
| http://gcc.gnu.org/[GCC] from Macports
|

| macOS
| http://clang.llvm.org[Clang] from Macports
|

| Windows
| http://gcc.gnu.org/[GCC] with http://cygwin.com[Cygwin 64]
| Windows XP and later.

| UNIX-like
| http://gcc.gnu.org/[GCC]
|

| UNIX-like
| http://clang.llvm.org[Clang]
|
|===


[[sec:tool_chain_installation]]
== Tool chain installation


[NOTE]
====

Note that if you are using GCC then you currently need to install support for C+\\+, even if you are not building from C++ source. This restriction will be removed in a future Gradle version.

====

To build native software, you will need to have a compatible tool chain installed:


[[sec:windows]]
=== Windows

To build on Windows, install a compatible version of Visual Studio. The native plugins will discover the Visual Studio installations and select the latest version. There is no need to mess around with environment variables or batch scripts. This works fine from a Cygwin shell or the Windows command-line.

Alternatively, you can install Cygwin with GCC or MinGW. Clang is currently not supported.

[[sec:macOS]]
=== macOS

To build on macOS, you should install XCode. The native plugins will discover the XCode installation using the system PATH.

The native plugins also work with GCC and Clang bundled with Macports. To use one of the Macports tool chains, you will need to make the tool chain the default using the `port select` command and add Macports to the system PATH.

[[sec:linux]]
=== Linux

To build on Linux, install a compatible version of GCC or Clang. The native plugins will discover GCC or Clang using the system PATH.

[[sec:native_software_model]]
== Native software model

The native software model builds on the base Gradle <<software_model_concepts.adoc#software_model_concepts,software model>>.

To build native software using Gradle, your project should define one or more _native components_. Each component represents either an executable or a library that Gradle should build. A project can define any number of components. Gradle does not define any components by default.

For each component, Gradle defines a _source set_ for each language that the component can be built from. A source set is essentially just a set of source directories containing source files. For example, when you apply the `c` plugin and define a library called `helloworld`, Gradle will define, by default, a source set containing the C source files in the `src/helloworld/c` directory. It will use these source files to build the `helloworld` library. This is described in more detail below.

For each component, Gradle defines one or more _binaries_ as output. To build a binary, Gradle will take the source files defined for the component, compile them as appropriate for the source language, and link the result into a binary file. For an executable component, Gradle can produce executable binary files. For a library component, Gradle can produce both static and shared library binary files. For example, when you define a library called `helloworld` and build on Linux, Gradle will, by default, produce `libhelloworld.so` and `libhelloworld.a` binaries.

In many cases, more than one binary can be produced for a component. These binaries may vary based on the tool chain used to build, the compiler/linker flags supplied, the dependencies provided, or additional source files provided. Each native binary produced for a component is referred to as a _variant_. Binary variants are discussed in detail below.

[[sec:parallel_compilation]]
== Parallel Compilation

Gradle uses the single build worker pool to concurrently compile and link native components, by default. No special configuration is required to enable concurrent building.

By default, the worker pool size is determined by the number of available processors on the build machine (as reported to the build JVM). To explicitly set the number of workers use the `--max-workers` command-line option or `org.gradle.workers.max` system property. There is generally no need to change this setting from its default.

The build worker pool is shared across all build tasks. This means that when using <<multi_project_builds.adoc#sec:parallel_execution,parallel project execution>>, the maximum number of concurrent individual compilation operations does not increase. For example, if the build machine has 4 processing cores and 10 projects are compiling in parallel, Gradle will only use 4 total workers, not 40.

[[sec:building_a_library]]
== Building a library

To build either a static or shared native library, you define a library component in the `components` container. The following sample defines a library called `hello`:

=== Example: Defining a library component

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/c/build.gradle[tag=libraries]
----

A library component is represented using link:{javadocPath}/org/gradle/nativeplatform/NativeLibrarySpec.html[NativeLibrarySpec]. Each library component can produce at least one shared library binary (link:{javadocPath}/org/gradle/nativeplatform/SharedLibraryBinarySpec.html[SharedLibraryBinarySpec]) and at least one static library binary (link:{javadocPath}/org/gradle/nativeplatform/StaticLibraryBinarySpec.html[StaticLibraryBinarySpec]).

[[sec:building_an_executable]]
== Building an executable

To build a native executable, you define an executable component in the `components` container. The following sample defines an executable called `main`:

=== Example: Defining executable components

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/c/build.gradle[tag=executables]
----

An executable component is represented using link:{javadocPath}/org/gradle/nativeplatform/NativeExecutableSpec.html[NativeExecutableSpec]. Each executable component can produce at least one executable binary (link:{javadocPath}/org/gradle/nativeplatform/NativeExecutableBinarySpec.html[NativeExecutableBinarySpec]).

For each component defined, Gradle adds a link:{javadocPath}/org/gradle/language/base/FunctionalSourceSet.html[FunctionalSourceSet] with the same name. Each of these functional source sets will contain a language-specific source set for each of the languages supported by the project.

[[sec:dependents]]
== Assembling or building dependents

Sometimes, you may need to _assemble_ (compile and link) or _build_ (compile, link and test) a component or binary and its _dependents_ (things that depend upon the component or binary). The native software model provides tasks that enable this capability. First, the _dependent components_ report gives insight about the relationships between each component. Second, the _build and assemble dependents_ tasks allow you to assemble or build a component and its dependents in one step.

In the following example, the build file defines `OpenSSL` as a dependency of `libUtil` and `libUtil` as a dependency of `LinuxApp` and `WindowsApp`. Test suites are treated similarly. Dependents can be thought of as reverse dependencies.

.Dependent Components Example
image::nativeDependents.png[]

[NOTE]
====
By following the dependencies backwards, you can see `LinuxApp` and `WindowsApp` are _dependents_ of `libUtil`. When `libUtil` is changed, Gradle will need to recompile or relink `LinuxApp` and `WindowsApp`.
====


When you _assemble_ dependents of a component, the component and all of its dependents are compiled and linked, including any test suite binaries. Gradle's up-to-date checks are used to only compile or link if something has changed. For instance, if you have changed source files in a way that do not affect the headers of your project, Gradle will be able to skip compilation for dependent components and only need to re-link with the new library. Tests are not run when assembling a component.

When you _build_ dependents of a component, the component and all of its dependent binaries are compiled, linked _and checked_. Checking components means running any <<#sec:check_tasks,check task>> including executing any test suites, so tests _are_ run when building a component.

In the following sections, we will demonstrate the usage of the `assembleDependents\\*`, `buildDependents*` and `dependentComponents` tasks with a sample build that contains a CUnit test suite. The build script for the sample is the following:

=== Example: Sample build

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/cunit/build.gradle[tag=terse-example]
----

NOTE: The code for this example can be found at **`samples/native-binaries/cunit`** in the ‘-all’ distribution of Gradle.


[[sec:dependents_report]]
=== Dependent components report

Gradle provides a report that you can run from the command-line that shows a graph of components in your project and components that depend upon them. The following is an example of running `gradle dependentComponents` on the sample project:

=== Example: Dependent components report

.Output of **`gradle dependentComponents`**
----
> gradle dependentComponents
include::{samplesPath}/native-binaries/cunit/dependentComponentsReport.out[]
----

[NOTE]
====
See link:{groovyDslPath}/org.gradle.api.reporting.dependents.DependentComponentsReport.html[DependentComponentsReport] API documentation for more details.
====

By default, non-buildable binaries and test suites are hidden from the report. The `dependentComponents` task provides options that allow you to see all dependents by using the `--all` option:

=== Example: Dependent components report

.Output of **`gradle dependentComponents --all`**
----
> gradle dependentComponents --all
include::{samplesPath}/native-binaries/cunit/dependentComponentsReportAll.out[]
----

Here is the corresponding report for the `operators` component, showing dependents of all its binaries:

=== Example: Report of components that depends on the operators component

.Output of **`gradle dependentComponents --component operators`**
----
> gradle dependentComponents --component operators
include::{samplesPath}/native-binaries/cunit/assembleDependentComponentsReport.out[]
----

Here is the corresponding report for the `operators` component, showing dependents of all its binaries, including test suites:

=== Example: Report of components that depends on the operators component, including test suites

.Output of **`gradle dependentComponents --test-suites --component operators`**
----
> gradle dependentComponents --test-suites --component operators
include::{samplesPath}/native-binaries/cunit/buildDependentComponentsReport.out[]
----


[[sec:assemble_dependents]]
=== Assembling dependents

For each link:{javadocPath}/org/gradle/nativeplatform/NativeBinarySpec.html[NativeBinarySpec], Gradle will create a task named `assembleDependents__${component.name}${binary.variant}__` that _assembles_ (compile and link) the binary and all of its dependent binaries.

For each link:{javadocPath}/org/gradle/nativeplatform/NativeComponentSpec.html[NativeComponentSpec], Gradle will create a task named `assembleDependents__${component.name}__` that _assembles_ all the binaries of the component and all of their dependent binaries.

For example, to assemble the dependents of the ""passing"" flavor of the ""static"" library binary of the ""operators"" component, you would run the `assembleDependentsOperatorsPassingStaticLibrary` task:

=== Example: Assemble components that depends on the passing/static binary of the operators component

.Output of **`gradle assembleDependentsOperatorsPassingStaticLibrary --max-workers=1`**
----
> gradle assembleDependentsOperatorsPassingStaticLibrary --max-workers=1
include::{samplesPath}/native-binaries/cunit/assembleDependentComponents.out[]
----

In the output above, the targeted binary gets assembled as well as the test suite binary that depends on it.

You can also assemble _all_ of the dependents of a component (i.e. of all its binaries/variants) using the corresponding component task, e.g. `assembleDependentsOperators`. This is useful if you have many combinations of build types, flavors and platforms and want to assemble all of them.

[[sec:build_dependents]]
=== Building dependents

For each link:{javadocPath}/org/gradle/nativeplatform/NativeBinarySpec.html[NativeBinarySpec], Gradle will create a task named `buildDependents__${component.name}${binary.variant}__` that _builds_ (compile, link and check) the binary and all of its dependent binaries.

For each link:{javadocPath}/org/gradle/nativeplatform/NativeComponentSpec.html[NativeComponentSpec], Gradle will create a task named `buildDependents__${component.name}__` that _builds_ all the binaries of the component and all of their dependent binaries.

For example, to build the dependents of the ""passing"" flavor of the ""static"" library binary of the ""operators"" component, you would run the `buildDependentsOperatorsPassingStaticLibrary` task:

=== Example: Build components that depends on the passing/static binary of the operators component

.Output of **`gradle buildDependentsOperatorsPassingStaticLibrary --max-workers=1`**
----
> gradle buildDependentsOperatorsPassingStaticLibrary --max-workers=1
include::{samplesPath}/native-binaries/cunit/buildDependentComponents.out[]
----

In the output above, the targeted binary as well as the test suite binary that depends on it are built and the test suite has run.

You can also build _all_ of the dependents of a component (i.e. of all its binaries/variants) using the corresponding component task, e.g. `buildDependentsOperators`.

[[sec:native_tasks]]
== Tasks

For each link:{javadocPath}/org/gradle/nativeplatform/NativeBinarySpec.html[NativeBinarySpec] that can be produced by a build, a single _lifecycle task_ is constructed that can be used to create that binary, together with a set of other tasks that do the actual work of compiling, linking or assembling the binary.


`__${component.name}__Executable`::
  Component Type;;
    link:{javadocPath}/org/gradle/nativeplatform/NativeExecutableSpec.html[NativeExecutableSpec]
  Native Binary Type;;
    link:{javadocPath}/org/gradle/nativeplatform/NativeExecutableBinarySpec.html[NativeExecutableBinarySpec]
  Location of created binary;;
    `__${project.buildDir}__/exe/__${component.name}__/__${component.name}__`

`__${component.name}__SharedLibrary`::
  Component Type;;
    link:{javadocPath}/org/gradle/nativeplatform/NativeLibrarySpec.html[NativeLibrarySpec]
  Native Binary Type;;
    link:{javadocPath}/org/gradle/nativeplatform/SharedLibraryBinarySpec.html[SharedLibraryBinarySpec]
  Location of created binary;;
    `__${project.buildDir}__/libs/__${component.name}__/shared/lib__${component.name}__.so`

`__${component.name}__StaticLibrary`::
  Component Type;;
    link:{javadocPath}/org/gradle/nativeplatform/NativeLibrarySpec.html[NativeLibrarySpec]
  Native Binary Type;;
    link:{javadocPath}/org/gradle/nativeplatform/StaticLibraryBinarySpec.html[StaticLibraryBinarySpec]
  Location of created binary;;
    `__${project.buildDir}__/libs/__${component.name}__/static/__${component.name}__.a`


[[sec:check_tasks]]
=== Check tasks

For each link:{javadocPath}/org/gradle/nativeplatform/NativeBinarySpec.html[NativeBinarySpec] that can be produced by a build, a single _check task_ is constructed that can be used to assemble and check that binary.

`check__${component.name}__Executable`::
  Component Type;;
    link:{javadocPath}/org/gradle/nativeplatform/NativeExecutableSpec.html[NativeExecutableSpec]
  Native Binary Type;;
    link:{javadocPath}/org/gradle/nativeplatform/NativeExecutableBinarySpec.html[NativeExecutableBinarySpec]

`check__${component.name}__SharedLibrary`::
  Component Type;;
    link:{javadocPath}/org/gradle/nativeplatform/NativeLibrarySpec.html[NativeLibrarySpec]
  Native Binary Type;;
    link:{javadocPath}/org/gradle/nativeplatform/SharedLibraryBinarySpec.html[SharedLibraryBinarySpec]

`check__${component.name}__StaticLibrary`::
  Component Type;;
    link:{javadocPath}/org/gradle/nativeplatform/NativeLibrarySpec.html[NativeLibrarySpec]
  Native Binary Type;;
    link:{javadocPath}/org/gradle/nativeplatform/SharedLibraryBinarySpec.html[SharedLibraryBinarySpec]

The built-in `check` task depends on all the _check tasks_ for binaries in the project. Without either <<#native_binaries:cunit,CUnit>> or <<#native_binaries:google_test,GoogleTest>> plugins, the binary check task only depends on the _lifecycle task_ that assembles the binary, see <<#sec:native_tasks,Native tasks>>.

When the <<#native_binaries:cunit,CUnit>> or <<#native_binaries:google_test,GoogleTest>> plugins are applied, the task that executes the test suites for a component are automatically wired to the appropriate _check task_.

You can also add custom check tasks as follows:

=== Example: Adding a custom check task

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/custom-check/build.gradle[tag=custom-check]
----

NOTE: The code for this example can be found at **`samples/native-binaries/custom-check`** in the ‘-all’ distribution of Gradle.


Now, running `check` or any of the _check tasks_ for the `hello` binaries will run the custom check task:

=== Example: Running checks for a given binary

.Output of **`gradle checkHelloSharedLibrary`**
----
> gradle checkHelloSharedLibrary
include::{samplesPath}/native-binaries/custom-check/nativeComponentCustomCheckOutput.out[]
----


[[sec:working_with_shared_libraries]]
=== Working with shared libraries

For each executable binary produced, the `cpp` plugin provides an `install${binary.name}` task, which creates a development install of the executable, along with the shared libraries it requires. This allows you to run the executable without needing to install the shared libraries in their final locations.

[[sec:finding_out_more_about_your_project]]
== Finding out more about your project

Gradle provides a report that you can run from the command-line that shows some details about the components and binaries that your project produces. To use this report, just run `gradle components`. Below is an example of running this report for one of the sample projects:

=== Example: The components report

.Output of **`gradle components`**
----
> gradle components
include::{samplesPath}/native-binaries/cpp/nativeComponentReport.out[]
----


[[native_binaries:languages]]
== Language support

Presently, Gradle supports building native software from any combination of source languages listed below. A native binary project will contain one or more named `FunctionalSourceSet` instances (eg 'main', 'test', etc), each of which can contain ``LanguageSourceSet``s containing source files, one for each language.

* C
* C++
* Objective-C
* Objective-C++
* Assembly
* Windows resources


[[sec:cpp_sources]]
=== C++ sources

C++ language support is provided by means of the `'cpp'` plugin.

=== Example: The 'cpp' plugin

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/cpp/build.gradle[tag=apply-plugin]
----

$$C++$$ sources to be included in a native binary are provided via a link:{groovyDslPath}/org.gradle.language.cpp.CppSourceSet.html[CppSourceSet], which defines a set of C++ source files and optionally a set of exported header files (for a library). By default, for any named component the link:{groovyDslPath}/org.gradle.language.cpp.CppSourceSet.html[CppSourceSet] contains `.cpp` source files in `src/${name}/cpp`, and header files in `src/${name}/headers`.

While the `cpp` plugin defines these default locations for each link:{groovyDslPath}/org.gradle.language.cpp.CppSourceSet.html[CppSourceSet], it is possible to extend or override these defaults to allow for a different project layout.

=== Example: C++ source set

[source.multi-language-sample,groovy,indent=0]
.build.gradle
----
include::{samplesPath}/native-binaries/custom-layout/build.gradle[tag=cpp-sources]
----

For a library named 'main', header files in `src/main/headers` are considered the ""public"" or ""exported"" headers. Header files that should not be exported should be placed inside the `src/main/cpp` directory (though be aware that such header files should always be referenced in a manner relative to the file including them).

[[sec:c_sources]]
=== C sources

C language support is provided by means of the `'c'` plugin.

=== Example: The 'c' plugin

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/c/build.gradle[tag=apply-plugin]
----

C sources to be included in a native binary are provided via a link:{groovyDslPath}/org.gradle.language.c.CSourceSet.html[CSourceSet], which defines a set of C source files and optionally a set of exported header files (for a library). By default, for any named component the link:{groovyDslPath}/org.gradle.language.c.CSourceSet.html[CSourceSet] contains `.c` source files in `src/${name}/c`, and header files in `src/${name}/headers`.

While the `c` plugin defines these default locations for each link:{groovyDslPath}/org.gradle.language.c.CSourceSet.html[CSourceSet], it is possible to extend or override these defaults to allow for a different project layout.

=== Example: C source set

[source.multi-language-sample,groovy,indent=0]
.build.gradle
----
include::{samplesPath}/native-binaries/custom-layout/build.gradle[tag=c-sources]
----

For a library named 'main', header files in `src/main/headers` are considered the ""public"" or ""exported"" headers. Header files that should not be exported should be placed inside the `src/main/c` directory (though be aware that such header files should always be referenced in a manner relative to the file including them).

[[sec:assembler_sources]]
=== Assembler sources

Assembly language support is provided by means of the `'assembler'` plugin.

=== Example: The 'assembler' plugin

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/assembler/build.gradle[tag=apply-plugin]
----

Assembler sources to be included in a native binary are provided via a link:{groovyDslPath}/org.gradle.language.assembler.AssemblerSourceSet.html[AssemblerSourceSet], which defines a set of Assembler source files. By default, for any named component the link:{groovyDslPath}/org.gradle.language.assembler.AssemblerSourceSet.html[AssemblerSourceSet] contains `.s` source files under `src/${name}/asm`.

[[sec:objectivec_sources]]
=== Objective-C sources

Objective-C language support is provided by means of the `'objective-c'` plugin.

=== Example: The 'objective-c' plugin

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/objective-c/build.gradle[tag=apply-plugin]
----

Objective-C sources to be included in a native binary are provided via a link:{groovyDslPath}/org.gradle.language.objectivec.ObjectiveCSourceSet.html[ObjectiveCSourceSet], which defines a set of Objective-C source files. By default, for any named component the link:{groovyDslPath}/org.gradle.language.objectivec.ObjectiveCSourceSet.html[ObjectiveCSourceSet] contains `.m` source files under `src/${name}/objectiveC`.

[[sec:objectivecpp_sources]]
=== Objective-C++ sources

Objective-C++ language support is provided by means of the `'objective-cpp'` plugin.

=== Example: The 'objective-cpp' plugin

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/objective-cpp/build.gradle[tag=apply-plugin]
----

Objective-C$$++$$ sources to be included in a native binary are provided via a link:{groovyDslPath}/org.gradle.language.objectivecpp.ObjectiveCppSourceSet.html[ObjectiveCppSourceSet], which defines a set of Objective-C++ source files. By default, for any named component the link:{groovyDslPath}/org.gradle.language.objectivecpp.ObjectiveCppSourceSet.html[ObjectiveCppSourceSet] contains `.mm` source files under `src/${name}/objectiveCpp`.

[[sec:configuring_the_compiler_assembler_and_linker]]
== Configuring the compiler, assembler and linker

Each binary to be produced is associated with a set of compiler and linker settings, which include command-line arguments as well as macro definitions. These settings can be applied to all binaries, an individual binary, or selectively to a group of binaries based on some criteria.

=== Example: Settings that apply to all binaries

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/cpp/build.gradle[tag=all-binaries]
----

Each binary is associated with a particular link:{javadocPath}/org/gradle/nativeplatform/toolchain/NativeToolChain.html[NativeToolChain], allowing settings to be targeted based on this value.

It is easy to apply settings to all binaries of a particular type:

=== Example: Settings that apply to all shared libraries

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/c/build.gradle[tag=all-shared-libraries]
----

Furthermore, it is possible to specify settings that apply to all binaries produced for a particular `executable` or `library` component:

=== Example: Settings that apply to all binaries produced for the 'main' executable component

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/assembler/build.gradle[tag=assembler-args]
----

The example above will apply the supplied configuration to all `executable` binaries built.

Similarly, settings can be specified to target binaries for a component that are of a particular type: eg all shared libraries for the main library component.

=== Example: Settings that apply only to shared libraries produced for the 'main' library component

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/cpp-lib/build.gradle[tag=args]
----


[[native_binaries:windows-resources]]
== Windows Resources

When using the link:{groovyDslPath}/org.gradle.nativeplatform.toolchain.VisualCpp.html[VisualCpp] tool chain, Gradle is able to compile Window Resource (`rc`) files and link them into a native binary. This functionality is provided by the `'windows-resources'` plugin.

=== Example: The 'windows-resources' plugin

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/windows-resources/build.gradle[tag=apply-plugin]
----

Windows resources to be included in a native binary are provided via a link:{groovyDslPath}/org.gradle.language.rc.WindowsResourceSet.html[WindowsResourceSet], which defines a set of Windows Resource source files. By default, for any named component the link:{groovyDslPath}/org.gradle.language.rc.WindowsResourceSet.html[WindowsResourceSet] contains `.rc` source files under `src/${name}/rc`.

As with other source types, you can configure the location of the windows resources that should be included in the binary.

=== Example: Configuring the location of Windows resource sources

[source.multi-language-sample,groovy,indent=0]
.build-resource-only-dll.gradle
----
include::{samplesPath}/native-binaries/windows-resources/build-resource-only-dll.gradle[tag=windows-resource-set]
----

You are able to construct a resource-only library by providing Windows Resource sources with no other language sources, and configure the linker as appropriate:

=== Example: Building a resource-only dll

[source.multi-language-sample,groovy]
.build-resource-only-dll.gradle
----
include::{samplesPath}/native-binaries/windows-resources/build-resource-only-dll.gradle[tag=resource-only-library]
----

The example above also demonstrates the mechanism of passing extra command-line arguments to the resource compiler. The `rcCompiler` extension is of type link:{javadocPath}/org/gradle/nativeplatform/PreprocessingTool.html[PreprocessingTool].

[[sec:library_dependencies]]
== Library Dependencies

Dependencies for native components are binary libraries that export header files. The header files are used during compilation, with the compiled binary dependency being used during linking and execution. Header files should be organized into subdirectories to prevent clashes of commonly named headers. For instance, if your `mylib` project has a `logging.h` header, it will make it less likely the wrong header is used if you include it as `""mylib/logging.h""` instead of `""logging.h""`.


[[sec:dependencies_within_the_same_project]]
=== Dependencies within the same project

A set of sources may depend on header files provided by another binary component within the same project. A common example is a native executable component that uses functions provided by a separate native library component.

Such a library dependency can be added to a source set associated with the `executable` component:

=== Example: Providing a library dependency to the source set

[source.multi-language-sample,groovy,indent=0]
.build.gradle
----
include::{samplesPath}/native-binaries/cpp/build.gradle[tag=source-library]
----

Alternatively, a library dependency can be provided directly to the `NativeExecutableBinarySpec` for the `executable`.

=== Example: Providing a library dependency to the binary

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/custom-layout/build.gradle[tag=binary-library]
----


[[sec:project_dependencies]]
=== Project Dependencies

For a component produced in a different Gradle project, the notation is similar.

=== Example: Declaring project dependencies

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/multi-project/build.gradle[tag=project-dependencies]
----


[[native_binaries:preCompiledHeaders]]
== Precompiled Headers

Precompiled headers are a performance optimization that reduces the cost of compiling widely used headers multiple times. This feature _precompiles_ a header such that the compiled object file can be reused when compiling each source file rather than recompiling the header each time. This support is available for C, C+\\+, Objective-C, and Objective-C++ builds.

To configure a precompiled header, first a header file needs to be defined that includes all of the headers that should be precompiled. It must be specified as the first included header in every source file where the precompiled header should be used. It is assumed that this header file, and any headers it contains, make use of header guards so that they can be included in an idempotent manner. If header guards are not used in a header file, it is possible the header could be compiled more than once and could potentially lead to a broken build.

=== Example: Creating a precompiled header file

[source.multi-language-sample,c]
.src/hello/headers/pch.h
----
include::{samplesPath}/native-binaries/pre-compiled-headers/src/hello/headers/pch.h[]
----

=== Example: Including a precompiled header file in a source file

[source.multi-language-sample,cpp]
.src/hello/cpp/hello.cpp
----
include::{samplesPath}/native-binaries/pre-compiled-headers/src/hello/cpp/hello.cpp[]
----

Precompiled headers are specified on a source set. Only one precompiled header file can be specified on a given source set and will be applied to all source files that declare it as the first include. If a source files does not include this header file as the first header, the file will be compiled in the normal manner (without making use of the precompiled header object file). The string provided should be the same as that which is used in the ""#include"" directive in the source files.

=== Example: Configuring a precompiled header

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/pre-compiled-headers/build.gradle[tag=libraries]
----

A precompiled header must be included in the same way for all files that use it. Usually, this means the header file should exist in the source set ""headers"" directory or in a directory included on the compiler include path.

[[native_binaries:variants]]
== Native Binary Variants

For each executable or library defined, Gradle is able to build a number of different native binary variants. Examples of different variants include debug vs release binaries, 32-bit vs 64-bit binaries, and binaries produced with different custom preprocessor flags.

Binaries produced by Gradle can be differentiated on <<#native_binaries:build_type,build type>>, <<#native_binaries:platform,platform>>, and <<#native_binaries:flavor,flavor>>. For each of these 'variant dimensions', it is possible to specify a set of available values as well as target each component at one, some or all of these. For example, a plugin may define a range of support platforms, but you may choose to only target Windows-x86 for a particular component.


[[native_binaries:build_type]]
=== Build types

A `build type` determines various non-functional aspects of a binary, such as whether debug information is included, or what optimisation level the binary is compiled with. Typical build types are 'debug' and 'release', but a project is free to define any set of build types.

=== Example: Defining build types

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/variants/build.gradle[tag=build-types]
----

If no build types are defined in a project, then a single, default build type called 'debug' is added.

For a build type, a Gradle project will typically define a set of compiler/linker flags per tool chain.

=== Example: Configuring debug binaries

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/variants/build.gradle[tag=build-type-config]
----

[NOTE]
====
At this stage, it is completely up to the build script to configure the relevant compiler/linker flags for each build type. Future versions of Gradle will automatically include the appropriate debug flags for any 'debug' build type, and may be aware of various levels of optimisation as well.
====


[[native_binaries:platform]]
=== Platform

An executable or library can be built to run on different operating systems and cpu architectures, with a variant being produced for each platform. Gradle defines each OS/architecture combination as a link:{groovyDslPath}/org.gradle.nativeplatform.platform.NativePlatform.html[NativePlatform], and a project may define any number of platforms. If no platforms are defined in a project, then a single, default platform 'current' is added.

[NOTE]
====
Presently, a `Platform` consists of a defined operating system and architecture. As we continue to develop the native binary support in Gradle, the concept of Platform will be extended to include things like C-runtime version, Windows SDK, ABI, etc. Sophisticated builds may use the extensibility of Gradle to apply additional attributes to each platform, which can then be queried to specify particular includes, preprocessor macros or compiler arguments for a native binary.
====

=== Example: Defining platforms

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/variants/build.gradle[tag=platforms]
----

For a given variant, Gradle will attempt to find a link:{javadocPath}/org/gradle/nativeplatform/toolchain/NativeToolChain.html[NativeToolChain] that is able to build for the target platform. Available tool chains are searched in the order defined. See the <<#native_binaries:tool_chain,tool chains>> section below for more details.

[[native_binaries:flavor]]
=== Flavor

Each component can have a set of named `flavors`, and a separate binary variant can be produced for each flavor. While the `build type` and `target platform` variant dimensions have a defined meaning in Gradle, each project is free to define any number of flavors and apply meaning to them in any way.

An example of component flavors might differentiate between 'demo', 'paid' and 'enterprise' editions of the component, where the same set of sources is used to produce binaries with different functions.

=== Example: Defining flavors

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/flavors/build.gradle[tag=flavors]
----

In the example above, a library is defined with a 'english' and 'french' flavor. When compiling the 'french' variant, a separate macro is defined which leads to a different binary being produced.

If no flavor is defined for a component, then a single default flavor named 'default' is used.

[[sec:selecting_the_build_types_platforms_and_flavors_for_a_component]]
=== Selecting the build types, platforms and flavors for a component

For a default component, Gradle will attempt to create a native binary variant for each and every combination of `buildType` and `flavor` defined for the project. It is possible to override this on a per-component basis, by specifying the set of `targetBuildTypes` and/or `targetFlavors`. By default, Gradle will build for the default platform, see <<#native_binaries:platform,above>>, unless specified explicitly on a per-component basis by specifying a set of `targetPlatforms`.

=== Example: Targeting a component at particular platforms

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/variants/build.gradle[tag=target-platforms]
----

Here you can see that the link:{groovyDslPath}/org.gradle.nativeplatform.TargetedNativeComponent.html#org.gradle.nativeplatform.TargetedNativeComponent:targetPlatform(java.lang.String)[TargetedNativeComponent.targetPlatform(java.lang.String)] method is used to specify a platform that the `NativeExecutableSpec` named `main` should be built for.

A similar mechanism exists for selecting link:{groovyDslPath}/org.gradle.nativeplatform.TargetedNativeComponent.html#org.gradle.nativeplatform.TargetedNativeComponent:targetBuildTypes(java.lang.String++[]++)[TargetedNativeComponent.targetBuildTypes(java.lang.String...)] and link:{groovyDslPath}/org.gradle.nativeplatform.TargetedNativeComponent.html#org.gradle.nativeplatform.TargetedNativeComponent:targetFlavors(java.lang.String++[]++)[TargetedNativeComponent.targetFlavors(java.lang.String...)].

[[sec:building_all_possible_variants]]
=== Building all possible variants

When a set of build types, target platforms, and flavors is defined for a component, a link:{javadocPath}/org/gradle/nativeplatform/NativeBinarySpec.html[NativeBinarySpec] model element is created for every possible combination of these. However, in many cases it is not possible to build a particular variant, perhaps because no tool chain is available to build for a particular platform.

If a binary variant cannot be built for any reason, then the link:{javadocPath}/org/gradle/nativeplatform/NativeBinarySpec.html[NativeBinarySpec] associated with that variant will not be `buildable`. It is possible to use this property to create a task to generate all possible variants on a particular machine.

=== Example: Building all possible variants

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/tool-chains/build.gradle[tag=buildable]
----


[[native_binaries:tool_chain]]
== Tool chains

A single build may utilize different tool chains to build variants for different platforms. To this end, the core 'native-binary' plugins will attempt to locate and make available supported tool chains. However, the set of tool chains for a project may also be explicitly defined, allowing additional cross-compilers to be configured as well as allowing the install directories to be specified.


[[sec:defining_tool_chains]]
=== Defining tool chains

The supported tool chain types are:

* link:{groovyDslPath}/org.gradle.nativeplatform.toolchain.Gcc.html[Gcc]
* link:{groovyDslPath}/org.gradle.nativeplatform.toolchain.Clang.html[Clang]
* link:{groovyDslPath}/org.gradle.nativeplatform.toolchain.VisualCpp.html[VisualCpp]

=== Example: Defining tool chains

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/tool-chains/build.gradle[tag=toolChains]
----

Each tool chain implementation allows for a certain degree of configuration (see the API documentation for more details).

[[sec:using_tool_chains]]
=== Using tool chains

It is not necessary or possible to specify the tool chain that should be used to build. For a given variant, Gradle will attempt to locate a link:{javadocPath}/org/gradle/nativeplatform/toolchain/NativeToolChain.html[NativeToolChain] that is able to build for the target platform. Available tool chains are searched in the order defined.

[NOTE]
====
When a platform does not define an architecture or operating system, the default target of the tool chain is assumed. So if a platform does not define a value for `operatingSystem`, Gradle will find the first available tool chain that can build for the specified `architecture`.
====

The core Gradle tool chains are able to target the following architectures out of the box. In each case, the tool chain will target the current operating system. See the next section for information on cross-compiling for other operating systems.

[cols=""a,a"", options=""header""]
|===
| Tool Chain
| Architectures

| GCC
| x86, x86_64

| Clang
| x86, x86_64

| Visual C++
| x86, x86_64, ia-64
|===

So for GCC running on linux, the supported target platforms are 'linux/x86' and 'linux/x86_64'. For GCC running on Windows via Cygwin, platforms 'windows/x86' and 'windows/x86_64' are supported. (The Cygwin POSIX runtime is not yet modelled as part of the platform, but will be in the future.)

If no target platforms are defined for a project, then all binaries are built to target a default platform named 'current'. This default platform does not specify any `architecture` or `operatingSystem` value, hence using the default values of the first available tool chain.

Gradle provides a _hook_ that allows the build author to control the exact set of arguments passed to a tool chain executable. This enables the build author to work around any limitations in Gradle, or assumptions that Gradle makes. The arguments hook should be seen as a 'last-resort' mechanism, with preference given to truly modelling the underlying domain.

=== Example: Reconfigure tool arguments

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/tool-chains/build.gradle[tag=withArguments]
----


[[sec:crosscompiling_with_gcc]]
=== Cross-compiling with GCC

Cross-compiling is possible with the link:{groovyDslPath}/org.gradle.nativeplatform.toolchain.Gcc.html[Gcc] and link:{groovyDslPath}/org.gradle.nativeplatform.toolchain.Clang.html[Clang] tool chains, by adding support for additional target platforms. This is done by specifying a target platform for a toolchain. For each target platform a custom configuration can be specified.

=== Example: Defining target platforms

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/target-platforms/build.gradle[tag=targetplatforms]
----


[[native_binaries:visual_studio]]
== Visual Studio IDE integration

Gradle has the ability to generate Visual Studio project and solution files for the native components defined in your build. This ability is added by the `visual-studio` plugin. For a multi-project build, all projects with native components (and the root project) should have this plugin applied.

When the `visual-studio` plugin is applied to the root project, a task named `visualStudio` is created, which will generate a Visual Studio solution file containing all components in the build. This solution will include a Visual Studio project for each component, as well as configuring each component to build using Gradle.

A task named `openVisualStudio` is also created by the `visual-studio` plugin when the project is the root project. This task generates the Visual Studio solution and then opens the solution in Visual Studio. This means you can simply run `gradlew openVisualStudio` from the root project to generate and open the Visual Studio solution in one convenient step.

The content of the generated visual studio files can be modified via API hooks, provided by the `visualStudio` extension. Take a look at the 'visual-studio' sample, or see link:{groovyDslPath}/org.gradle.ide.visualstudio.VisualStudioExtension.html#org.gradle.ide.visualstudio.VisualStudioExtension:projects[VisualStudioExtension.getProjects()] and link:{groovyDslPath}/org.gradle.ide.visualstudio.VisualStudioRootExtension.html#org.gradle.ide.visualstudio.VisualStudioRootExtension:solution[VisualStudioRootExtension.getSolution()] in the API documentation for more details.

[[native_binaries:cunit]]
== CUnit support

The Gradle `cunit` plugin provides support for compiling and executing CUnit tests in your native-binary project. For each link:{javadocPath}/org/gradle/nativeplatform/NativeExecutableSpec.html[NativeExecutableSpec] and link:{javadocPath}/org/gradle/nativeplatform/NativeLibrarySpec.html[NativeLibrarySpec] defined in your project, Gradle will create a matching link:{groovyDslPath}/org.gradle.nativeplatform.test.cunit.CUnitTestSuiteSpec.html[CUnitTestSuiteSpec] component, named `${component.name}Test`.


[[sec:cunit_sources]]
=== CUnit sources

Gradle will create a link:{groovyDslPath}/org.gradle.language.c.CSourceSet.html[CSourceSet] named 'cunit' for each link:{groovyDslPath}/org.gradle.nativeplatform.test.cunit.CUnitTestSuiteSpec.html[CUnitTestSuiteSpec] component in the project. This source set should contain the cunit test files for the component under test. Source files can be located in the conventional location (`src/${component.name}Test/cunit`) or can be configured like any other source set.

Gradle initialises the CUnit test registry and executes the tests, utilising some generated CUnit launcher sources. Gradle will expect and call a function with the signature `void gradle_cunit_register()` that you can use to configure the actual CUnit suites and tests to execute.

=== Example: Registering CUnit tests

[source.multi-language-sample,c]
.suite_operators.c
----
include::{samplesPath}/native-binaries/cunit/src/operatorsTest/c/suite_operators.c[]
----

[NOTE]
====
Due to this mechanism, your CUnit sources may not contain a `main` method since this will clash with the method provided by Gradle.
====


[[sec:building_cunit_executables]]
=== Building CUnit executables

A link:{groovyDslPath}/org.gradle.nativeplatform.test.cunit.CUnitTestSuiteSpec.html[CUnitTestSuiteSpec] component has an associated link:{javadocPath}/org/gradle/nativeplatform/NativeExecutableSpec.html[NativeExecutableSpec] or link:{javadocPath}/org/gradle/nativeplatform/NativeLibrarySpec.html[NativeLibrarySpec] component. For each link:{javadocPath}/org/gradle/nativeplatform/NativeBinarySpec.html[NativeBinarySpec] configured for the main component, a matching link:{groovyDslPath}/org.gradle.nativeplatform.test.cunit.CUnitTestSuiteBinarySpec.html[CUnitTestSuiteBinarySpec] will be configured on the test suite component. These test suite binaries can be configured in a similar way to any other binary instance:

=== Example: Configuring CUnit tests

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/cunit/build.gradle[tag=configure-test-binary]
----

[NOTE]
====
Both the CUnit sources provided by your project and the generated launcher require the core CUnit headers and libraries. Presently, this library dependency must be provided by your project for each link:{groovyDslPath}/org.gradle.nativeplatform.test.cunit.CUnitTestSuiteBinarySpec.html[CUnitTestSuiteBinarySpec].
====


[[sec:running_cunit_tests]]
=== Running CUnit tests

For each link:{groovyDslPath}/org.gradle.nativeplatform.test.cunit.CUnitTestSuiteBinarySpec.html[CUnitTestSuiteBinarySpec], Gradle will create a task to execute this binary, which will run all of the registered CUnit tests. Test results will be found in the `__${build.dir}__/test-results` directory.

=== Example: Running CUnit tests

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/cunit/build.gradle[tag=complete-example]
----

.Output of `gradle -q runOperatorsTestFailingCUnitExe`
----
> gradle -q runOperatorsTestFailingCUnitExe
include::{samplesPath}/native-binaries/cunit/completeCUnitExample.out[]
----

NOTE: The code for this example can be found at **`samples/native-binaries/cunit`** in the ‘-all’ distribution of Gradle.


[NOTE]
====

The current support for CUnit is quite rudimentary. Plans for future integration include:

* Allow tests to be declared with Javadoc-style annotations.
* Improved HTML reporting, similar to that available for JUnit.
* Real-time feedback for test execution.
* Support for additional test frameworks.

====


[[native_binaries:google_test]]
== GoogleTest support

The Gradle `google-test` plugin provides support for compiling and executing GoogleTest tests in your native-binary project. For each link:{javadocPath}/org/gradle/nativeplatform/NativeExecutableSpec.html[NativeExecutableSpec] and link:{javadocPath}/org/gradle/nativeplatform/NativeLibrarySpec.html[NativeLibrarySpec] defined in your project, Gradle will create a matching link:{groovyDslPath}/org.gradle.nativeplatform.test.googletest.GoogleTestTestSuiteSpec.html[GoogleTestTestSuiteSpec] component, named `${component.name}Test`.


[[sec:googletest_sources]]
=== GoogleTest sources

Gradle will create a link:{groovyDslPath}/org.gradle.language.cpp.CppSourceSet.html[CppSourceSet] named 'cpp' for each link:{groovyDslPath}/org.gradle.nativeplatform.test.googletest.GoogleTestTestSuiteSpec.html[GoogleTestTestSuiteSpec] component in the project. This source set should contain the GoogleTest test files for the component under test. Source files can be located in the conventional location (`src/${component.name}Test/cpp`) or can be configured like any other source set.

[[sec:building_googletest_executables]]
=== Building GoogleTest executables

A link:{groovyDslPath}/org.gradle.nativeplatform.test.googletest.GoogleTestTestSuiteSpec.html[GoogleTestTestSuiteSpec] component has an associated link:{javadocPath}/org/gradle/nativeplatform/NativeExecutableSpec.html[NativeExecutableSpec] or link:{javadocPath}/org/gradle/nativeplatform/NativeLibrarySpec.html[NativeLibrarySpec] component. For each link:{javadocPath}/org/gradle/nativeplatform/NativeBinarySpec.html[NativeBinarySpec] configured for the main component, a matching link:{groovyDslPath}/org.gradle.nativeplatform.test.googletest.GoogleTestTestSuiteBinarySpec.html[GoogleTestTestSuiteBinarySpec] will be configured on the test suite component. These test suite binaries can be configured in a similar way to any other binary instance:

=== Example: Registering GoogleTest tests

[source.multi-language-sample,groovy]
.build.gradle
----
include::{samplesPath}/native-binaries/google-test/build.gradle[tag=configure-test-binary]
----

NOTE: The code for this example can be found at **`samples/native-binaries/google-test`** in the ‘-all’ distribution of Gradle.

[NOTE]
====
The GoogleTest sources provided by your project require the core GoogleTest headers and libraries. Presently, this library dependency must be provided by your project for each link:{groovyDslPath}/org.gradle.nativeplatform.test.googletest.GoogleTestTestSuiteBinarySpec.html[GoogleTestTestSuiteBinarySpec].
====


[[sec:running_googletest_tests]]
=== Running GoogleTest tests

For each link:{groovyDslPath}/org.gradle.nativeplatform.test.googletest.GoogleTestTestSuiteBinarySpec.html[GoogleTestTestSuiteBinarySpec], Gradle will create a task to execute this binary, which will run all of the registered GoogleTest tests. Test results will be found in the `__${build.dir}__/test-results` directory.
[NOTE]
====

The current support for GoogleTest is quite rudimentary. Plans for future integration include:

* Improved HTML reporting, similar to that available for JUnit.
* Real-time feedback for test execution.
* Support for additional test frameworks.

====
",12118,False,2284.4199342070224,median
"//
// Licensed to the Apache Software Foundation (ASF) under one or more
// contributor license agreements.  See the NOTICE file distributed with
// this work for additional information regarding copyright ownership.
// The ASF licenses this file to You under the Apache License, Version 2.0
// (the ""License""); you may not use this file except in compliance with
// the License.  You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an ""AS IS"" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
Getting Started with Apache NiFi
================================
Apache NiFi Team <dev@nifi.apache.org>
:homepage: http://nifi.apache.org


Who is This Guide For?
----------------------

This guide is written for users who have never used, have had limited exposure to, or only accomplished specific tasks within NiFi.
This guide is not intended to be an exhaustive instruction manual or a reference guide. The
link:user-guide.html[User Guide] provides a great deal of information
and is intended to be a much more exhaustive resource and is very useful as a reference guide, as well.
This guide, in comparison, is intended to provide users with just the information needed in order
to understand how to work with NiFi in order to quickly and easily build powerful and agile dataflows.

Because some of the information in this guide is applicable only for first-time users while other
information may be applicable for those who have used NiFi a bit, this guide is broken up into
several different sections, some of which may not be useful for some readers. Feel free to jump to
the sections that are most appropriate for you.

This guide does expect that the user has a basic understanding of what NiFi is and does not
delve into this level of detail. This level of information can be found in the
link:overview.html[Overview] documentation.




Terminology Used in This Guide
------------------------------

In order to talk about NiFi, there are a few key terms that readers should be familiar with.
We will explain those NiFi-specific terms here, at a high level.


*FlowFile*: Each piece of ""User Data"" (i.e., data that the user brings into NiFi for processing and distribution) is
referred to as a FlowFile. A FlowFile is made up of two parts: Attributes and Content. The Content is the User Data
itself. Attributes are key-value pairs that are associated with the User Data.

*Processor*: The Processor is the NiFi component that is responsible for creating, sending, receiving, transforming, routing,
splitting, merging, and processing FlowFiles. It is the most important building block available to NiFi users to build their
dataflows.


Downloading and Installing NiFi
-------------------------------

NiFi can be downloaded from the link:http://nifi.apache.org/download.html[NiFi Downloads Page]. There are two packaging options
available: a ""tarball"" that is tailored more to Linux and a zip file that is more applicable for Windows users. Mac OS X users
may also use the tarball or can install via Homebrew.

To install via Homebrew, simply run the command `brew install nifi`.

For users who are not running OS X or do not have Homebrew installed, after downloading the version of NiFi that you
would like to use simply extract the archive to the location that you wish to run the application from.

For information on how to configure the instance of NiFi (for example, to configure security, data storage
configuration, or the port that NiFi is running on), see the link:administration-guide.html[Admin Guide].


Starting NiFi
-------------

Once NiFi has been downloaded and installed as described above, it can be started by using the mechanism
appropriate for your operating system.

=== For Windows Users

For Windows users, navigate to the folder where NiFi was installed. Within this folder is a subfolder
named `bin`. Navigate to this subfolder and double-click the `run-nifi.bat` file.

This will launch NiFi and leave it running in the foreground. To shut down NiFi, select the window that
was launched and hold the Ctrl key while pressing C.


=== For Linux/Mac OS X users

For Linux and OS X users, use a Terminal window to navigate to the directory where NiFi was installed.
To run NiFi in the foreground, run `bin/nifi.sh run`. This will leave the application running until
the user presses Ctrl-C. At that time, it will initiate shutdown of the application.

To run NiFi in the background, instead run `bin/nifi.sh start`. This will initiate the application to
begin running. To check the status and see if NiFi is currently running, execute the command `bin/nifi.sh status`.
NiFi can be shutdown by executing the command `bin/nifi.sh stop`.


=== Installing as a Service

Currently, installing NiFi as a service is supported only for Linux and Mac OS X users. To install the application
as a service, navigate to the installation directory in a Terminal window and execute the command `bin/nifi.sh install`
to install the service with the default name `nifi`. To specify a custom name for the service, execute the command
with an optional second argument that is the name of the service. For example, to install NiFi as a service with the
name `dataflow`, use the command `bin/nifi.sh install dataflow`.

Once installed, the service can be started and stopped using the appropriate commands, such as `sudo service nifi start`
and `sudo service nifi stop`. Additionally, the running status can be checked via `sudo service nifi status`.



I Started NiFi. Now What?
-------------------------

Now that NiFi has been started, we can bring up the User Interface (UI) in order to create and monitor our dataflow.
To get started, open a web browser and navigate to `http://localhost:8080/nifi`. The port can be changed by
editing the `nifi.properties` file in the NiFi `conf` directory, but the default port is 8080.

This will bring up the User Interface, which at this point is a blank canvas for orchestrating a dataflow:

image:new-flow.png[""New Flow""]

The UI has multiple tools to create and manage your first dataflow:

image:nifi-toolbar-components.png[""Toolbar Components""]

The Global Menu contains the following options:

image:global-menu.png[""Global Menu""]


=== Adding a Processor

We can now begin creating our dataflow by adding a Processor to our canvas. To do this, drag the Processor icon
(image:iconProcessor.png[""Processor""]) from the top-left of the screen into the middle of the canvas (the graph paper-like
background) and drop it there. This will give us a dialog that allows us to choose which Processor we want to add:

image:add-processor.png[""Add Processor""]

We have quite a few options to choose from. For the sake of becoming oriented with the system, let's say that we
just want to bring in files from our local disk into NiFi. When a developer creates a Processor, the developer can
assign ""tags"" to that Processor. These can be thought of as keywords. We can filter by these tags or by Processor
name by typing into the Filter box in the top-right corner of the dialog. Type in the keywords that you would think
of when wanting to ingest files from a local disk. Typing in keyword ""file"", for instance, will provide us a few
different Processors that deal with files. Filtering by the term ""local"" will narrow down the list pretty quickly,
as well. If we select a Processor from the list,
we will see a brief description of the Processor near the bottom of the dialog. This should tell us exactly what
the Processor does. The description of the *GetFile* Processor tells us that it pulls data from our local disk
into NiFi and then removes the local file. We can then double-click the Processor type or select it and choose the
`Add` button. The Processor will be added to the canvas in the location that it was dropped.

=== Configuring a Processor

Now that we have added the GetFile Processor, we can configure it by right-clicking on the Processor and choosing
the `Configure` menu item. The provided dialog allows us to configure many different options that can be read about
in the link:user-guide.html[User Guide], but for the sake of this guide, we will focus on the Properties tab. Once
the Properties tab has been selected, we are given a list of several different properties that we can configure
for the Processor. The properties that are available depend on the type of Processor and are generally different
for each type. Properties that are in bold are required properties. The Processor cannot be started until all required
properties have been configured. The most important property to configure for GetFile is the directory from which
to pick up files. If we set the directory name to `./data-in`, this will cause the Processor to start picking up
any data in the `data-in` subdirectory of the NiFi Home directory. We can choose to configure several different
Properties for this Processor. If unsure what a particular Property does, we can hover over the Help icon (
image:iconInfo.png[""Help""]
)
next to the Property Name with the mouse in order to read a description of the property. Additionally, the
tooltip that is displayed when hovering over the Help icon will provide the default value for that property,
if one exists, information about whether or not the property supports the Expression Language (see the
<<ExpressionLanguage>> section below), and previously configured values for that property.

In order for this property to be valid, create a directory named `data-in` in the NiFi home directory and then
click the `Ok` button to close the dialog.


=== Connecting Processors

Each Processor has a set of defined ""Relationships"" that it is able to send data to. When a Processor finishes handling
a FlowFile, it transfers it to one of these Relationships. This allows a user to configure how to handle FlowFiles based
on the result of Processing. For example, many Processors define two Relationships: `success` and `failure`. Users are
then able to configure data to be routed through the flow one way if the Processor is able to successfully process
the data and route the data through the flow in a completely different manner if the Processor cannot process the
data for some reason. Or, depending on the use case, it may simply route both relationships to the same route through
the flow.

Now that we have added and configured our GetFile processor and applied the configuration, we can see in the
top-left corner of the Processor an Alert icon (
image:iconAlert.png[Alert]
) signaling that the Processor is not in a valid state. Hovering over this icon, we can see that the `success`
relationship has not been defined. This simply means that we have not told NiFi what to do with the data that the Processor
transfers to the `success` Relationship.

In order to address this, let's add another Processor that we can connect the GetFile Processor to, by following
the same steps above. This time, however, we will simply log the attributes that exist for the FlowFile. To do this,
we will add a LogAttributes Processor.

We can now send the output of the GetFile Processor to the LogAttribute Processor. Hover over the GetFile Processor
with the mouse and a Connection Icon (
image:iconConnection.png[Connection]
) will appear over the middle of the Processor. We can drag this icon from the GetFile Processor to the LogAttribute
Processor. This gives us a dialog to choose which Relationships we want to include for this connection. Because GetFile
has only a single Relationship, `success`, it is automatically selected for us.

Clicking on the Settings tab provides a handful of options for configuring how this Connection should behave:

image:connection-settings.png[Connection Settings]

We can give the Connection a name, if we like. Otherwise, the Connection name will be based on the selected Relationships.
We can also set an expiration for the data. By default, it is set to ""0 sec"" which indicates that the data should not
expire. However, we can change the value so that when data in this Connection reaches a certain age, it will automatically
be deleted (and a corresponding EXPIRE Provenance event will be created).

The backpressure thresholds allow us to specify how full the queue is allowed to become before the source Processor is
no longer scheduled to run. This allows us to handle cases where one Processor is capable of producing data faster than
the next Processor is capable of consuming that data. If the backpressure is configured for each Connection along the way,
the Processor that is bringing data into the system will eventually experience the backpressure and stop bringing in new
data so that our system has the ability to recover.

Finally, we have the Prioritizers on the right-hand side. This allows us to control how the data in this queue is ordered.
We can drag Prioritizers from the ""Available prioritizers"" list to the ""Selected prioritizers"" list in order to activate
the prioritizer. If multiple prioritizers are activated, they will be evaluated such that the Prioritizer listed first
will be evaluated first and if two FlowFiles are determined to be equal according to that Prioritizer, the second Prioritizer
will be used.

For the sake of this discussion, we can simply click `Add` to add the Connection to our graph. We should now see that the Alert
icon has changed to a Stopped icon (
image:iconStop.png[Stopped]
). The LogAttribute Processor, however, is now invalid because its `success` Relationship has not been connected to
anything. Let's address this by signaling that data that is routed to `success` by LogAttribute should be ""Auto Terminated,""
meaning that NiFi should consider the FlowFile's processing complete and ""drop"" the data. To do this, we configure the
LogAttribute Processor. On the Settings tab, in the right-hand side we can check the box next to the `success` Relationship
to Auto Terminate the data. Clicking `OK` will close the dialog and show that both Processors are now stopped.


=== Starting and Stopping Processors

At this point, we have two Processors on our graph, but nothing is happening. In order to start the Processors, we can
click on each one individually and then right-click and choose the `Start` menu item. Alternatively, we can select the first
Processor, and then hold the Shift key while selecting the other Processor in order to select both. Then, we can
right-click and choose the `Start` menu item. As an alternative to using the context menu, we can select the Processors and
then click the Start icon in the Operate palette.

Once started, the icon in the top-left corner of the Processors will change from a stopped icon to a running icon. We can then
stop the Processors by using the Stop icon in the Operate palette or the `Stop` menu item.

Once a Processor has started, we are not able to configure it anymore. Instead, when we right-click on the Processor, we are
given the option to view its current configuration. In order to configure a Processor, we must first stop the Processor and
wait for any tasks that may be executing to finish. The number of tasks currently executing is shown near the top-right
corner of the Processor, but nothing is shown there if there are currently no tasks.


=== Getting More Info for a Processor

With each Processor having the ability to expose multiple different Properties and Relationships, it can be challenging
to remember how all of the different pieces work for each Processor. To address this, you are able to right-click
on a Processor and choose the `Usage` menu item. This will provide you with the Processor's usage information, such as a
description of the Processor, the different Relationships that are available, when the different Relationships are used,
Properties that are exposed by the Processor and their documentation, as well as which FlowFile Attributes (if any) are
expected on incoming FlowFiles and which Attributes (if any) are added to outgoing FlowFiles.


=== Other Components

The toolbar that provides users the ability to drag and drop Processors onto the graph includes several other components
that can be used to build a dataflow. These components include Input and Output Ports, Funnels, Process Groups, and Remote
Process Groups. Due to the intended scope of this document, we will not discuss these elements here, but information is
readily available in the link:user-guide.html#building-dataflow[Building a Dataflow section] of the
link:user-guide.html[User Guide].



What Processors are Available
-----------------------------

In order to create an effective dataflow, the users must understand what types of Processors are available to them.
NiFi contains many different Processors out of the box. These Processors provide capabilities to ingest data from
numerous different systems, route, transform, process, split, and aggregate data, and distribute data to many systems.

The number of Processors that are available increases in nearly each release of NiFi. As a result, we will not attempt
to name each of the Processors that are available, but we will highlight some of the most frequently used Processors,
categorizing them by their functions.

=== Data Transformation
- *CompressContent*: Compress or Decompress Content
- *ConvertCharacterSet*: Convert the character set used to encode the content from one character set to another
- *EncryptContent*: Encrypt or Decrypt Content
- *ReplaceText*: Use Regular Expressions to modify textual Content
- *TransformXml*: Apply an XSLT transform to XML Content
- *JoltTransformJSON*: Apply a JOLT specification to transform JSON Content

=== Routing and Mediation
- *ControlRate*: Throttle the rate at which data can flow through one part of the flow
- *DetectDuplicate*: Monitor for duplicate FlowFiles, based on some user-defined criteria. Often used in conjunction
	with HashContent
- *DistributeLoad*: Load balance or sample data by distributing only a portion of data to each user-defined Relationship
- *MonitorActivity*: Sends a notification when a user-defined period of time elapses without any data coming through a particular
	point in the flow. Optionally send a notification when dataflow resumes.
- *RouteOnAttribute*: Route FlowFile based on the attributes that it contains.
- *ScanAttribute*: Scans the user-defined set of Attributes on a FlowFile, checking to see if any of the Attributes match the terms
  found in a user-defined dictionary.
- *RouteOnContent*: Search Content of a FlowFile to see if it matches any user-defined Regular Expression. If so, the FlowFile is
  routed to the configured Relationship.
- *ScanContent*: Search Content of a FlowFile for terms that are present in a user-defined dictionary and route based on the
	presence or absence of those terms. The dictionary can consist of either textual entries or binary entries.
- *ValidateXml*: Validation XML Content against an XML Schema; routes FlowFile based on whether or not the Content of the FlowFile
	is valid according to the user-defined XML Schema.

=== Database Access
- *ConvertJSONToSQL*: Convert a JSON document into a SQL INSERT or UPDATE command that can then be passed to the PutSQL Processor
- *ExecuteSQL*: Executes a user-defined SQL SELECT command, writing the results to a FlowFile in Avro format
- *PutSQL*: Updates a database by executing the SQL DDM statement defined by the FlowFile's content
- *SelectHiveQL*: Executes a user-defined HiveQL SELECT command against an Apache Hive database, writing the results to a FlowFile in Avro or CSV format
- *PutHiveQL*: Updates a Hive database by executing the HiveQL DDM statement defined by the FlowFile's content

[[AttributeExtraction]]
=== Attribute Extraction
- *EvaluateJsonPath*: User supplies JSONPath Expressions (Similar to XPath, which is used for XML parsing/extraction), and these Expressions
  are then evaluated against the JSON Content to either replace the FlowFile Content or extract the value into the user-named Attribute.
- *EvaluateXPath*: User supplies XPath Expressions, and these Expressions are then evaluated against the XML Content to either
  replace the FlowFile Content or extract the value into the user-named Attribute.
- *EvaluateXQuery*: User supplies an XQuery query, and this query is then evaluated against the XML Content to either replace the FlowFile
  Content or extract the value into the user-named Attribute.
- *ExtractText*: User supplies one or more Regular Expressions that are then evaluated against the textual content of the FlowFile, and the
  values that are extracted are then added as user-named Attributes.
- *HashAttribute*: Performs a hashing function against the concatenation of a user-defined list of existing Attributes.
- *HashContent*: Performs a hashing function against the content of a FlowFile and adds the hash value as an Attribute.
- *IdentifyMimeType*: Evaluates the content of a FlowFile in order to determine what type of file the FlowFile encapsulates. This Processor is
  capable of detecting many different MIME Types, such as images, word processor documents, text, and compression formats just to name
	a few.
- *UpdateAttribute*: Adds or updates any number of user-defined Attributes to a FlowFile. This is useful for adding statically configured values,
  as well as deriving Attribute values dynamically by using the Expression Language. This processor also provides an ""Advanced User Interface,""
	allowing users to update Attributes conditionally, based on user-supplied rules.

=== System Interaction
- *ExecuteProcess*: Runs the user-defined Operating System command. The Process's StdOut is redirected such that the content that is written
  to StdOut becomes the content of the outbound FlowFile. This Processor is a Source Processor - its output is expected to generate a new FlowFile,
	and the system call is expected to receive no input. In order to provide input to the process, use the ExecuteStreamCommand Processor.

- *ExecuteStreamCommand*: Runs the user-defined Operating System command. The contents of the FlowFile are optionally streamed to the StdIn
  of the process. The content that is written to StdOut becomes the content of hte outbound FlowFile. This Processor cannot be used a Source Processor -
	it must be fed incoming FlowFiles in order to perform its work. To perform the same type of functionality with a Source Processor, see the
	ExecuteProcess Processor.

=== Data Ingestion
- *GetFile*: Streams the contents of a file from a local disk (or network-attached disk) into NiFi and then deletes the original file. This
  Processor is expected to move the file from one location to another location and is not to be used for copying the data.
- *GetFTP*: Downloads the contents of a remote file via FTP into NiFi and then deletes the original file. This Processor is expected to move
  the data from one location to another location and is not to be used for copying the data.
- *GetSFTP*: Downloads the contents of a remote file via SFTP into NiFi and then deletes the original file. This Processor is expected to move
  the data from one location to another location and is not to be used for copying the data.
- *GetJMSQueue*: Downloads a message from a JMS Queue and creates a FlowFile based on the contents of the JMS message. The JMS Properties are
  optionally copied over as Attributes, as well.
- *GetJMSTopic*: Downloads a message from a JMS Topic and creates a FlowFile based on the contents of the JMS message. The JMS Properties are
  optionally copied over as Attributes, as well. This Processor supports both durable and non-durable subscriptions.
- *GetHTTP*: Downloads the contents of a remote HTTP- or HTTPS-based URL into NiFi. The Processor will remember the ETag and Last-Modified Date
  in order to ensure that the data is not continually ingested.
- *ListenHTTP*: Starts an HTTP (or HTTPS) Server and listens for incoming connections. For any incoming POST request, the contents of the request
  are written out as a FlowFile, and a 200 response is returned.
- *ListenUDP*: Listens for incoming UDP packets and creates a FlowFile per packet or per bundle of packets (depending on configuration) and
  emits the FlowFile to the 'success' relationship.
- *GetHDFS*: Monitors a user-specified directory in HDFS. Whenever a new file enters HDFS, it is copied into NiFi and deleted from HDFS. This
  Processor is expected to move the file from one location to another location and is not to be used for copying the data. This Processor is also
	expected to be run On Primary Node only, if run within a cluster. In order to copy the data from HDFS and leave it in-tact, or to stream the data
	from multiple nodes in the cluster, see the ListHDFS Processor.
- *ListHDFS* / *FetchHDFS*: ListHDFS monitors a user-specified directory in HDFS and emits a FlowFile containing the filename for each file that it
  encounters. It then persists this state across the entire NiFi cluster by way of a Distributed Cache. These FlowFiles can then be fanned out across
	the cluster and sent to the FetchHDFS Processor, which is responsible for fetching the actual content of those files and emitting FlowFiles that contain
	the content fetched from HDFS.
- *FetchS3Object*: Fetches the contents of an object from the Amazon Web Services (AWS) Simple Storage Service (S3). The outbound FlowFile contains the contents
  received from S3.
- *GetKafka*: Fetches messages from Apache Kafka, specifically for 0.8.x versions. The messages can be emitted as a FlowFile per message or can be batched together using a user-specified delimiter.
- *GetMongo*: Executes a user-specified query against MongoDB and writes the contents to a new FlowFile.
- *GetTwitter*: Allows Users to register a filter to listen to the Twitter ""garden hose"" or Enterprise endpoint, creating a FlowFile for each tweet
  that is received.

=== Data Egress / Sending Data
- *PutEmail*: Sends an E-mail to the configured recipients. The content of the FlowFile is optionally sent as an attachment.
- *PutFile*: Writes the contents of a FlowFile to a directory on the local (or network attached) file system.
- *PutFTP*: Copies the contents of a FlowFile to a remote FTP Server.
- *PutSFTP*: Copies the contents of a FlowFile to a remote SFTP Server.
- *PutJMS*: Sends the contents of a FlowFile as a JMS message to a JMS broker, optionally adding JMS Properties based on Attributes.
- *PutSQL*: Executes the contents of a FlowFile as a SQL DDL Statement (INSERT, UPDATE, or DELETE). The contents of the FlowFile must be a valid
  SQL statement. Attributes can be used as parameters so that the contents of the FlowFile can be parameterized SQL statements in order to avoid
	SQL injection attacks.
- *PutKafka*: Sends the contents of a FlowFile as a message to Apache Kafka, specifically for 0.8.x versions. The FlowFile can be sent as a single message or a delimiter, such as a
  new-line can be specified, in order to send many messages for a single FlowFile.
- *PutMongo*: Sends the contents of a FlowFile to Mongo as an INSERT or an UPDATE.

=== Splitting and Aggregation
- *SplitText*: SplitText takes in a single FlowFile whose contents are textual and splits it into 1 or more FlowFiles based on the configured
  number of lines. For example, the Processor can be configured to split a FlowFile into many FlowFiles, each of which is only 1 line.
- *SplitJson*: Allows the user to split a JSON object that is comprised of an array or many child objects into a FlowFile per JSON element.
- *SplitXml*: Allows the user to split an XML message into many FlowFiles, each containing a segment of the original. This is generally used when
  several XML elements have been joined together with a ""wrapper"" element. This Processor then allows those elements to be split out into individual
	XML elements.
- *UnpackContent*: Unpacks different types of archive formats, such as ZIP and TAR. Each file within the archive is then transferred as a single
  FlowFile.
- *MergeContent*: This Processor is responsible for merging many FlowFiles into a single FlowFile. The FlowFiles can be merged by concatenating their
  content together along with optional header, footer, and demarcator, or by specifying an archive format, such as ZIP or TAR. FlowFiles can be binned
	together based on a common attribute, or can be ""defragmented"" if they were split apart by some other Splitting process. The minimum and maximum
	size of each bin is user-specified, based on number of elements or total size of FlowFiles' contents, and an optional Timeout can be assigned as well
	so that FlowFiles will only wait for their bin to become full for a certain amount of time.
- *SegmentContent*: Segments a FlowFile into potentially many smaller FlowFiles based on some configured data size. The splitting is not performed
  against any sort of demarcator but rather just based on byte offsets. This is used before transmitting FlowFiles in order to provide lower latency
	by sending many different pieces in parallel. On the other side, these FlowFiles can then be reassembled by the MergeContent processor using the
	Defragment mode.
- *SplitContent*: Splits a single FlowFile into potentially many FlowFiles, similarly to SegmentContent. However, with SplitContent, the splitting
  is not performed on arbitrary byte boundaries but rather a byte sequence is specified on which to split the content.

=== HTTP
- *GetHTTP*: Downloads the contents of a remote HTTP- or HTTPS-based URL into NiFi. The Processor will remember the ETag and Last-Modified Date
  in order to ensure that the data is not continually ingested.
- *ListenHTTP*: Starts an HTTP (or HTTPS) Server and listens for incoming connections. For any incoming POST request, the contents of the request
  are written out as a FlowFile, and a 200 response is returned.
- *InvokeHTTP*: Performs an HTTP Request that is configured by the user. This Processor is much more versatile than the GetHTTP and PostHTTP
  but requires a bit more configuration. This Processor cannot be used as a Source Processor and is required to have incoming FlowFiles in order
	to be triggered to perform its task.
- *PostHTTP*: Performs an HTTP POST request, sending the contents of the FlowFile as the body of the message. This is often used in conjunction
  with ListenHTTP in order to transfer data between two different instances of NiFi in cases where Site-to-Site cannot be used (for instance,
	when the nodes cannot access each other directly and are able to communicate through an HTTP proxy).
	*Note*: HTTP is available as a link:user-guide.html#site-to-site[Site-to-Site] transport protocol in addition to the existing RAW socket transport. It also supports HTTP Proxy. Using HTTP Site-to-Site is recommended since it's more scalable, and can provide bi-directional data transfer using input/output ports with better user authentication and authorization.
- *HandleHttpRequest* / *HandleHttpResponse*: The HandleHttpRequest Processor is a Source Processor that starts an embedded HTTP(S) server
  similarly to ListenHTTP. However, it does not send a response to the client. Instead, the FlowFile is sent out with the body of the HTTP request
	as its contents and attributes for all of the typical Servlet parameters, headers, etc. as Attributes. The HandleHttpResponse then is able to
	send a response back to the client after the FlowFile has finished being processed. These Processors are always expected to be used in conjunction
	with one another and allow the user to visually create a Web Service within NiFi. This is particularly useful for adding a front-end to a non-web-
  based protocol or to add a simple web service around some functionality that is already performed by NiFi, such as data format conversion.

=== Amazon Web Services
- *FetchS3Object*: Fetches the content of an object stored in Amazon Simple Storage Service (S3). The content that is retrieved from S3
  is then written to the content of the FlowFile.
- *PutS3Object*: Writes the contents of a FlowFile to an Amazon S3 object using the configured credentials, key, and bucket name.
- *PutSNS*: Sends the contents of a FlowFile as a notification to the Amazon Simple Notification Service (SNS).
- *GetSQS*: Pulls a message from the Amazon Simple Queuing Service (SQS) and writes the contents of the message to the content of the FlowFile.
- *PutSQS*: Sends the contents of a FlowFile as a message to the Amazon Simple Queuing Service (SQS).
- *DeleteSQS*: Deletes a message from the Amazon Simple Queuing Service (SQS). This can be used in conjunction with the GetSQS in order to receive
  a message from SQS, perform some processing on it, and then delete the object from the queue only after it has successfully completed processing.


Working With Attributes
-----------------------
Each FlowFile is created with several Attributes, and these Attributes will change over the life of
the FlowFile. The concept of a FlowFile is extremely powerful and provides three primary benefits.
First, it allows the user to make routing decisions in the flow so that FlowFiles that meet some criteria
can be handled differently than other FlowFiles. This is done using the RouteOnAttribute and similar Processors.

Secondly, Attributes are used in order to configure Processors in such a way that the configuration of the
Processor is dependent on the data itself. For instance, the PutFile Processor is able to use the Attributes in order
to know where to store each FlowFile, while the directory and filename Attributes may be different for each FlowFile.

Finally, the Attributes provide extremely valuable context about the data. This is useful when reviewing the Provenance
data for a FlowFile. This allows the user to search for Provenance data that match specific criteria, and it also allows
the user to view this context when inspecting the details of a Provenance Event. By doing this, the user is then able
to gain valuable insight as to why the data was processed one way or another, simply by glancing at this context that is
carried along with the content.

=== Common Attributes

Each FlowFile has a minimum set of Attributes:

	- *filename*: A filename that can be used to store the data to a local or remote file system.
	- *path*: The name of a directory that can be used to store the data to a local or remote file system.
	- *uuid*: A Universally Unique Identifier that distinguishes the FlowFile from other FlowFiles in the system.
	- *entryDate*: The date and time at which the FlowFile entered the system (i.e., was created). The value of this
		attribute is a number that represents the number of milliseconds since midnight, Jan. 1, 1970 (UTC).
	- *lineageStartDate*: Any time that a FlowFile is cloned, merged, or split, this results in a ""child"" FlowFile being
		created. As those children are then cloned, merged, or split, a chain of ancestors is built. This value represents
		the date and time at which the oldest ancestor entered the system. Another way to think about this is that this
		attribute represents the latency of the FlowFile through the system. The value is a number that represents the number
		of milliseconds since midnight, Jan. 1, 1970 (UTC).
	- *fileSize*: This attribute represents the number of bytes taken up by the FlowFile's Content.

Note that the `uuid`, `entryDate`, `lineageStartDate`, and `fileSize` attributes are system-generated and cannot be changed.

=== Extracting Attributes

NiFi provides several different Processors out of the box for extracting Attributes from FlowFiles. A list of commonly used
Processors for this purpose can be found above in the <<AttributeExtraction>> section. This is a very common use case for building
custom Processors, as well. Many Processors are written to understand a specific data format and extract pertinent information from
a FlowFile's content, creating Attributes to hold that information, so that decisions can then be made about how to route or
process the data.

=== Adding User-Defined Attributes

In addition to having Processors that are able to extract particular pieces of information from FlowFile content into Attributes,
it is also common for users to want to add their own user-defined Attributes to each FlowFile at a particular place in the flow.
The UpdateAttribute Processor is designed specifically for this purpose. Users are able to add a new property to the Processor
in the Configure dialog by clicking the ""+"" button in the top-right corner of the Properties tab. The user is then
prompted to enter the name of the property and then a value. For each FlowFile that is processed by this UpdateAttribute
Processor, an Attribute will be added for each user-defined property. The name of the Attribute will be the same as the name of
the property that was added. The value of the Attribute will be the same as the value of the property.

The value of the property may contain the Expression Language, as well. This allows Attributes to be modified or added
based on other Attributes. For example, if we want to prepend the hostname that is processing a file as well as the date to
a filename, we could do this by adding a property with the name `filename` and the value `${hostname()}-${now():format('yyyy-dd-MM')}-${filename}`.
While this may seem confusing at first, the section below on <<ExpressionLanguage>> will help to clear up what is going on
here.

In addition to always adding a defined set of Attributes, the UpdateAttribute Processor has an Advanced UI that allows the user
to configure a set of rules for which Attributes should be added when. To access this capability, in the Configure dialog's
Properties tab, click the `Advanced` button at the bottom of the dialog. This will provide a UI that is tailored specifically
to this Processor, rather than the simple Properties table that is provided for all Processors. Within this UI, the user is able
to configure a rules engine, essentially, specifying rules that must match in order to have the configured Attributes added
to the FlowFile.

=== Routing on Attributes

One of the most powerful features of NiFi is the ability to route FlowFiles based on their Attributes. The primary mechanism
for doing this is the RouteOnAttribute Processor. This Processor, like UpdateAttribute, is configured by adding user-defined properties.
Any number of properties can be added by clicking the ""+"" button in the top-right corner of the Properties tab in the
Processor's Configure dialog.

Each FlowFile's Attributes will be compared against the configured properties to determine whether or not the FlowFile meets the
specified criteria. The value of each property is expected to be an Expression Language expression and return a boolean value.
For more on the Expression Language, see the <<ExpressionLanguage>> section below.

After evaluating the Expression Language expressions provided against the FlowFile's Attributes, the Processor determines how to
route the FlowFile based on the Routing Strategy selected. The most common strategy is the ""Route to Property name"" strategy. With this
strategy selected, the Processor will expose a Relationship for each property configured. If the FlowFile's Attributes satisfy the given
expression, a copy of the FlowFile will be routed to the corresponding Relationship. For example, if we had a new property with the name
""begins-with-r"" and the value ""${filename:startsWith(\\'r')}"" then any FlowFile whose filename starts with the letter 'r' will be routed
to that Relationship. All other FlowFiles will be routed to 'unmatched'.


[[ExpressionLanguage]]
=== Expression Language / Using Attributes in Property Values

As we extract Attributes from FlowFiles' contents and add user-defined Attributes, they don't do us much good as an operator unless
we have some mechanism by which we can use them. The NiFi Expression Language allows us to access and manipulate FlowFile Attribute
values as we configure our flows. Not all Processor properties allow the Expression Language to be used, but many do. In order to
determine whether or not a property supports the Expression Language, a user can hover over the Help icon (
image:iconInfo.png[""Help""]
) in the Properties tab of the Processor Configure dialog. This will provide a tooltip that shows a description of the property, the
default value, if any, and whether or not the property supports the Expression Language.

For properties that do support the Expression Language, it is used by adding an expression within the opening `${` tag and the closing
`}` tag. An expression can be as simple as an attribute name. For example, to reference the `uuid` Attribute, we can simply use the
value `${uuid}`. If the Attribute name begins with any character other than a letter, or if it contains a character other than
a number, a letter, a period (.), or an underscore (_), the Attribute name will need to be quoted. For example, `${My Attribute Name}`
will be invalid, but `${'My Attribute Name'}` will refer to the Attribute `My Attribute Name`.

In addition to referencing Attribute values, we can perform a number of functions and comparisons on those Attributes. For example,
if we want to check if the `filename` attribute contains the letter 'r' without paying attention to case (upper case or lower case),
we can do this by using the expression `${filename:toLower():contains('r')}`. Note here that the functions are separated by colons.
We can chain together any number of functions to build up more complex expressions. It is also important to understand here that even
though we are calling `filename:toLower()`, this does not alter the value of the `filename` Attribute in anyway but rather just gives
us a new value to work with.

We can also embed one expression within another. For example, if we wanted to compare the value of the `attr1` Attribute to
the value of the `attr2` Attribute, we can do this with the following expression: `${attr1:equals( ${attr2} )}`.

The Expression Language contains many different functions that can be used in order to perform the tasks needed for routing and manipulating
Attributes. Functions exist for parsing and manipulating strings, comparing string and numeric values, manipulating and replacing values,
and comparing values. A full explanation of the different functions available is out of the scope of this document, but the
link:expression-language-guide.html[Expression Language Guide] provides far greater detail for each of the functions.

In addition, this Expression Language guide is built in to the application so that users are able to easily see which functions are available
and see their documentation while typing. When setting the value of a property that supports the Expression Language, if the cursor is within
the Expression Language start and end tags, pressing Ctrl + Space on the keyword will provide a pop-up of all of the available functions and
will provide auto-complete functionality. Clicking on or using the keyboard to navigate to one of the functions listed in the pop-up will
cause a tooltip to show, which explains what the function does, the arguments that it expects, and the return type of the function.



Custom Properties Within Expression Language
--------------------------------------------

In addition to using FlowFile attributes, you can also define custom properties for Expression Language use. Defining custom properties gives you additional flexibility in processing and configuring dataflows. For example, you can refer to custom properties for connection, server, and service properties. Once you have created custom properties, you can identify their location in the `nifi.variable.registry.properties` field in the 'nifi.properties' file. After you have updated the 'nifi.properties' file and restarted NiFi, you are able to use custom properties as needed.


Working With Templates
----------------------

As we use Processors to build more and more complex dataflows in NiFi, we often will find that we string together the same sequence
of Processors to perform some task. This can become tedious and inefficient. To address this, NiFi provides a concept of Templates.
A template can be thought of as a reusable sub-flow. To create a template, follow these steps:

- Select the components to include in the template. We can select multiple components by clicking on the first component and then holding
  the Shift key while selecting additional components (to include the Connections between those components), or by holding the Shift key
	while dragging a box around the desired components on the canvas.
- Select the Create Template Icon (
	image:iconNewTemplate.png[New Template Icon]
	) from the Operate palette.
- Provide a name and optionally a description for the template.
- Click the `Create` button.

Once we have created a template, we can now use it as a building block in our flow, just as we would a Processor. To do this, we will
click and drag the Template icon (
	image:iconTemplate.png[Template]
	) from the Component toolbar onto our canvas. We can then choose the template that we would like to add
to our canvas and click the `Add` button.

Finally, we have the ability to manage our templates by using the Template Management dialog. To access this dialog, select Templates
from the Global Menu. From here, we can see which templates exist and filter the templates to find the templates of interest.
On the right-hand side of the table is an icon to Export, or Download, the template as an XML file. This can then be provided to others so
that they can use your template.

To import a template into your NiFi instance, select the Upload Template icon (
	image:iconUploadTemplate.png[Upload Template]
	) from the Operator palette, click the Search Icon and navigate to the file on
your computer. Then click the `Upload` button. The template will now show up in your table, and you can drag it onto your canvas as you would
any other template that you have created.

There are a few important notes to remember when working with templates:

- Any properties that are identified as being Sensitive Properties (such as a password that is configured in a Processor) will not be added to the template. These sensitive properties will have to be populated each time that the template is added to the canvas.
- If a component that is included in the template references a Controller Service, the Controller Service will also be added to the template. This means that each time that the template is added to the graph, it will create a copy of the Controller Service.


Monitoring NiFi
---------------

As data flows through your dataflow in NiFi, it is important to understand how well your system is performing in order to assess if you
will require more resources and in order to assess the health of your current resources. NiFi provides a few mechanisms for monitoring
your system.

=== Status Bar

Near the top of the NiFi screen under the Component toolbar is a bar that is referred to as the Status Bar. It contains a few important statistics about the current
health of NiFi. The number of Active Threads can indicate how hard NiFi is currently working, and the Queued stat indicates how many FlowFiles
are currently queued across the entire flow, as well as the total size of those FlowFiles.

If the NiFi instance is in a cluster, we will also see an indicator here telling us how many nodes are in the cluster and how many are currently
connected. In this case, the number of active threads and the queue size are indicative of all the sum of all nodes that are currently connected.

=== Component Statistics

Each Processor, Process Group, and Remote Process Group on the canvas provides several statistics about how much data has been processed
by the component. These statistics provide information about how much data has been processed in the past five minutes. This is a rolling
window and allows us to see things like the number of FlowFiles that have been consumed by a Processor, as well as the number of FlowFiles
that have been emitted by the Processor.

The connections between Processors also expose the number of items that are currently queued.

It may also be valuable to see historical values for these metrics and, if clustered, how the different nodes compare to one another.
In order to see this information, we can right-click on a component and choose the `Stats` menu item. This will show us a graph that spans
the time since NiFi was started, or up to 24 hours, whichever is less. The amount of time that is shown here can be extended or reduced
by changing the configuration in the properties file.

In the top-right corner of this dialog is a drop-down that allows the user to select which metric they are viewing. The graph on the bottom allows the
user to select a smaller portion of the graph to zoom in.


=== Bulletins

In addition to the statistics provided by each component, a user will want to know if any problems occur. While we could monitor the
logs for anything interesting, it is much more convenient to have notifications pop up on the screen. If a Processor logs
anything as a WARNING or ERROR, we will see a ""Bulletin Indicator"" show up in the top-right-hand corner of the Processor. This indicator
looks like a sticky note and will be shown for five minutes after the event occurs. Hovering over the bulletin provides information about
what happened so that the user does not have to sift through log messages to find it. If in a cluster, the bulletin will also indicate which
node in the cluster emitted the bulletin. We can also change the log level at which bulletins will occur in the Settings tab of the Configure
dialog for a Processor.

If the framework emits a bulletin, we will also see a bulletin indicator highlighted at the top-right of the screen.
In the Global Menu is a Bulletin Board option. Clicking this option will take us to the bulletin board where we can see all bulletins that occur across the NiFi instance and can filter based on the component, the message, etc.


Data Provenance
---------------

NiFi keeps a very granular level of detail about each piece of data that it ingests. As the data is processed through
the system and is transformed, routed, split, aggregated, and distributed to other endpoints, this information is
all stored within NiFi's Provenance Repository. In order to search and view this information, we can select Data Provenance from the Global Menu. This will provide us a table that lists
the Provenance events that we have searched for:

image:provenance-table.png[Provenance Table]

Initially, this table is populated with the most recent 1,000 Provenance Events that have occurred (though it may take a few
seconds for the information to be processed after the events occur). From this dialog, there is a `Search` button that allows the
user to search for events that happened by a particular Processor, for a particular FlowFile by filename or UUID, or several other
fields. The `nifi.properties` file provides the ability to configure which of these properties are indexed, or made searchable.
Additionally, the properties file also allows you to choose specific FlowFile Attributes that will be indexed. As a result, you can
choose which Attributes will be important to your specific dataflows and make those Attributes searchable.

[[EventDetails]]
=== Event Details
Once we have performed our search, our table will be populated only with the events that match the search criteria. From here, we
can choose the Info icon (
image:iconDetails.png[Details Icon]
) on the left-hand side of the table to view the details of that event:

image:event-details.png[Event Details]

From here, we can see exactly when that event occurred, which FlowFile the event affected, which component (Processor, etc.) performed the event,
how long the event took, and the overall time that the data had been in NiFi when the event occurred (total latency).

The next tab provides a listing of all Attributes that existed on the FlowFile at the time that the event occurred:

image:event-attributes.png[Event Attributes]

From here, we can see all the Attributes that existed on the FlowFile when the event occurred, as well as the previous values for those
Attributes. This allows us to know which Attributes changed as a result of this event and how they changed. Additionally, in the right-hand
corner is a checkbox that allows the user to see only those Attributes that changed. This may not be particularly useful if the FlowFile has
only a handful of Attributes, but can be very helpful when a FlowFile has hundreds of Attributes.

This is very important because it allows the user to understand the exact context in which the FlowFile was processed. It is helpful
to understand 'why' the FlowFile was processed the way that it was, especially when the Processor was configured using the Expression Language.

Finally, we have the Content tab:

image:event-content.png[Event Content]

This tab provides us information about where in the Content Repository the FlowFile's content was stored. If the event modified the content
of the FlowFile, we will see the 'before' (input) and 'after' (output) content claims. We are then given the option to Download the content or to View the
content within NiFi itself, if the data format is one that NiFi understands how to render.

Additionally, in the Replay section of the tab, there is a 'Replay' button that allows the user to re-insert the FlowFile into the flow and re-process it from exactly the point
at which the event happened. This provides a very powerful mechanism, as we are able to modify our flow in real time, re-process a FlowFile,
and then view the results. If they are not as expected, we can modify the flow again, and re-process the FlowFile again. We are able to perform
this iterative development of the flow until it is processing the data exactly as intended.

=== Lineage Graph

In addition to viewing the details of a Provenance event, we can also view the lineage of the FlowFile involved by clicking on the Lineage Icon (
image:iconLineage.png[Lineage]
) from the table view.

This provides us with a graphical representation of exactly what happened to that piece of data as it traversed the system:

image:lineage-graph-annotated.png[Lineage Graph]

From here, we can right-click on any of the events represented and click the `View Details` menu item to see the <<EventDetails>>.
This graphical representation shows us exactly which events occurred to the data. There are a few ""special"" event types to be
aware of. If we see a JOIN, FORK, or CLONE event, we can right-click and choose to Find Parents or Expand. This allows us to
see the lineage of parent FlowFiles and children FlowFiles that were created as well.

The slider in the bottom-left corner allows us to see the time at which these events occurred. By sliding it left and right, we can
see which events introduced latency into the system so that we have a very good understanding of where in our system we may need to
provide more resources, such as the number of Concurrent Tasks for a Processor. Or it may reveal, for example, that most of the latency
was introduced by a JOIN event, in which we were waiting for more FlowFiles to join together. In either case, the ability to easily
see where this is occurring is a very powerful feature that will help users to understand how the enterprise is operating.


Where To Go For More Information
--------------------------------

The NiFi community has built up a significant amount of documentation on how to use the software. The following guides are available, in
addition to this Getting Started Guide:

- link:overview.html[Apache NiFi Overview] - Provides an overview of what Apache NiFi is, what it does, and why it was created.
- link:user-guide.html[Apache NiFi User Guide] - A fairly extensive guide that is often used more as a Reference Guide, as it has pretty
  lengthy discussions of all of the different components that comprise the application. This guide is written with the NiFi Operator as its
	audience. It provides information on each of the different components available in NiFi and explains how to use the different features
	provided by the application.
- link:administration-guide.html[Administration Guide] - A guide for setting up and administering Apache NiFi for production environments.
  This guide provides information about the different system-level settings, such as setting up clusters of NiFi and securing access to the
	web UI and data.
- link:expression-language-guide.html[Expression Language Guide] - A far more exhaustive guide for understanding the Expression Language than
  is provided above. This guide is the definitive documentation for the NiFi Expression Language. It provides an introduction to the EL
	and an explanation of each function, its arguments, and return types as well as providing examples.
- link:developer-guide.html[Developer's Guide] - While not an exhaustive guide to All Things NiFi Development, this guide does provide a
  comprehensive overview of the different API's available and how they should be used. In addition, it provides Best Practices for developing
	NiFi components and common Processor idioms to help aid in understanding the logic behind many of the existing NiFi components.
- link:https://cwiki.apache.org/confluence/display/NIFI/Contributor+Guide[Contributor's Guide] - A guide for explaining how to contribute
  work back to the Apache NiFi community so that others can make use of it.

Several blog postings have also been added to the Apache NiFi blog site:
link:https://blogs.apache.org/nifi/[https://blogs.apache.org/nifi/]

In addition to the blog and guides provided here, you can browse the different
link:https://nifi.apache.org/mailing_lists.html[NiFi Mailing Lists] or send an e-mail to one of the mailing lists at
link:mailto:users@nifi.apache.org[users@nifi.apache.org] or
link:mailto:dev@nifi.apache.org[dev@nifi.apache.org].

Many of the members of the NiFi community are also available on Twitter and actively monitor for tweets that mention @apachenifi.
",12350,False,2061.0048930155335,median
"[[analysis-lang-analyzer]]
=== Language Analyzers

A set of analyzers aimed at analyzing specific language text. The
following types are supported:
<<arabic-analyzer,`arabic`>>,
<<armenian-analyzer,`armenian`>>,
<<basque-analyzer,`basque`>>,
<<bengali-analyzer,`bengali`>>,
<<brazilian-analyzer,`brazilian`>>,
<<bulgarian-analyzer,`bulgarian`>>,
<<catalan-analyzer,`catalan`>>,
<<cjk-analyzer,`cjk`>>,
<<czech-analyzer,`czech`>>,
<<danish-analyzer,`danish`>>,
<<dutch-analyzer,`dutch`>>,
<<english-analyzer,`english`>>,
<<finnish-analyzer,`finnish`>>,
<<french-analyzer,`french`>>,
<<galician-analyzer,`galician`>>,
<<german-analyzer,`german`>>,
<<greek-analyzer,`greek`>>,
<<hindi-analyzer,`hindi`>>,
<<hungarian-analyzer,`hungarian`>>,
<<indonesian-analyzer,`indonesian`>>,
<<irish-analyzer,`irish`>>,
<<italian-analyzer,`italian`>>,
<<latvian-analyzer,`latvian`>>,
<<lithuanian-analyzer,`lithuanian`>>,
<<norwegian-analyzer,`norwegian`>>,
<<persian-analyzer,`persian`>>,
<<portuguese-analyzer,`portuguese`>>,
<<romanian-analyzer,`romanian`>>,
<<russian-analyzer,`russian`>>,
<<sorani-analyzer,`sorani`>>,
<<spanish-analyzer,`spanish`>>,
<<swedish-analyzer,`swedish`>>,
<<turkish-analyzer,`turkish`>>,
<<thai-analyzer,`thai`>>.

==== Configuring language analyzers

===== Stopwords

All analyzers support setting custom `stopwords` either internally in
the config, or by using an external stopwords file by setting
`stopwords_path`. Check <<analysis-stop-analyzer,Stop Analyzer>> for
more details.

===== Excluding words from stemming

The `stem_exclusion` parameter allows you to specify an array
of lowercase words that should not be stemmed.  Internally, this
functionality is implemented by adding the
<<analysis-keyword-marker-tokenfilter,`keyword_marker` token filter>>
with the `keywords` set to the value of the `stem_exclusion` parameter.

The following analyzers support setting custom `stem_exclusion` list:
`arabic`, `armenian`, `basque`, `bengali`, `bulgarian`, `catalan`, `czech`,
`dutch`, `english`, `finnish`, `french`, `galician`,
`german`, `hindi`, `hungarian`, `indonesian`, `irish`, `italian`, `latvian`,
`lithuanian`, `norwegian`, `portuguese`, `romanian`, `russian`, `sorani`,
`spanish`, `swedish`, `turkish`.

==== Reimplementing language analyzers

The built-in language analyzers can be reimplemented as `custom` analyzers
(as described below) in order to customize their behaviour.

NOTE: If you do not intend to exclude words from being stemmed (the
equivalent of the `stem_exclusion` parameter above), then you should remove
the `keyword_marker` token filter from the custom analyzer configuration.

[[arabic-analyzer]]
===== `arabic` analyzer

The `arabic` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /arabic_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""arabic_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_arabic_"" <1>
        },
        ""arabic_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""مثال""] <2>
        },
        ""arabic_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""arabic""
        }
      },
      ""analyzer"": {
        ""rebuilt_arabic"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""lowercase"",
            ""decimal_digit"",
            ""arabic_stop"",
            ""arabic_normalization"",
            ""arabic_keywords"",
            ""arabic_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""arabic_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: arabic_example, first: arabic, second: rebuilt_arabic}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[armenian-analyzer]]
===== `armenian` analyzer

The `armenian` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /armenian_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""armenian_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_armenian_"" <1>
        },
        ""armenian_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""օրինակ""] <2>
        },
        ""armenian_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""armenian""
        }
      },
      ""analyzer"": {
        ""rebuilt_armenian"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""lowercase"",
            ""armenian_stop"",
            ""armenian_keywords"",
            ""armenian_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""armenian_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: armenian_example, first: armenian, second: rebuilt_armenian}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[basque-analyzer]]
===== `basque` analyzer

The `basque` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /basque_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""basque_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_basque_"" <1>
        },
        ""basque_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""Adibidez""] <2>
        },
        ""basque_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""basque""
        }
      },
      ""analyzer"": {
        ""rebuilt_basque"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""lowercase"",
            ""basque_stop"",
            ""basque_keywords"",
            ""basque_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""basque_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: basque_example, first: basque, second: rebuilt_basque}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[bengali-analyzer]]
===== `bengali` analyzer

The `bengali` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /bengali_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""bengali_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_bengali_"" <1>
        },
        ""bengali_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""উদাহরণ""] <2>
        },
        ""bengali_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""bengali""
        }
      },
      ""analyzer"": {
        ""rebuilt_bengali"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""lowercase"",
            ""decimal_digit"",
            ""bengali_keywords"",
            ""indic_normalization"",
            ""bengali_normalization"",
            ""bengali_stop"",
            ""bengali_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""bengali_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: bengali_example, first: bengali, second: rebuilt_bengali}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[brazilian-analyzer]]
===== `brazilian` analyzer

The `brazilian` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /brazilian_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""brazilian_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_brazilian_"" <1>
        },
        ""brazilian_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""exemplo""] <2>
        },
        ""brazilian_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""brazilian""
        }
      },
      ""analyzer"": {
        ""rebuilt_brazilian"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""lowercase"",
            ""brazilian_stop"",
            ""brazilian_keywords"",
            ""brazilian_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""brazilian_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: brazilian_example, first: brazilian, second: rebuilt_brazilian}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[bulgarian-analyzer]]
===== `bulgarian` analyzer

The `bulgarian` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /bulgarian_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""bulgarian_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_bulgarian_"" <1>
        },
        ""bulgarian_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""пример""] <2>
        },
        ""bulgarian_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""bulgarian""
        }
      },
      ""analyzer"": {
        ""rebuilt_bulgarian"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""lowercase"",
            ""bulgarian_stop"",
            ""bulgarian_keywords"",
            ""bulgarian_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""bulgarian_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: bulgarian_example, first: bulgarian, second: rebuilt_bulgarian}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[catalan-analyzer]]
===== `catalan` analyzer

The `catalan` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /catalan_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""catalan_elision"": {
          ""type"":       ""elision"",
          ""articles"":   [ ""d"", ""l"", ""m"", ""n"", ""s"", ""t""],
          ""articles_case"": true
        },
        ""catalan_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_catalan_"" <1>
        },
        ""catalan_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""exemple""] <2>
        },
        ""catalan_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""catalan""
        }
      },
      ""analyzer"": {
        ""rebuilt_catalan"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""catalan_elision"",
            ""lowercase"",
            ""catalan_stop"",
            ""catalan_keywords"",
            ""catalan_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""catalan_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: catalan_example, first: catalan, second: rebuilt_catalan}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[cjk-analyzer]]
===== `cjk` analyzer

The `cjk` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /cjk_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""english_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  [ <1>
            ""a"", ""and"", ""are"", ""as"", ""at"", ""be"", ""but"", ""by"", ""for"",
            ""if"", ""in"", ""into"", ""is"", ""it"", ""no"", ""not"", ""of"", ""on"",
            ""or"", ""s"", ""such"", ""t"", ""that"", ""the"", ""their"", ""then"",
            ""there"", ""these"", ""they"", ""this"", ""to"", ""was"", ""will"",
            ""with"", ""www""
          ]
        }
      },
      ""analyzer"": {
        ""rebuilt_cjk"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""cjk_width"",
            ""lowercase"",
            ""cjk_bigram"",
            ""english_stop""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""cjk_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: cjk_example, first: cjk, second: rebuilt_cjk}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters. The default stop words are
    *almost* the same as the `_english_` set, but not exactly
    the same.

[[czech-analyzer]]
===== `czech` analyzer

The `czech` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /czech_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""czech_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_czech_"" <1>
        },
        ""czech_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""příklad""] <2>
        },
        ""czech_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""czech""
        }
      },
      ""analyzer"": {
        ""rebuilt_czech"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""lowercase"",
            ""czech_stop"",
            ""czech_keywords"",
            ""czech_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""czech_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: czech_example, first: czech, second: rebuilt_czech}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[danish-analyzer]]
===== `danish` analyzer

The `danish` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /danish_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""danish_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_danish_"" <1>
        },
        ""danish_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""eksempel""] <2>
        },
        ""danish_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""danish""
        }
      },
      ""analyzer"": {
        ""rebuilt_danish"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""lowercase"",
            ""danish_stop"",
            ""danish_keywords"",
            ""danish_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""danish_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: danish_example, first: danish, second: rebuilt_danish}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[dutch-analyzer]]
===== `dutch` analyzer

The `dutch` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /dutch_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""dutch_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_dutch_"" <1>
        },
        ""dutch_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""voorbeeld""] <2>
        },
        ""dutch_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""dutch""
        },
        ""dutch_override"": {
          ""type"":       ""stemmer_override"",
          ""rules"": [
            ""fiets=>fiets"",
            ""bromfiets=>bromfiets"",
            ""ei=>eier"",
            ""kind=>kinder""
          ]
        }
      },
      ""analyzer"": {
        ""rebuilt_dutch"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""lowercase"",
            ""dutch_stop"",
            ""dutch_keywords"",
            ""dutch_override"",
            ""dutch_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""dutch_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: dutch_example, first: dutch, second: rebuilt_dutch}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[english-analyzer]]
===== `english` analyzer

The `english` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /english_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""english_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_english_"" <1>
        },
        ""english_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""example""] <2>
        },
        ""english_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""english""
        },
        ""english_possessive_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""possessive_english""
        }
      },
      ""analyzer"": {
        ""rebuilt_english"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""english_possessive_stemmer"",
            ""lowercase"",
            ""english_stop"",
            ""english_keywords"",
            ""english_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""english_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: english_example, first: english, second: rebuilt_english}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[finnish-analyzer]]
===== `finnish` analyzer

The `finnish` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /finnish_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""finnish_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_finnish_"" <1>
        },
        ""finnish_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""esimerkki""] <2>
        },
        ""finnish_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""finnish""
        }
      },
      ""analyzer"": {
        ""rebuilt_finnish"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""lowercase"",
            ""finnish_stop"",
            ""finnish_keywords"",
            ""finnish_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""finnish_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: finnish_example, first: finnish, second: rebuilt_finnish}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[french-analyzer]]
===== `french` analyzer

The `french` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /french_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""french_elision"": {
          ""type"":         ""elision"",
          ""articles_case"": true,
          ""articles"": [
              ""l"", ""m"", ""t"", ""qu"", ""n"", ""s"",
              ""j"", ""d"", ""c"", ""jusqu"", ""quoiqu"",
              ""lorsqu"", ""puisqu""
            ]
        },
        ""french_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_french_"" <1>
        },
        ""french_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""Exemple""] <2>
        },
        ""french_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""light_french""
        }
      },
      ""analyzer"": {
        ""rebuilt_french"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""french_elision"",
            ""lowercase"",
            ""french_stop"",
            ""french_keywords"",
            ""french_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""french_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: french_example, first: french, second: rebuilt_french}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[galician-analyzer]]
===== `galician` analyzer

The `galician` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /galician_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""galician_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_galician_"" <1>
        },
        ""galician_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""exemplo""] <2>
        },
        ""galician_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""galician""
        }
      },
      ""analyzer"": {
        ""rebuilt_galician"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""lowercase"",
            ""galician_stop"",
            ""galician_keywords"",
            ""galician_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""galician_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: galician_example, first: galician, second: rebuilt_galician}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[german-analyzer]]
===== `german` analyzer

The `german` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /german_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""german_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_german_"" <1>
        },
        ""german_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""Beispiel""] <2>
        },
        ""german_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""light_german""
        }
      },
      ""analyzer"": {
        ""rebuilt_german"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""lowercase"",
            ""german_stop"",
            ""german_keywords"",
            ""german_normalization"",
            ""german_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""german_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: german_example, first: german, second: rebuilt_german}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[greek-analyzer]]
===== `greek` analyzer

The `greek` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /greek_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""greek_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_greek_"" <1>
        },
        ""greek_lowercase"": {
          ""type"":       ""lowercase"",
          ""language"":   ""greek""
        },
        ""greek_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""παράδειγμα""] <2>
        },
        ""greek_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""greek""
        }
      },
      ""analyzer"": {
        ""rebuilt_greek"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""greek_lowercase"",
            ""greek_stop"",
            ""greek_keywords"",
            ""greek_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""greek_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: greek_example, first: greek, second: rebuilt_greek}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[hindi-analyzer]]
===== `hindi` analyzer

The `hindi` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /hindi_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""hindi_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_hindi_"" <1>
        },
        ""hindi_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""उदाहरण""] <2>
        },
        ""hindi_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""hindi""
        }
      },
      ""analyzer"": {
        ""rebuilt_hindi"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""lowercase"",
            ""decimal_digit"",
            ""hindi_keywords"",
            ""indic_normalization"",
            ""hindi_normalization"",
            ""hindi_stop"",
            ""hindi_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""hindi_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: hindi_example, first: hindi, second: rebuilt_hindi}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[hungarian-analyzer]]
===== `hungarian` analyzer

The `hungarian` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /hungarian_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""hungarian_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_hungarian_"" <1>
        },
        ""hungarian_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""példa""] <2>
        },
        ""hungarian_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""hungarian""
        }
      },
      ""analyzer"": {
        ""rebuilt_hungarian"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""lowercase"",
            ""hungarian_stop"",
            ""hungarian_keywords"",
            ""hungarian_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""hungarian_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: hungarian_example, first: hungarian, second: rebuilt_hungarian}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.


[[indonesian-analyzer]]
===== `indonesian` analyzer

The `indonesian` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /indonesian_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""indonesian_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_indonesian_"" <1>
        },
        ""indonesian_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""contoh""] <2>
        },
        ""indonesian_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""indonesian""
        }
      },
      ""analyzer"": {
        ""rebuilt_indonesian"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""lowercase"",
            ""indonesian_stop"",
            ""indonesian_keywords"",
            ""indonesian_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""indonesian_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: indonesian_example, first: indonesian, second: rebuilt_indonesian}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[irish-analyzer]]
===== `irish` analyzer

The `irish` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /irish_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""irish_hyphenation"": {
          ""type"":       ""stop"",
          ""stopwords"":  [ ""h"", ""n"", ""t"" ],
          ""ignore_case"": true
        },
        ""irish_elision"": {
          ""type"":       ""elision"",
          ""articles"":   [ ""d"", ""m"", ""b"" ],
          ""articles_case"": true
        },
        ""irish_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_irish_"" <1>
        },
        ""irish_lowercase"": {
          ""type"":       ""lowercase"",
          ""language"":   ""irish""
        },
        ""irish_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""sampla""] <2>
        },
        ""irish_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""irish""
        }
      },
      ""analyzer"": {
        ""rebuilt_irish"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""irish_hyphenation"",
            ""irish_elision"",
            ""irish_lowercase"",
            ""irish_stop"",
            ""irish_keywords"",
            ""irish_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""irish_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: irish_example, first: irish, second: rebuilt_irish}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[italian-analyzer]]
===== `italian` analyzer

The `italian` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /italian_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""italian_elision"": {
          ""type"": ""elision"",
          ""articles"": [
                ""c"", ""l"", ""all"", ""dall"", ""dell"",
                ""nell"", ""sull"", ""coll"", ""pell"",
                ""gl"", ""agl"", ""dagl"", ""degl"", ""negl"",
                ""sugl"", ""un"", ""m"", ""t"", ""s"", ""v"", ""d""
          ],
          ""articles_case"": true
        },
        ""italian_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_italian_"" <1>
        },
        ""italian_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""esempio""] <2>
        },
        ""italian_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""light_italian""
        }
      },
      ""analyzer"": {
        ""rebuilt_italian"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""italian_elision"",
            ""lowercase"",
            ""italian_stop"",
            ""italian_keywords"",
            ""italian_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""italian_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: italian_example, first: italian, second: rebuilt_italian}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[latvian-analyzer]]
===== `latvian` analyzer

The `latvian` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /latvian_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""latvian_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_latvian_"" <1>
        },
        ""latvian_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""piemērs""] <2>
        },
        ""latvian_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""latvian""
        }
      },
      ""analyzer"": {
        ""rebuilt_latvian"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""lowercase"",
            ""latvian_stop"",
            ""latvian_keywords"",
            ""latvian_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""latvian_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: latvian_example, first: latvian, second: rebuilt_latvian}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[lithuanian-analyzer]]
===== `lithuanian` analyzer

The `lithuanian` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /lithuanian_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""lithuanian_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_lithuanian_"" <1>
        },
        ""lithuanian_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""pavyzdys""] <2>
        },
        ""lithuanian_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""lithuanian""
        }
      },
      ""analyzer"": {
        ""rebuilt_lithuanian"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""lowercase"",
            ""lithuanian_stop"",
            ""lithuanian_keywords"",
            ""lithuanian_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""lithuanian_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: lithuanian_example, first: lithuanian, second: rebuilt_lithuanian}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[norwegian-analyzer]]
===== `norwegian` analyzer

The `norwegian` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /norwegian_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""norwegian_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_norwegian_"" <1>
        },
        ""norwegian_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""eksempel""] <2>
        },
        ""norwegian_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""norwegian""
        }
      },
      ""analyzer"": {
        ""rebuilt_norwegian"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""lowercase"",
            ""norwegian_stop"",
            ""norwegian_keywords"",
            ""norwegian_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""norwegian_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: norwegian_example, first: norwegian, second: rebuilt_norwegian}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[persian-analyzer]]
===== `persian` analyzer

The `persian` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /persian_example
{
  ""settings"": {
    ""analysis"": {
      ""char_filter"": {
        ""zero_width_spaces"": {
            ""type"":       ""mapping"",
            ""mappings"": [ ""\\\\u200C=> ""] <1>
        }
      },
      ""filter"": {
        ""persian_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_persian_"" <2>
        }
      },
      ""analyzer"": {
        ""rebuilt_persian"": {
          ""tokenizer"":     ""standard"",
          ""char_filter"": [ ""zero_width_spaces"" ],
          ""filter"": [
            ""lowercase"",
            ""decimal_digit"",
            ""arabic_normalization"",
            ""persian_normalization"",
            ""persian_stop""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: persian_example, first: persian, second: rebuilt_persian}\\nendyaml\\n/]
<1> Replaces zero-width non-joiners with an ASCII space.
<2> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.

[[portuguese-analyzer]]
===== `portuguese` analyzer

The `portuguese` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /portuguese_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""portuguese_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_portuguese_"" <1>
        },
        ""portuguese_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""exemplo""] <2>
        },
        ""portuguese_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""light_portuguese""
        }
      },
      ""analyzer"": {
        ""rebuilt_portuguese"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""lowercase"",
            ""portuguese_stop"",
            ""portuguese_keywords"",
            ""portuguese_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""portuguese_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: portuguese_example, first: portuguese, second: rebuilt_portuguese}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[romanian-analyzer]]
===== `romanian` analyzer

The `romanian` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /romanian_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""romanian_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_romanian_"" <1>
        },
        ""romanian_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""exemplu""] <2>
        },
        ""romanian_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""romanian""
        }
      },
      ""analyzer"": {
        ""rebuilt_romanian"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""lowercase"",
            ""romanian_stop"",
            ""romanian_keywords"",
            ""romanian_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""romanian_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: romanian_example, first: romanian, second: rebuilt_romanian}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.


[[russian-analyzer]]
===== `russian` analyzer

The `russian` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /russian_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""russian_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_russian_"" <1>
        },
        ""russian_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""пример""] <2>
        },
        ""russian_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""russian""
        }
      },
      ""analyzer"": {
        ""rebuilt_russian"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""lowercase"",
            ""russian_stop"",
            ""russian_keywords"",
            ""russian_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""russian_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: russian_example, first: russian, second: rebuilt_russian}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[sorani-analyzer]]
===== `sorani` analyzer

The `sorani` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /sorani_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""sorani_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_sorani_"" <1>
        },
        ""sorani_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""mînak""] <2>
        },
        ""sorani_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""sorani""
        }
      },
      ""analyzer"": {
        ""rebuilt_sorani"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""sorani_normalization"",
            ""lowercase"",
            ""decimal_digit"",
            ""sorani_stop"",
            ""sorani_keywords"",
            ""sorani_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""sorani_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: sorani_example, first: sorani, second: rebuilt_sorani}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[spanish-analyzer]]
===== `spanish` analyzer

The `spanish` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /spanish_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""spanish_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_spanish_"" <1>
        },
        ""spanish_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""ejemplo""] <2>
        },
        ""spanish_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""light_spanish""
        }
      },
      ""analyzer"": {
        ""rebuilt_spanish"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""lowercase"",
            ""spanish_stop"",
            ""spanish_keywords"",
            ""spanish_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""spanish_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: spanish_example, first: spanish, second: rebuilt_spanish}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[swedish-analyzer]]
===== `swedish` analyzer

The `swedish` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /swedish_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""swedish_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_swedish_"" <1>
        },
        ""swedish_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""exempel""] <2>
        },
        ""swedish_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""swedish""
        }
      },
      ""analyzer"": {
        ""rebuilt_swedish"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""lowercase"",
            ""swedish_stop"",
            ""swedish_keywords"",
            ""swedish_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""swedish_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: swedish_example, first: swedish, second: rebuilt_swedish}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[turkish-analyzer]]
===== `turkish` analyzer

The `turkish` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /turkish_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""turkish_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_turkish_"" <1>
        },
        ""turkish_lowercase"": {
          ""type"":       ""lowercase"",
          ""language"":   ""turkish""
        },
        ""turkish_keywords"": {
          ""type"":       ""keyword_marker"",
          ""keywords"":   [""örnek""] <2>
        },
        ""turkish_stemmer"": {
          ""type"":       ""stemmer"",
          ""language"":   ""turkish""
        }
      },
      ""analyzer"": {
        ""rebuilt_turkish"": {
          ""tokenizer"":  ""standard"",
          ""filter"": [
            ""apostrophe"",
            ""turkish_lowercase"",
            ""turkish_stop"",
            ""turkish_keywords"",
            ""turkish_stemmer""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""turkish_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: turkish_example, first: turkish, second: rebuilt_turkish}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
<2> This filter should be removed unless there are words which should
    be excluded from stemming.

[[thai-analyzer]]
===== `thai` analyzer

The `thai` analyzer could be reimplemented as a `custom` analyzer as follows:

[source,js]
----------------------------------------------------
PUT /thai_example
{
  ""settings"": {
    ""analysis"": {
      ""filter"": {
        ""thai_stop"": {
          ""type"":       ""stop"",
          ""stopwords"":  ""_thai_"" <1>
        }
      },
      ""analyzer"": {
        ""rebuilt_thai"": {
          ""tokenizer"":  ""thai"",
          ""filter"": [
            ""lowercase"",
            ""decimal_digit"",
            ""thai_stop""
          ]
        }
      }
    }
  }
}
----------------------------------------------------
// CONSOLE
// TEST[s/""thai_keywords"",//]
// TEST[s/\\n$/\\nstartyaml\\n  - compare_analyzers: {index: thai_example, first: thai, second: rebuilt_thai}\\nendyaml\\n/]
<1> The default stopwords can be overridden with the `stopwords`
    or `stopwords_path` parameters.
",12357,True,4144.585958567526,median
"// {{{ MIT License

// Copyright 2017 Roland Kaminski

// 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 ""gringo/input/nongroundparser.hh""
#include ""gringo/input/programbuilder.hh""
#include ""input/nongroundgrammar/grammar.hh""
#include ""gringo/symbol.hh""
#include ""tests/tests.hh""

#include <climits>
#include <sstream>

namespace Gringo { namespace Input { namespace Test {

namespace {

// {{{ declaration of TestNongroundProgramBuilder

class TestNongroundProgramBuilder : public INongroundProgramBuilder {
public:

    // {{{ terms
    virtual TermUid term(Location const &loc, Symbol val) override;
    virtual TermUid term(Location const &loc, String name) override;
    virtual TermUid term(Location const &loc, UnOp op, TermUid a) override;
    virtual TermUid term(Location const &loc, UnOp op, TermVecUid a) override;
    virtual TermUid term(Location const &loc, BinOp op, TermUid a, TermUid b) override;
    virtual TermUid term(Location const &loc, TermUid a, TermUid b) override;
    virtual TermUid term(Location const &loc, String name, TermVecVecUid b, bool lua) override;
    virtual TermUid term(Location const &loc, TermVecUid args, bool forceTuple) override;
    virtual TermUid pool(Location const &loc, TermVecUid args) override;
    // }}}
    // {{{ csp
    virtual CSPMulTermUid cspmulterm(Location const &loc, TermUid coe, TermUid var) override;
    virtual CSPMulTermUid cspmulterm(Location const &loc, TermUid coe) override;
    virtual CSPAddTermUid cspaddterm(Location const &loc, CSPAddTermUid a, CSPMulTermUid b, bool add) override;
    virtual CSPAddTermUid cspaddterm(Location const &loc, CSPMulTermUid a) override;
    virtual LitUid csplit(CSPLitUid a) override;
    virtual CSPLitUid csplit(Location const &loc, CSPLitUid a, Relation rel, CSPAddTermUid b) override;
    virtual CSPLitUid csplit(Location const &loc, CSPAddTermUid a, Relation rel, CSPAddTermUid b) override;
    // }}}
    // {{{ id vectors
    virtual IdVecUid idvec() override;
    virtual IdVecUid idvec(IdVecUid uid, Location const &loc, String id) override;
    // }}}
    // {{{ term vectors
    virtual TermVecUid termvec() override;
    virtual TermVecUid termvec(TermVecUid uid, TermUid term) override;
    // }}}
    // {{{ term vector vectors
    virtual TermVecVecUid termvecvec() override;
    virtual TermVecVecUid termvecvec(TermVecVecUid uid, TermVecUid termvecUid) override;
    // }}}
    // {{{ literals
    virtual LitUid boollit(Location const &loc, bool type) override;
    virtual LitUid predlit(Location const &loc, NAF naf, TermUid termUid) override;
    virtual LitUid rellit(Location const &loc, Relation rel, TermUid termUidLeft, TermUid termUidRight) override;
    // }}}
    // {{{ literal vectors
    virtual LitVecUid litvec() override;
    virtual LitVecUid litvec(LitVecUid uid, LitUid literalUid) override;
    // }}}
    // {{{ count aggregate elements (body/head)
    virtual CondLitVecUid condlitvec() override;
    virtual CondLitVecUid condlitvec(CondLitVecUid uid, LitUid lit, LitVecUid litvec) override;
    // }}}
    // {{{ body aggregate elements
    virtual BdAggrElemVecUid bodyaggrelemvec() override;
    virtual BdAggrElemVecUid bodyaggrelemvec(BdAggrElemVecUid uid, TermVecUid termvec, LitVecUid litvec) override;
    // }}}
    // {{{ head aggregate elements
    virtual HdAggrElemVecUid headaggrelemvec() override;
    virtual HdAggrElemVecUid headaggrelemvec(HdAggrElemVecUid uid, TermVecUid termvec, LitUid lit, LitVecUid litvec) override;
    // }}}
    // {{{ bounds
    virtual BoundVecUid boundvec() override;
    virtual BoundVecUid boundvec(BoundVecUid uid, Relation rel, TermUid term) override;
    // }}}
    // {{{ heads
    virtual HdLitUid headlit(LitUid lit) override;
    virtual HdLitUid headaggr(Location const &loc, TheoryAtomUid atom) override;
    virtual HdLitUid headaggr(Location const &loc, AggregateFunction fun, BoundVecUid bounds, HdAggrElemVecUid headaggrelemvec) override;
    virtual HdLitUid headaggr(Location const &loc, AggregateFunction fun, BoundVecUid bounds, CondLitVecUid headaggrelemvec) override;
    virtual HdLitUid disjunction(Location const &loc, CondLitVecUid condlitvec) override;
    // }}}
    // {{{ bodies
    virtual BdLitVecUid body() override;
    virtual BdLitVecUid bodylit(BdLitVecUid body, LitUid bodylit) override;
    virtual BdLitVecUid bodyaggr(BdLitVecUid body, Location const &loc, NAF naf, TheoryAtomUid atom) override;
    virtual BdLitVecUid bodyaggr(BdLitVecUid body, Location const &loc, NAF naf, AggregateFunction fun, BoundVecUid bounds, BdAggrElemVecUid bodyaggrelemvec) override;
    virtual BdLitVecUid bodyaggr(BdLitVecUid body, Location const &loc, NAF naf, AggregateFunction fun, BoundVecUid bounds, CondLitVecUid bodyaggrelemvec) override;
    virtual BdLitVecUid conjunction(BdLitVecUid body, Location const &loc, LitUid head, LitVecUid litvec) override;
    virtual BdLitVecUid disjoint(BdLitVecUid body, Location const &loc, NAF naf, CSPElemVecUid elem) override;
    // }}}
    // {{{ csp constraint elements
    virtual CSPElemVecUid cspelemvec() override;
    virtual CSPElemVecUid cspelemvec(CSPElemVecUid uid, Location const &loc, TermVecUid termvec, CSPAddTermUid addterm, LitVecUid litvec) override;
    // }}}
    // {{{ statements
    virtual void rule(Location const &loc, HdLitUid head) override;
    virtual void rule(Location const &loc, HdLitUid head, BdLitVecUid body) override;
    virtual void define(Location const &loc, String name, TermUid value, bool defaultDef, Logger &log) override;
    virtual void optimize(Location const &loc, TermUid weight, TermUid priority, TermVecUid cond, BdLitVecUid body) override;
    virtual void showsig(Location const &loc, Sig sig, bool csp) override;
    virtual void show(Location const &loc, TermUid t, BdLitVecUid body, bool csp) override;
    virtual void python(Location const &loc, String code) override;
    virtual void lua(Location const &loc, String code) override;
    virtual void block(Location const &loc, String name, IdVecUid args) override;
    virtual void external(Location const &loc, TermUid head, BdLitVecUid body) override;
    virtual void edge(Location const &loc, TermVecVecUid edges, BdLitVecUid body) override;
    virtual void heuristic(Location const &loc, TermUid termUid, BdLitVecUid body, TermUid a, TermUid b, TermUid mod) override;
    virtual void project(Location const &loc, TermUid termUid, BdLitVecUid body) override;
    virtual void project(Location const &loc, Sig sig) override;
    // }}}
    // {{{ theory atoms
    virtual TheoryTermUid theorytermset(Location const &loc, TheoryOptermVecUid args) override;
    virtual TheoryTermUid theoryoptermlist(Location const &loc, TheoryOptermVecUid args) override;
    virtual TheoryTermUid theorytermopterm(Location const &loc, TheoryOptermUid opterm) override;
    virtual TheoryTermUid theorytermtuple(Location const &loc, TheoryOptermVecUid args) override;
    virtual TheoryTermUid theorytermfun(Location const &loc, String name, TheoryOptermVecUid args) override;
    virtual TheoryTermUid theorytermvalue(Location const &loc, Symbol val) override;
    virtual TheoryTermUid theorytermvar(Location const &loc, String var) override;

    virtual TheoryOptermUid theoryopterm(TheoryOpVecUid ops, TheoryTermUid term) override;
    virtual TheoryOptermUid theoryopterm(TheoryOptermUid opterm, TheoryOpVecUid ops, TheoryTermUid term) override;

    virtual TheoryOpVecUid theoryops() override;
    virtual TheoryOpVecUid theoryops(TheoryOpVecUid ops, String op) override;

    virtual TheoryOptermVecUid theoryopterms() override;
    virtual TheoryOptermVecUid theoryopterms(TheoryOptermVecUid opterms, Location const &loc, TheoryOptermUid opterm) override;
    virtual TheoryOptermVecUid theoryopterms(Location const &loc, TheoryOptermUid opterm, TheoryOptermVecUid opterms) override;

    virtual TheoryElemVecUid theoryelems() override;
    virtual TheoryElemVecUid theoryelems(TheoryElemVecUid elems, TheoryOptermVecUid opterms, LitVecUid cond) override;

    virtual TheoryAtomUid theoryatom(TermUid term, TheoryElemVecUid elems) override;
    virtual TheoryAtomUid theoryatom(TermUid term, TheoryElemVecUid elems, String op, Location const &loc, TheoryOptermUid opterm) override;
    // }}}
    // {{{ theory definitions

    virtual TheoryOpDefUid theoryopdef(Location const &loc, String op, unsigned priority, TheoryOperatorType type) override;
    virtual TheoryOpDefVecUid theoryopdefs() override;
    virtual TheoryOpDefVecUid theoryopdefs(TheoryOpDefVecUid defs, TheoryOpDefUid def) override;

    virtual TheoryTermDefUid theorytermdef(Location const &loc, String name, TheoryOpDefVecUid defs, Logger &log) override;
    virtual TheoryAtomDefUid theoryatomdef(Location const &loc, String name, unsigned arity, String termDef, TheoryAtomType type) override;
    virtual TheoryAtomDefUid theoryatomdef(Location const &loc, String name, unsigned arity, String termDef, TheoryAtomType type, TheoryOpVecUid ops, String guardDef) override;

    virtual TheoryDefVecUid theorydefs() override;
    virtual TheoryDefVecUid theorydefs(TheoryDefVecUid defs, TheoryTermDefUid def) override;
    virtual TheoryDefVecUid theorydefs(TheoryDefVecUid defs, TheoryAtomDefUid def) override;

    virtual void theorydef(Location const &loc, String name, TheoryDefVecUid defs, Logger &log) override;

    // }}}

    std::string toString();

    virtual ~TestNongroundProgramBuilder();

private:
    // {{{ typedefs
    using StringVec = std::vector<std::string>;
    using StringVecVec = std::vector<StringVec>;
    using StringPair = std::pair<std::string, std::string>;
    using StringPairVec = std::vector<StringPair>;
    using TermUidVec = std::vector<TermUid>;
    using TermVecUidVec = std::vector<TermVecUid>;
    using LitUidVec = std::vector<LitUid>;

    using IdVecs = Indexed<StringVec, IdVecUid>;
    using Terms = Indexed<std::string, TermUid>;
    using TermVecs = Indexed<StringVec, TermVecUid>;
    using TermVecVecs = Indexed<StringVecVec, TermVecVecUid>;
    using Lits = Indexed<std::string, LitUid>;
    using LitVecs = Indexed<StringVec, LitVecUid>;
    using BodyAggrElemVecs = Indexed<StringVec, BdAggrElemVecUid>;
    using CondLitVecs = Indexed<StringVec, CondLitVecUid>;
    using HeadAggrElemVecs = Indexed<StringVec, HdAggrElemVecUid>;
    using Bodies = Indexed<StringVec, BdLitVecUid>;
    using CSPElems = Indexed<StringVec, CSPElemVecUid>;
    using Heads = Indexed<std::string, HdLitUid>;
    using CSPAddTerms = Indexed<std::string, CSPAddTermUid>;
    using CSPMulTerms = Indexed<std::string, CSPMulTermUid>;
    using CSPLits = Indexed<std::string, CSPLitUid>;
    using Bounds = Indexed<StringPairVec, BoundVecUid>;
    using Statements = std::vector<std::string>;

    using TheoryOps = Indexed<StringVec, TheoryOpVecUid>;
    using TheoryTerms = Indexed<std::string, TheoryTermUid>;
    using TheoryOpterms = Indexed<std::string, TheoryOptermUid>;
    using TheoryOptermVecs = Indexed<StringVec, TheoryOptermVecUid>;
    using TheoryElemVecs = Indexed<StringVec, TheoryElemVecUid>;
    using TheoryAtoms = Indexed<std::string, TheoryAtomUid>;

    using TheoryOpDefs = Indexed<std::string, TheoryOpDefUid>;
    using TheoryOpDefVecs = Indexed<StringVec, TheoryOpDefVecUid>;
    using TheoryTermDefs = Indexed<std::string, TheoryTermDefUid>;
    using TheoryAtomDefs = Indexed<std::string, TheoryAtomDefUid>;
    using TheoryDefVecs = Indexed<StringVec, TheoryDefVecUid>;

    // }}}
    // {{{ auxiliary functions
    std::string str();
    void print(StringVec const &vec, char const *sep);
    void print(StringVecVec const &vec);
    void print(AggregateFunction fun, BoundVecUid boundvecuid, StringVec const &elems);
    void print(NAF naf);
    // }}}
    // {{{ member variables
    IdVecs idvecs_;
    Terms terms_;
    TermVecs termvecs_;
    TermVecVecs termvecvecs_;
    Lits lits_;
    LitVecs litvecs_;
    BodyAggrElemVecs bodyaggrelemvecs_;
    CondLitVecs condlitvecs_;
    HeadAggrElemVecs headaggrelemvecs_;
    Bodies bodies_;
    Heads heads_;
    CSPAddTerms cspaddterms_;
    CSPMulTerms cspmulterms_;
    CSPLits csplits_;
    CSPElems cspelems_;
    Bounds bounds_;
    Statements statements_;
    std::stringstream current_;

    TheoryOps theoryOps_;
    TheoryTerms theoryTerms_;
    TheoryOpterms theoryOpterms_;
    TheoryOptermVecs theoryOptermVecs_;
    TheoryElemVecs theoryElemVecs_;
    TheoryAtoms theoryAtoms_;

    TheoryOpDefs theoryOpDefs_;
    TheoryOpDefVecs theoryOpDefVecs_;
    TheoryTermDefs theoryTermDefs_;
    TheoryAtomDefs theoryAtomDefs_;
    TheoryDefVecs theoryDefVecs_;
    // }}}
};

// }}}
// {{{ definition of TestNongroundProgramBuilder

// {{{ id vectors

IdVecUid TestNongroundProgramBuilder::idvec() {
    return idvecs_.emplace();
}

IdVecUid TestNongroundProgramBuilder::idvec(IdVecUid uid, Location const &, String id) {
    idvecs_[uid].emplace_back(id.c_str());
    return uid;
}

// }}}
// {{{ terms

TermUid TestNongroundProgramBuilder::term(Location const &, Symbol val) {
    current_ << val;
    return terms_.emplace(str());
}

TermUid TestNongroundProgramBuilder::term(Location const &, String name) {
    current_ << name;
    return terms_.emplace(str());
}

TermUid TestNongroundProgramBuilder::term(Location const &, UnOp op, TermUid a) {
    if(op == UnOp::ABS) { current_ << ""|""; }
    else { current_ << op; }
    current_ << terms_.erase(a) << (op == UnOp::ABS ? ""|"" : """");
    return terms_.emplace(str());
}

TermUid TestNongroundProgramBuilder::term(Location const &, UnOp op, TermVecUid a) {
    auto v = termvecs_.erase(a);
    if(op == UnOp::ABS) { current_ << ""|""; }
    else { current_ << op << (v.size() > 1 ? ""("" : """"); }
    print(v, "";"");
    if(op == UnOp::ABS) { current_ << ""|""; }
    else if (v.size() > 1) { current_ << "")""; }
    return terms_.emplace(str());
}

TermUid TestNongroundProgramBuilder::term(Location const &, BinOp op, TermUid a, TermUid b) {
    current_ << ""("" << terms_.erase(a) << op << terms_.erase(b) << "")"";
    return terms_.emplace(str());
}

TermUid TestNongroundProgramBuilder::term(Location const &, TermUid a, TermUid b) {
    current_ << ""("" << terms_.erase(a) << "".."" << terms_.erase(b) << "")"";
    return terms_.emplace(str());
}

TermUid TestNongroundProgramBuilder::term(Location const &, String name, TermVecVecUid a, bool lua) {
    assert(name != """");
    assert(!termvecvecs_[a].empty());
    bool nempty = lua || termvecvecs_[a].size() > 1 || !termvecvecs_[a].front().empty();
    if (lua) { current_ << ""@""; }
    current_ << name;
    if (nempty) { current_ << ""(""; }
    print(termvecvecs_.erase(a));
    if (nempty) { current_ << "")""; }
    return terms_.emplace(str());
}

TermUid TestNongroundProgramBuilder::term(Location const &, TermVecUid args, bool forceTuple) {
    current_ << ""("";
    print(termvecs_.erase(args), "","");
    if (forceTuple) { current_ << "",""; }
    current_ << "")"";
    return terms_.emplace(str());
}

TermUid TestNongroundProgramBuilder::pool(Location const &, TermVecUid args) {
    current_ << ""("";
    print(termvecs_.erase(args), "";"");
    current_ << "")"";
    return terms_.emplace(str());
}

// }}}
// {{{ csp
CSPMulTermUid TestNongroundProgramBuilder::cspmulterm(Location const &, TermUid coe, TermUid var) {
    current_ << terms_.erase(coe) << ""$*$"" << terms_.erase(var);
    return cspmulterms_.emplace(str());
}
CSPMulTermUid TestNongroundProgramBuilder::cspmulterm(Location const &, TermUid coe) {
    current_ << terms_.erase(coe);
    return cspmulterms_.emplace(str());
}
CSPAddTermUid TestNongroundProgramBuilder::cspaddterm(Location const &, CSPAddTermUid a, CSPMulTermUid b, bool add) {
    cspaddterms_[a] += (add ? ""$+"" : ""$-"") + cspmulterms_.erase(b);
    return a;
}
CSPAddTermUid TestNongroundProgramBuilder::cspaddterm(Location const &, CSPMulTermUid a) {
    current_ << cspmulterms_.erase(a);
    return cspaddterms_.emplace(str());
}
LitUid TestNongroundProgramBuilder::csplit(CSPLitUid a) {
    return lits_.emplace(csplits_.erase(a));
}
CSPLitUid TestNongroundProgramBuilder::csplit(Location const &, CSPLitUid a, Relation rel, CSPAddTermUid b) {
    csplits_[a] += ""$"" + IO::to_string(rel) + cspaddterms_.erase(b);
    return a;
}
CSPLitUid TestNongroundProgramBuilder::csplit(Location const &, CSPAddTermUid a, Relation rel, CSPAddTermUid b) {
    current_ << cspaddterms_.erase(a) << ""$"" << rel << cspaddterms_.erase(b);
    return csplits_.emplace(str());
}
// }}}
// {{{ term vectors

TermVecUid TestNongroundProgramBuilder::termvec() {
    return termvecs_.emplace();
}

TermVecUid TestNongroundProgramBuilder::termvec(TermVecUid uid, TermUid term) {
    termvecs_[uid].emplace_back(terms_.erase(term));
    return uid;
}

// }}}
// {{{ term vector vectors

TermVecVecUid TestNongroundProgramBuilder::termvecvec() {
    return termvecvecs_.emplace();
}

TermVecVecUid TestNongroundProgramBuilder::termvecvec(TermVecVecUid uid, TermVecUid termvecUid) {
    termvecvecs_[uid].push_back(termvecs_.erase(termvecUid));
    return uid;
}

// }}}
// {{{ literals

LitUid TestNongroundProgramBuilder::boollit(Location const &, bool type) {
    return lits_.emplace(type ? ""#true"" : ""#false"");
}

LitUid TestNongroundProgramBuilder::predlit(Location const &, NAF naf, TermUid termUid) {
    print(naf);
    current_ << terms_.erase(termUid);
    return lits_.emplace(str());
}

LitUid TestNongroundProgramBuilder::rellit(Location const &, Relation rel, TermUid termUidLeft, TermUid termUidRight) {
    current_ << terms_.erase(termUidLeft) << rel << terms_.erase(termUidRight);
    return lits_.emplace(str());
}

// }}}
// {{{ literal vectors

LitVecUid TestNongroundProgramBuilder::litvec() {
    return litvecs_.emplace();
}

LitVecUid TestNongroundProgramBuilder::litvec(LitVecUid uid, LitUid literalUid) {
    litvecs_[uid].emplace_back(lits_.erase(literalUid));
    return uid;
}

// }}}
// {{{ count aggregate elements (body/head)

CondLitVecUid TestNongroundProgramBuilder::condlitvec() {
    return condlitvecs_.emplace();
}

CondLitVecUid TestNongroundProgramBuilder::condlitvec(CondLitVecUid uid, LitUid lit, LitVecUid litvec) {
    current_ << lits_.erase(lit);
    current_ << "":"";
    print(litvecs_.erase(litvec), "","");
    condlitvecs_[uid].emplace_back(str());
    return uid;
}

// }}}
// {{{ body aggregate elements

BdAggrElemVecUid TestNongroundProgramBuilder::bodyaggrelemvec() {
    return bodyaggrelemvecs_.emplace();
}

BdAggrElemVecUid TestNongroundProgramBuilder::bodyaggrelemvec(BdAggrElemVecUid uid, TermVecUid termvec, LitVecUid litvec) {
    print(termvecs_.erase(termvec), "","");
    current_ << "":"";
    print(litvecs_.erase(litvec), "","");
    bodyaggrelemvecs_[uid].emplace_back(str());
    return uid;
}

// }}}
// {{{ head aggregate elements

HdAggrElemVecUid TestNongroundProgramBuilder::headaggrelemvec() {
    return headaggrelemvecs_.emplace();
}

HdAggrElemVecUid TestNongroundProgramBuilder::headaggrelemvec(HdAggrElemVecUid uid, TermVecUid termvec, LitUid lit, LitVecUid litvec) {
    print(termvecs_.erase(termvec), "","");
    current_ << "":"" << lits_.erase(lit) << "":"";
    print(litvecs_.erase(litvec), "","");
    headaggrelemvecs_[uid].emplace_back(str());
    return uid;
}

// }}}
// {{{ bounds

BoundVecUid TestNongroundProgramBuilder::boundvec() {
    return bounds_.emplace();
}

BoundVecUid TestNongroundProgramBuilder::boundvec(BoundVecUid uid, Relation rel, TermUid term) {
    std::stringstream ss;
    current_ << terms_.erase(term);
    ss << rel << current_.str();
    current_ << inv(rel);
    bounds_[uid].emplace_back(str(), ss.str());
    return uid;
}

// }}}
// {{{ heads

HdLitUid TestNongroundProgramBuilder::headlit(LitUid lit) {
    return heads_.emplace(lits_.erase(lit));
}

HdLitUid TestNongroundProgramBuilder::headaggr(Location const &, TheoryAtomUid atom) {
    return heads_.emplace(theoryAtoms_.erase(atom));
}

HdLitUid TestNongroundProgramBuilder::headaggr(Location const &, AggregateFunction fun, BoundVecUid boundvecuid, HdAggrElemVecUid headaggrelemvec) {
    print(fun, boundvecuid, headaggrelemvecs_.erase(headaggrelemvec));
    return heads_.emplace(str());
}

HdLitUid TestNongroundProgramBuilder::headaggr(Location const &, AggregateFunction fun, BoundVecUid boundvecuid, CondLitVecUid headaggrelemvec) {
    print(fun, boundvecuid, condlitvecs_.erase(headaggrelemvec));
    return heads_.emplace(str());
}

HdLitUid TestNongroundProgramBuilder::disjunction(Location const &, CondLitVecUid condlitvec) {
    print(condlitvecs_.erase(condlitvec), "";"");
    return heads_.emplace(str());
}

// }}}
// {{{ bodies

BdLitVecUid TestNongroundProgramBuilder::body() {
    return bodies_.emplace();
}

BdLitVecUid TestNongroundProgramBuilder::bodylit(BdLitVecUid uid, LitUid lit) {
    bodies_[uid].emplace_back(lits_.erase(lit));
    return uid;
}

BdLitVecUid TestNongroundProgramBuilder::bodyaggr(BdLitVecUid body, Location const &, NAF naf, TheoryAtomUid atom) {
    print(naf);
    current_ << theoryAtoms_.erase(atom);
    bodies_[body].emplace_back(str());
    return body;
}

BdLitVecUid TestNongroundProgramBuilder::bodyaggr(BdLitVecUid uid, Location const &, NAF naf, AggregateFunction fun, BoundVecUid bounds, BdAggrElemVecUid bodyaggrelemvec) {
    print(naf);
    print(fun, bounds, bodyaggrelemvecs_.erase(bodyaggrelemvec));
    bodies_[uid].emplace_back(str());
    return uid;
}

BdLitVecUid TestNongroundProgramBuilder::bodyaggr(BdLitVecUid uid, Location const &, NAF naf, AggregateFunction fun, BoundVecUid bounds, CondLitVecUid bodyaggrelemvec) {
    print(naf);
    print(fun, bounds, condlitvecs_.erase(bodyaggrelemvec));
    bodies_[uid].emplace_back(str());
    return uid;
}

BdLitVecUid TestNongroundProgramBuilder::conjunction(BdLitVecUid uid, Location const &, LitUid head, LitVecUid litvec) {
    current_ << lits_.erase(head) << "":"";
    print(litvecs_.erase(litvec), "","");
    bodies_[uid].emplace_back(str());
    return uid;
}

BdLitVecUid TestNongroundProgramBuilder::disjoint(BdLitVecUid body, Location const &, NAF naf, CSPElemVecUid elem) {
    current_ << naf << ""#disjoint{"";
    print(cspelems_.erase(elem), "","");
    current_ << ""}"";
    bodies_[body].emplace_back(str());
    return body;
}

// }}}
// {{{ csp constraint elements

CSPElemVecUid TestNongroundProgramBuilder::cspelemvec() {
    return cspelems_.emplace();
}

CSPElemVecUid TestNongroundProgramBuilder::cspelemvec(CSPElemVecUid uid, Location const &, TermVecUid termvec, CSPAddTermUid addterm, LitVecUid litvec) {
    print(termvecs_.erase(termvec), "","");
    current_ << "":"" << cspaddterms_.erase(addterm) << "":"";
    print(litvecs_.erase(litvec), "","");
    cspelems_[uid].emplace_back(str());
    return uid;
}

// }}}
// {{{ statements

void TestNongroundProgramBuilder::rule(Location const &, HdLitUid head) {
    current_ << heads_.erase(head) << ""."";
    statements_.emplace_back(str());
}

void TestNongroundProgramBuilder::rule(Location const &, HdLitUid head, BdLitVecUid bodyuid) {
    current_ << heads_.erase(head);
    StringVec body(bodies_.erase(bodyuid));
    if (!body.empty()) {
        current_ << "":-"";
        print(body, "";"");
    }
    current_ << ""."";
    statements_.emplace_back(str());
}

void TestNongroundProgramBuilder::define(Location const &, String name, TermUid value, bool, Logger &) {
    current_ << ""#const "" << name << ""="" << terms_.erase(value) << ""."";
    statements_.emplace_back(str());
}

void TestNongroundProgramBuilder::optimize(Location const &, TermUid weight, TermUid priority, TermVecUid cond, BdLitVecUid body) {
    current_ << "":~"";
    StringVec bd(bodies_.erase(body));
    print(bd, "";"");
    current_ << "".["" << terms_.erase(weight) << ""@"" << terms_.erase(priority);
    StringVec cd(termvecs_.erase(cond));
    if (!cd.empty()) {
        current_ << "","";
        print(cd, "","");
    }
    current_ << ""]"";
    statements_.emplace_back(str());
}

void TestNongroundProgramBuilder::showsig(Location const &, Sig sig, bool csp) {
    current_ << ""#showsig "" << (csp ? ""$"" : """") << sig << ""."";
    statements_.emplace_back(str());
}

void TestNongroundProgramBuilder::show(Location const &, TermUid t, BdLitVecUid bodyuid, bool csp) {
    current_ << ""#show "" << (csp ? ""$"" : """") << terms_.erase(t);
    StringVec body(bodies_.erase(bodyuid));
    if (!body.empty()) {
        current_ << "":"";
        print(body, "";"");
    }
    current_ << ""."";
    statements_.emplace_back(str());
}

void TestNongroundProgramBuilder::python(Location const &, String code) {
    current_ << code << ""."";
    statements_.emplace_back(str());
}

void TestNongroundProgramBuilder::lua(Location const &, String code) {
    current_ << code << ""."";
    statements_.emplace_back(str());
}
void TestNongroundProgramBuilder::block(Location const &, String name, IdVecUid args) {
    current_ << ""#program "" << name << ""("";
    print(idvecs_.erase(args), "","");
    current_ << "")."";
    statements_.emplace_back(str());
}

void TestNongroundProgramBuilder::external(Location const &, TermUid head, BdLitVecUid bodyuid) {
    current_ << ""#external "" << terms_.erase(head);
    StringVec body(bodies_.erase(bodyuid));
    if (!body.empty()) {
        current_ << "":"";
        print(body, "";"");
    }
    current_ << ""."";
    statements_.emplace_back(str());
}

void TestNongroundProgramBuilder::edge(Location const &, TermVecVecUid edges, BdLitVecUid bodyuid) {
    current_ << ""#edge("";
    print(termvecvecs_.erase(edges));
    current_ << "")"";
    StringVec body(bodies_.erase(bodyuid));
    if (!body.empty()) {
        current_ << "":"";
        print(body, "";"");
    }
    current_ << ""."";
    statements_.emplace_back(str());
}

void TestNongroundProgramBuilder::heuristic(Location const &, TermUid termUid, BdLitVecUid bodyuid, TermUid a, TermUid b, TermUid mod) {
    current_ << ""#heuristic "" << terms_.erase(termUid);
    StringVec body(bodies_.erase(bodyuid));
    if (!body.empty()) {
        current_ << "":"";
        print(body, "";"");
    }
    current_ << "".["" << terms_.erase(a) << ""@"" << terms_.erase(b) << "","" << terms_.erase(mod) << ""]"";
    statements_.emplace_back(str());
}

void TestNongroundProgramBuilder::project(Location const &, TermUid termUid, BdLitVecUid bodyuid) {
    current_ << ""#project "" << terms_.erase(termUid);
    StringVec body(bodies_.erase(bodyuid));
    if (!body.empty()) {
        current_ << "":"";
        print(body, "";"");
    }
    current_ << ""."";
    statements_.emplace_back(str());

}

void TestNongroundProgramBuilder::project(Location const &, Sig sig) {
    current_ << ""#project "" << sig << ""."";
    statements_.emplace_back(str());
}

// }}}
// {{{ theory atoms

TheoryTermUid TestNongroundProgramBuilder::theorytermset(Location const &, TheoryOptermVecUid args) {
    current_ << ""{"";
    print(theoryOptermVecs_.erase(args), "" ; "");
    current_ << ""}"";
    return theoryTerms_.emplace(str());
}
TheoryTermUid TestNongroundProgramBuilder::theoryoptermlist(Location const &, TheoryOptermVecUid args) {
    current_ << ""["";
    print(theoryOptermVecs_.erase(args), "" ; "");
    current_ << ""]"";
    return theoryTerms_.emplace(str());
}

TheoryTermUid TestNongroundProgramBuilder::theorytermopterm(Location const &, TheoryOptermUid opterm) {
    current_ << ""("" << theoryOpterms_.erase(opterm) << "")"";
    return theoryTerms_.emplace(str());
}

TheoryTermUid TestNongroundProgramBuilder::theorytermtuple(Location const &, TheoryOptermVecUid args) {
    current_ << ""("";
    auto size = theoryOptermVecs_[args].size();
    print(theoryOptermVecs_.erase(args), "","");
    if (size == 1) { current_ << "",""; }
    current_ << "")"";
    return theoryTerms_.emplace(str());
}

TheoryTermUid TestNongroundProgramBuilder::theorytermfun(Location const &, String name, TheoryOptermVecUid args) {
    current_ << name << ""("";
    print(theoryOptermVecs_.erase(args), "","");
    current_ << "")"";
    return theoryTerms_.emplace(str());
}

TheoryTermUid TestNongroundProgramBuilder::theorytermvalue(Location const &, Symbol val) {
    current_ << val;
    return theoryTerms_.emplace(str());
}

TheoryTermUid TestNongroundProgramBuilder::theorytermvar(Location const &, String var) {
    current_ << var;
    return theoryTerms_.emplace(str());
}

TheoryOptermUid TestNongroundProgramBuilder::theoryopterm(TheoryOpVecUid ops, TheoryTermUid term) {
    auto to = theoryOps_.erase(ops);
    print(to, "" "");
    if (!to.empty()) { current_ << "" ""; }
    current_ << theoryTerms_.erase(term);
    return theoryOpterms_.emplace(str());

}

TheoryOptermUid TestNongroundProgramBuilder::theoryopterm(TheoryOptermUid opterm, TheoryOpVecUid ops, TheoryTermUid term) {
    auto to = theoryOps_.erase(ops);
    if (!to.empty()) { current_ << "" ""; }
    print(to, "" "");
    current_ << "" "" << theoryTerms_.erase(term);
    theoryOpterms_[opterm] += str();
    return opterm;
}

TheoryOpVecUid TestNongroundProgramBuilder::theoryops() {
    return theoryOps_.emplace();
}

TheoryOpVecUid TestNongroundProgramBuilder::theoryops(TheoryOpVecUid ops, String op) {
    theoryOps_[ops].emplace_back(op.c_str());
    return ops;
}

TheoryOptermVecUid TestNongroundProgramBuilder::theoryopterms() {
    return theoryOptermVecs_.emplace();
}

TheoryOptermVecUid TestNongroundProgramBuilder::theoryopterms(TheoryOptermVecUid opterms, Location const &, TheoryOptermUid opterm) {
    theoryOptermVecs_[opterms].emplace_back(theoryOpterms_.erase(opterm));
    return opterms;
}

TheoryOptermVecUid TestNongroundProgramBuilder::theoryopterms(Location const &, TheoryOptermUid opterm, TheoryOptermVecUid opterms) {
    theoryOptermVecs_[opterms].emplace(theoryOptermVecs_[opterms].begin(), theoryOpterms_.erase(opterm));
    return opterms;
}

TheoryElemVecUid TestNongroundProgramBuilder::theoryelems() {
    return theoryElemVecs_.emplace();
}

TheoryElemVecUid TestNongroundProgramBuilder::theoryelems(TheoryElemVecUid elems, TheoryOptermVecUid opterms, LitVecUid cond) {
    print(theoryOptermVecs_.erase(opterms), "","");
    current_ << "":"";
    print(litvecs_.erase(cond), "","");
    theoryElemVecs_[elems].emplace_back(str());
    return elems;
}

TheoryAtomUid TestNongroundProgramBuilder::theoryatom(TermUid term, TheoryElemVecUid elems) {
    current_ << ""&"" << terms_.erase(term) << ""{"";
    print(theoryElemVecs_.erase(elems), "" ; "");
    current_ << ""}"";
    return theoryAtoms_.emplace(str());
}

TheoryAtomUid TestNongroundProgramBuilder::theoryatom(TermUid term, TheoryElemVecUid elems, String op, Location const &, TheoryOptermUid opterm) {
    current_ << ""&"" << terms_.erase(term) << ""{"";
    print(theoryElemVecs_.erase(elems), "" ; "");
    current_ << ""} "" << op << "" "" << theoryOpterms_.erase(opterm);
    return theoryAtoms_.emplace(str());
}

// }}}
// {{{ theory definitions

TheoryOpDefUid TestNongroundProgramBuilder::theoryopdef(Location const &, String op, unsigned priority, TheoryOperatorType type) {
    current_ << op << "" :"" << priority << "","" << type;
    return theoryOpDefs_.emplace(str());
}

TheoryOpDefVecUid TestNongroundProgramBuilder::theoryopdefs() {
    return theoryOpDefVecs_.emplace();
}

TheoryOpDefVecUid TestNongroundProgramBuilder::theoryopdefs(TheoryOpDefVecUid defs, TheoryOpDefUid def) {
    theoryOpDefVecs_[defs].emplace_back(theoryOpDefs_.erase(def));
    return defs;
}

TheoryTermDefUid TestNongroundProgramBuilder::theorytermdef(Location const &, String name, TheoryOpDefVecUid defs, Logger &) {
    current_ << name << ""{"";
    print(theoryOpDefVecs_.erase(defs), "","");
    current_ << ""}"";
    return theoryTermDefs_.emplace(str());
}

TheoryAtomDefUid TestNongroundProgramBuilder::theoryatomdef(Location const &, String name, unsigned arity, String termDef, TheoryAtomType type) {
    current_ << ""&"" << name << ""/"" << arity << "":"" << termDef << "","" << type;
    return theoryAtomDefs_.emplace(str());
}

TheoryAtomDefUid TestNongroundProgramBuilder::theoryatomdef(Location const &, String name, unsigned arity, String termDef, TheoryAtomType type, TheoryOpVecUid ops, String guardDef) {
    current_ << ""&"" << name << ""/"" << arity << "":"" << termDef << "",{"";
    print(theoryOps_.erase(ops), "","");
    current_ << ""},"" << guardDef << "","" << type;
    return theoryAtomDefs_.emplace(str());
}

TheoryDefVecUid TestNongroundProgramBuilder::theorydefs() {
    return theoryDefVecs_.emplace();
}

TheoryDefVecUid TestNongroundProgramBuilder::theorydefs(TheoryDefVecUid defs, TheoryTermDefUid def) {
    theoryDefVecs_[defs].emplace_back(theoryTermDefs_.erase(def));
    return defs;
}

TheoryDefVecUid TestNongroundProgramBuilder::theorydefs(TheoryDefVecUid defs, TheoryAtomDefUid def) {
    theoryDefVecs_[defs].emplace_back(theoryAtomDefs_.erase(def));
    return defs;
}

void TestNongroundProgramBuilder::theorydef(Location const &, String name, TheoryDefVecUid defs, Logger &) {
    current_ << ""#theory "" << name << ""{"";
    print(theoryDefVecs_.erase(defs), "";"");
    current_ << ""}."";
    statements_.emplace_back(str());
}

// }}}
// {{{ auxiliary functions

void TestNongroundProgramBuilder::print(AggregateFunction fun, BoundVecUid boundvecuid, StringVec const &elems) {
    StringPairVec bounds(bounds_.erase(boundvecuid));
    auto it = bounds.begin(), end = bounds.end();
    if (it != end) { current_ << it->first; ++it; }
    current_ << fun << ""{"";
    print(elems, "";"");
    current_ << ""}"";
    for (; it != end; ++it) { current_ << it->second; }
}

void TestNongroundProgramBuilder::print(NAF naf) {
    switch (naf) {
        case NAF::NOT:    { current_ << ""#not ""; break; }
        case NAF::NOTNOT: { current_ << ""#not #not ""; break; }
        case NAF::POS:    { break; }
    }
}

std::string TestNongroundProgramBuilder::str() {
    std::string str(current_.str());
    current_.str("""");
    return str;
}

void TestNongroundProgramBuilder::print(StringVec const &vec, char const *sep) {
    auto it = vec.begin(), end = vec.end();
    if (it != end) {
        current_ << *it++;
        for (; it != end; ++it) { current_ << sep << *it; }
    }
}

void TestNongroundProgramBuilder::print(StringVecVec const &vec) {
    auto it = vec.begin(), end = vec.end();
    if (it != end) {
        print(*it++, "","");
        for (; it != end; ++it) {
            current_ << "";"";
            print(*it, "","");
        }
    }
}

// }}}

std::string TestNongroundProgramBuilder::toString() {
    auto it = statements_.begin(), end = statements_.end();
    if (it != end) {
        current_ << *it;
        for (++it; it != end; ++it) { current_ << '\\n' << *it; }
    }
    statements_.clear();
    return str();
}

TestNongroundProgramBuilder::~TestNongroundProgramBuilder() { }

// }}}

std::string parse(std::string const &str) {
    Gringo::Test::TestGringoModule log;
    TestNongroundProgramBuilder pb;
    bool incmode;
    NonGroundParser ngp(pb, incmode);
    ngp.pushStream(""-"", std::unique_ptr<std::istream>(new std::stringstream(str)), log);
    ngp.parse(log);
    return pb.toString();
}

} // namespace

TEST_CASE(""input-nongroundprogrambuilder"", ""[input]"") {

    SECTION(""term"") {
        // testing constants
        REQUIRE(""#program base().\\np(x)."" == parse(""p(x).""));
        REQUIRE(""#program base().\\np(1)."" == parse(""p(1).""));
        REQUIRE(""#program base().\\np(\\""1\\"")."" == parse(""p(\\""1\\"").""));
        REQUIRE(""#program base().\\np(#inf)."" == parse(""p(#inf).""));
        REQUIRE(""#program base().\\np(#sup)."" == parse(""p(#sup).""));
        REQUIRE(""#program base().\\np(X)."" == parse(""p(X).""));
        REQUIRE(""#program base().\\np(_)."" == parse(""p(_).""));
        // absolute
        REQUIRE(""#program base().\\np(|1|)."" == parse(""p(|1|).""));
        REQUIRE(""#program base().\\np(|1;2;3|)."" == parse(""p(|1;2;3|).""));
        // lua function calls
        REQUIRE(""#program base().\\np(@f())."" == parse(""p(@f()).""));
        REQUIRE(""#program base().\\np(@f(1))."" == parse(""p(@f(1)).""));
        REQUIRE(""#program base().\\np(@f(1,2))."" == parse(""p(@f(1,2)).""));
        REQUIRE(""#program base().\\np(@f(1,2,3))."" == parse(""p(@f(1,2,3)).""));
        REQUIRE(""#program base().\\np(@f(;;;1,2;3))."" == parse(""p(@f(;;;1,2;3)).""));
        // function symbols
        REQUIRE(""#program base().\\np(f)."" == parse(""p(f()).""));
        REQUIRE(""#program base().\\np(f(1))."" == parse(""p(f(1)).""));
        REQUIRE(""#program base().\\np(f(1,2))."" == parse(""p(f(1,2)).""));
        REQUIRE(""#program base().\\np(f(1,2,3))."" == parse(""p(f(1,2,3)).""));
        REQUIRE(""#program base().\\np(f(;;;1,2;3))."" == parse(""p(f(;;;1,2;3)).""));
        // tuples / parenthesis
        REQUIRE(""#program base().\\np((()))."" == parse(""p(()).""));
        REQUIRE(""#program base().\\np(((1)))."" == parse(""p((1)).""));
        REQUIRE(""#program base().\\np(((1,2)))."" == parse(""p((1,2)).""));
        REQUIRE(""#program base().\\np(((1,2,3)))."" == parse(""p((1,2,3)).""));
        REQUIRE(""#program base().\\np((();();();(1,2);(3,)))."" == parse(""p((;;;1,2;3,)).""));
        // unary operations
        REQUIRE(""#program base().\\np(-1)."" == parse(""p(-1).""));
        REQUIRE(""#program base().\\np(~1)."" == parse(""p(~1).""));
        // binary operations
        REQUIRE(""#program base().\\np((1**2))."" == parse(""p(1**2).""));
        REQUIRE(""#program base().\\np((1\\\\2))."" == parse(""p(1\\\\2).""));
        REQUIRE(""#program base().\\np((1/2))."" == parse(""p(1/2).""));
        REQUIRE(""#program base().\\np((1*2))."" == parse(""p(1*2).""));
        REQUIRE(""#program base().\\np((1-2))."" == parse(""p(1-2).""));
        REQUIRE(""#program base().\\np((1+2))."" == parse(""p(1+2).""));
        REQUIRE(""#program base().\\np((1&2))."" == parse(""p(1&2).""));
        REQUIRE(""#program base().\\np((1?2))."" == parse(""p(1?2).""));
        REQUIRE(""#program base().\\np((1^2))."" == parse(""p(1^2).""));
        REQUIRE(""#program base().\\np((1..2))."" == parse(""p(1..2).""));
        // precedence
        REQUIRE(""#program base().\\np(((1+2)+((3*4)*(5**(6**7)))))."" == parse(""p(1+2+3*4*5**6**7).""));
        // nesting
        REQUIRE(""#program base().\\np((f(1,(();();();(1,(x..Y));(3)),3)+p(f(1,#sup,3))))."" == parse(""p(f(1,(;;;1,x..Y;3),3)+p(f(1,#sup,3))).""));
    }

    SECTION(""atomargs"") {
        // identifier
        REQUIRE(""#program base().\\np."" == parse(""p.""));
        // identifier LPAREN argvec RPAREN
        REQUIRE(""#program base().\\np."" == parse(""p().""));
        REQUIRE(""#program base().\\np(1)."" == parse(""p(1).""));
        REQUIRE(""#program base().\\np(;;;1,2;3,4)."" == parse(""p(;;;1,2;3,4).""));
        // identifier LPAREN MUL RPAREN
        REQUIRE(""#program base().\\np(_)."" == parse(""p(_).""));
        // identifier LPAREN MUL cpredargvec RPAREN
        REQUIRE(""#program base().\\np(_,1)."" == parse(""p(_,1).""));
        REQUIRE(""#program base().\\np(_,1,2)."" == parse(""p(_,1,2).""));
        REQUIRE(""#program base().\\np(_,1,2;2,3)."" == parse(""p(_,1,2;2,3).""));
        // identifier LPAREN MUL spredargvec RPAREN
        REQUIRE(""#program base().\\np(_;1)."" == parse(""p(_;1).""));
        REQUIRE(""#program base().\\np(_;1,2)."" == parse(""p(_;1,2).""));
        REQUIRE(""#program base().\\np(_;1,2;2,3)."" == parse(""p(_;1,2;2,3).""));
        // identifier LPAREN argvec COMMAMUL MUL RPAREN
        REQUIRE(""#program base().\\np(1,_)."" == parse(""p(1,_).""));
        REQUIRE(""#program base().\\np(1,2,_)."" == parse(""p(1,2,_).""));
        // identifier LPAREN argvec COMMAMUL MUL cpredargvec RPAREN
        REQUIRE(""#program base().\\np(1,2,_,3,_;_)."" == parse(""p(1,2,_,3,_;_).""));
        REQUIRE(""#program base().\\np(1,2,_,3,4,_;_)."" == parse(""p(1,2,_,3,4,_;_).""));
        // identifier LPAREN argvec COMMAMUL MUL spredargvec RPAREN
        REQUIRE(""#program base().\\np(1,2,_;3,_;_)."" == parse(""p(1,2,_;3,_;_).""));
        REQUIRE(""#program base().\\np(1,2,_;3,4,_;_)."" == parse(""p(1,2,_;3,4,_;_).""));
        // identifier LPAREN argvec SEMMUL MUL RPAREN
        REQUIRE(""#program base().\\np(1;_)."" == parse(""p(1;_).""));
        REQUIRE(""#program base().\\np(1,2;_)."" == parse(""p(1,2;_).""));
        // identifier LPAREN argvec SEMMUL MUL cpredargvec RPAREN
        REQUIRE(""#program base().\\np(1,2;_,3,_;_)."" == parse(""p(1,2;_,3,_;_).""));
        REQUIRE(""#program base().\\np(1,2;_,3,4,_;_)."" == parse(""p(1,2;_,3,4,_;_).""));
        // identifier LPAREN argvec SEMMUL MUL spredargvec RPAREN
        REQUIRE(""#program base().\\np(1,2;_;3,_;_)."" == parse(""p(1,2;_;3,_;_).""));
        REQUIRE(""#program base().\\np(1,2;_;3,4,_;_)."" == parse(""p(1,2;_;3,4,_;_).""));
    }

    SECTION(""literal"") {
        // TRUE
        REQUIRE(""#program base().\\n#true."" == parse(""#true.""));
        // FALSE
        REQUIRE(""#program base().\\n#false."" == parse(""#false.""));
        // atom
        REQUIRE(""#program base().\\np."" == parse(""p.""));
        REQUIRE(""#program base().\\n-p."" == parse(""-p.""));
        // NOT atom
        REQUIRE(""#program base().\\n#not p."" == parse(""not p.""));
        // NOT NOT atom
        REQUIRE(""#program base().\\n#not #not p."" == parse(""not not p.""));
        // term cmp term
        REQUIRE(""#program base().\\n(1+2)!=3."" == parse(""1+2!=3.""));
    }

    SECTION(""bdaggr"") {
        // aggregatefunction
        REQUIRE(""#program base().\\n#false:-#count{}."" == parse("":-{}.""));
        REQUIRE(""#program base().\\n#false:-#sum{}."" == parse("":-#sum{}.""));
        REQUIRE(""#program base().\\n#false:-#sum+{}."" == parse("":-#sum+{}.""));
        REQUIRE(""#program base().\\n#false:-#min{}."" == parse("":-#min{}.""));
        REQUIRE(""#program base().\\n#false:-#max{}."" == parse("":-#max{}.""));
        REQUIRE(""#program base().\\n#false:-#count{}."" == parse("":-#count{}.""));
        // LBRACE altbodyaggrelemvec RBRACE
        REQUIRE(""#program base().\\n#false:-#count{p:;p:;p:p;p:p,q}."" == parse("":-{p;p:;p:p;p:p,q}.""));
        // aggregatefunction LBRACE bodyaggrelemvec RBRACE
        REQUIRE(""#program base().\\n#false:-#count{:;:p;:p,q}."" == parse("":-#count{:;:p;:p,q}.""));
        REQUIRE(""#program base().\\n#false:-#count{p:;p,q:}."" == parse("":-#count{p;p,q}.""));
        REQUIRE(""#program base().\\n#false:-#count{p:;p,q:}."" == parse("":-#count{p:;p,q:}.""));
        REQUIRE(""#program base().\\n#false:-#count{p:q,r,s}."" == parse("":-#count{p:q,r,s}.""));
        // test lower
        REQUIRE(""#program base().\\n#false:-1<=#count{}."" == parse("":-1{}.""));
        REQUIRE(""#program base().\\n#false:-1<#count{}."" == parse("":-1<{}.""));
        REQUIRE(""#program base().\\n#false:-1<=#count{}."" == parse("":-1<={}.""));
        REQUIRE(""#program base().\\n#false:-1>#count{}."" == parse("":-1>{}.""));
        REQUIRE(""#program base().\\n#false:-1>=#count{}."" == parse("":-1>={}.""));
        REQUIRE(""#program base().\\n#false:-1=#count{}."" == parse("":-1=={}.""));
        REQUIRE(""#program base().\\n#false:-1=#count{}."" == parse("":-1={}.""));
        // test upper
        REQUIRE(""#program base().\\n#false:-1>=#count{}."" == parse("":-{}1.""));
        REQUIRE(""#program base().\\n#false:-1<#count{}."" == parse("":-{}>1.""));
        REQUIRE(""#program base().\\n#false:-1<=#count{}."" == parse("":-{}>=1.""));
        REQUIRE(""#program base().\\n#false:-1>#count{}."" == parse("":-{}<1.""));
        REQUIRE(""#program base().\\n#false:-1>=#count{}."" == parse("":-{}<=1.""));
        REQUIRE(""#program base().\\n#false:-1=#count{}."" == parse("":-{}==1.""));
        REQUIRE(""#program base().\\n#false:-1=#count{}."" == parse("":-{}=1.""));
        // test both
        REQUIRE(""#program base().\\n#false:-1<=#count{}<=2."" == parse("":-1{}2.""));
        REQUIRE(""#program base().\\n#false:-1<#count{}<2."" == parse("":-1<{}<2.""));
    }

    SECTION(""hdaggr"") {
        // aggregatefunction
        REQUIRE(""#program base().\\n#count{}."" == parse(""{}.""));
        REQUIRE(""#program base().\\n#sum{}."" == parse(""#sum{}.""));
        REQUIRE(""#program base().\\n#sum+{}."" == parse(""#sum+{}.""));
        REQUIRE(""#program base().\\n#min{}."" == parse(""#min{}.""));
        REQUIRE(""#program base().\\n#max{}."" == parse(""#max{}.""));
        REQUIRE(""#program base().\\n#count{}."" == parse(""#count{}.""));
        // LBRACE altheadaggrelemvec RBRACE
        REQUIRE(""#program base().\\n#count{p:;p:;p:p;p:p,q}."" == parse(""{p;p:;p:p;p:p,q}.""));
        // aggregatefunction LBRACE headaggrelemvec RBRACE
        REQUIRE(""#program base().\\n#count{:p:;:q:r;:s:t,u}."" == parse(""#count{:p;:q:r;:s:t,u}.""));
        REQUIRE(""#program base().\\n#count{p:q:;r,s:t:}."" == parse(""#count{p:q;r,s:t}.""));
        REQUIRE(""#program base().\\n#count{p:q:;r,s:t:}."" == parse(""#count{p:q:;r,s:t:}.""));
        REQUIRE(""#program base().\\n#count{p:q:x,y,z;r,s:t:q,w,e}."" == parse(""#count{p:q:x,y,z;r,s:t:q,w,e}.""));
        // test lower
        REQUIRE(""#program base().\\n1<=#count{}."" == parse(""1{}.""));
        REQUIRE(""#program base().\\n1<#count{}."" == parse(""1<{}.""));
        REQUIRE(""#program base().\\n1<=#count{}."" == parse(""1<={}.""));
        REQUIRE(""#program base().\\n1>#count{}."" == parse(""1>{}.""));
        REQUIRE(""#program base().\\n1>=#count{}."" == parse(""1>={}.""));
        REQUIRE(""#program base().\\n1=#count{}."" == parse(""1=={}.""));
        REQUIRE(""#program base().\\n1=#count{}."" == parse(""1={}.""));
        // test upper
        REQUIRE(""#program base().\\n1>=#count{}."" == parse(""{}1.""));
        REQUIRE(""#program base().\\n1<#count{}."" == parse(""{}>1.""));
        REQUIRE(""#program base().\\n1<=#count{}."" == parse(""{}>=1.""));
        REQUIRE(""#program base().\\n1>#count{}."" == parse(""{}<1.""));
        REQUIRE(""#program base().\\n1>=#count{}."" == parse(""{}<=1.""));
        REQUIRE(""#program base().\\n1=#count{}."" == parse(""{}==1.""));
        REQUIRE(""#program base().\\n1=#count{}."" == parse(""{}=1.""));
        // test both
        REQUIRE(""#program base().\\n1<=#count{}<=2."" == parse(""1{}2.""));
        REQUIRE(""#program base().\\n1<#count{}<2."" == parse(""1<{}<2.""));
    }

    SECTION(""conjunction"") {
        REQUIRE(""#program base().\\n#false:-a:."" == parse("":-a:.""));
        REQUIRE(""#program base().\\n#false:-a:b."" == parse("":-a:b.""));
        REQUIRE(""#program base().\\n#false:-a:b,c."" == parse("":-a:b,c.""));
        REQUIRE(""#program base().\\n#false:-a:b,c;x."" == parse("":-a:b,c;x.""));
    }

    SECTION(""disjunction"") {
        // Note: first disjunction element moves to the end (parsing related)
        // literal COLON litvec
        REQUIRE(""#program base().\\na."" == parse(""a.""));
        REQUIRE(""#program base().\\na:b."" == parse(""a:b.""));
        REQUIRE(""#program base().\\na:b,c."" == parse(""a:b,c.""));
        // literal COMMA disjunctionsep literal optcondition
        REQUIRE(""#program base().\\nb:;c:;a:."" == parse(""a,b,c.""));
        REQUIRE(""#program base().\\nb:;c:;d:;a:."" == parse(""a,b;c;d.""));
        REQUIRE(""#program base().\\nb:;c:d,e;a:."" == parse(""a,b,c:d,e.""));
        REQUIRE(""#program base().\\nb:d,e;c:;a:."" == parse(""a,b:d,e;c.""));
        // literal SEM disjunctionsep literal optcondition
        REQUIRE(""#program base().\\nb:;c:;a:."" == parse(""a;b,c.""));
        REQUIRE(""#program base().\\nb:;c:;d:;a:."" == parse(""a;b;c;d.""));
        REQUIRE(""#program base().\\nb:;c:d,e;a:."" == parse(""a;b,c:d,e.""));
        REQUIRE(""#program base().\\nb:d,e;c:;a:."" == parse(""a;b:d,e;c.""));
        // literal COLON litvec SEM disjunctionsep literal optcondition
        REQUIRE(""#program base().\\nc:;a:."" == parse(""a;c.""));
        REQUIRE(""#program base().\\nc:;a:x."" == parse(""a:x;c.""));
        REQUIRE(""#program base().\\nc:;a:x,y."" == parse(""a:x,y;c.""));
        REQUIRE(""#program base().\\nb:;c:;a:x,y."" == parse(""a:x,y;b,c.""));
        REQUIRE(""#program base().\\nb:;c:;d:;a:x,y."" == parse(""a:x,y;b;c;d.""));
        REQUIRE(""#program base().\\nb:;c:d,e;a:x,y."" == parse(""a:x,y;b,c:d,e.""));
        REQUIRE(""#program base().\\nb:d,e;c:;a:x,y."" == parse(""a:x,y;b:d,e;c.""));
    }

    SECTION(""rule"") {
        // body literal
        REQUIRE(""#program base().\\n#false:-a;x."" == parse("":-a,x.""));
        REQUIRE(""#program base().\\n#false:-a;x."" == parse("":-a;x.""));
        REQUIRE(""#program base().\\n#false:-a;x."" == parse("":-a,x.""));
        // body aggregate
        REQUIRE(""#program base().\\n#false:-#count{};#count{}."" == parse("":-{},{}.""));
        REQUIRE(""#program base().\\n#false:-#count{};#count{}."" == parse("":-{};{}.""));
        REQUIRE(""#program base().\\n#false:-#not #count{};#not #count{}."" == parse("":-not{},not{}.""));
        REQUIRE(""#program base().\\n#false:-#not #count{};#not #count{}."" == parse("":-not{};not{}.""));
        REQUIRE(""#program base().\\n#false:-#not #not #count{};#not #not #count{}."" == parse("":-not not{},not not{}.""));
        REQUIRE(""#program base().\\n#false:-#not #not #count{};#not #not #count{}."" == parse("":-not not{};not not{}.""));
        REQUIRE(""#program base().\\n#false:-#not #not nott<=#count{};#not #not nott<=#count{}."" == parse("":-not not nott{},not not nott{}.""));
        REQUIRE(""#program base().\\n#false:-#not #not nott<=#count{};#not #not nott<=#count{}."" == parse("":-not not nott{};not not nott{}.""));
        // conjunction
        REQUIRE(""#program base().\\n#false:-a:;b:."" == parse("":-a:;b:.""));
        // head literal
        REQUIRE(""#program base().\\na."" == parse(""a.""));
        // head aggregate
        REQUIRE(""#program base().\\n#count{}."" == parse(""{}.""));
        REQUIRE(""#program base().\\nnott<=#count{}."" == parse(""nott{}.""));
        // disjunction
        REQUIRE(""#program base().\\nb:;a:."" == parse(""a,b.""));
        // rules
        REQUIRE(""#program base().\\na."" == parse(""a.""));
        REQUIRE(""#program base().\\na:-b."" == parse(""a:-b.""));
        REQUIRE(""#program base().\\na:-b;c."" == parse(""a:-b,c.""));
        REQUIRE(""#program base().\\n#false."" == parse("":-.""));
        REQUIRE(""#program base().\\n#false:-b."" == parse("":-b.""));
        REQUIRE(""#program base().\\n#false:-b;c."" == parse("":-b,c.""));
    }

    SECTION(""define"") {
        REQUIRE(""#program base().\\n#const a=10."" == parse(""#const a=10.""));
    }

    SECTION(""optimize"") {
        REQUIRE(""#program base().\\n:~p(X,Y).[X@Y,a]"" == parse("":~ p(X,Y). [X@Y,a]""));
        REQUIRE(""#program base().\\n:~p(X,Y);r;s.[X@0]"" == parse("":~ p(X,Y),r,s. [X]""));
        REQUIRE(""#program base().\\n:~p(X,Y);s.[X@Y,a]\\n:~q(Y).[Y@f]\\n:~.[1@0]"" == parse(""#minimize { X@Y,a : p(X,Y),s; Y@f : q(Y); 1 }.""));
        REQUIRE(""#program base()."" == parse(""#minimize { }.""));
        REQUIRE(""#program base().\\n:~p(X,Y);r.[-X@Y,a]\\n:~q(Y).[-Y@f]\\n:~.[-2@0]"" == parse(""#maximize { X@Y,a : p(X,Y), r; Y@f : q(Y); 2 }.""));
        REQUIRE(""#program base()."" == parse(""#maximize { }.""));
    }

    SECTION(""show"") {
        REQUIRE(""#program base().\\n#showsig p/1."" == parse(""#show p/1.""));
        REQUIRE(""#program base().\\n#showsig p/1."" == parse(""#show p  /  1.""));
        REQUIRE(""#program base().\\n#showsig -p/1."" == parse(""#show -p/1.""));
        REQUIRE(""#program base().\\n#show (-p/-1)."" == parse(""#show -p/-1.""));
        REQUIRE(""#program base().\\n#show X:p(X);1<=#count{q(X):p(X)}."" == parse(""#show X:p(X), 1 { q(X):p(X) }.""));
    }

    SECTION(""include"") {
        struct Del {
            Del()  { std::ofstream(""test_include.lp"") << ""b.\\n""; }
            ~Del() { std::remove(""test_include.lp""); }
        } del;
        REQUIRE(""#program base().\\na.\\nb.\\n#program base().\\nc.\\nd."" == parse(""a.\\n#include \\""test_include.lp\\"".\\nc.\\nd.\\n""));
    }

    SECTION(""csp"") {
        REQUIRE(""#program base().\\n1$<=1$*$x$<=10."" == parse(""1 $<= $x $<= 10.""));
        REQUIRE(""#program base().\\n1$*$a$<=X$*$x$+8$*$X$<=10:-p(X)."" == parse(""1 $* $a $<= $x $* X $+ 8 $* $X $<= 10 :- p(X).""));
        REQUIRE(""#program base().\\n#false:-a;b;not #disjoint{a:1$*$a:a,a,b:1$*$b:b}."" == parse(""#disjoint{a:$a:a,a; b:$b:b} :- a, b.""));
    }

    SECTION(""edge"") {
        REQUIRE(""#program base().\\n#edge(a,b)."" == parse(""#edge (a, b).""));
        REQUIRE(""#program base().\\n#edge(a,b;e,f)."" == parse(""#edge (a, b;e,f):.""));
        REQUIRE(""#program base().\\n#edge(a,b;e,f):p;q."" == parse(""#edge (a, b;e,f):p,q.""));
    }

    SECTION(""project"") {
        REQUIRE(""#program base().\\n#project a/1."" == parse(""#project a/1.""));
        REQUIRE(""#program base().\\n#project -a/1."" == parse(""#project -a/1.""));
        REQUIRE(""#program base().\\n#project a."" == parse(""#project a.""));
        REQUIRE(""#program base().\\n#project a."" == parse(""#project a:.""));
        REQUIRE(""#program base().\\n#project a:b;c."" == parse(""#project a:b,c.""));
    }

    SECTION(""heuristic"") {
        REQUIRE(""#program base().\\n#heuristic p:q.[1@2,level]"" == parse(""#heuristic p : q. [1@2,level]""));
        REQUIRE(""#program base().\\n#heuristic p:q.[1@2,sign]"" == parse(""#heuristic p : q. [1@2,sign]""));
        REQUIRE(""#program base().\\n#heuristic p:q.[1@2,true]"" == parse(""#heuristic p : q. [1@2,true]""));
        REQUIRE(""#program base().\\n#heuristic p:q.[1@2,false]"" == parse(""#heuristic p : q. [1@2,false]""));
        REQUIRE(""#program base().\\n#heuristic p:q.[1@2,factor]"" == parse(""#heuristic p : q. [1@2,factor]""));
        REQUIRE(""#program base().\\n#heuristic p:q;r.[1@2,init]"" == parse(""#heuristic p : q,r. [1@2,init]""));
        REQUIRE(""#program base().\\n#heuristic p.[1@0,init]"" == parse(""#heuristic p:. [1,init]""));
        REQUIRE(""#program base().\\n#heuristic p.[1@0,init]"" == parse(""#heuristic p. [1,init]""));
    }

    SECTION(""theory"") {
        // NOTE: things would be less error prone if : and ; would not be valid theory connectives
        REQUIRE(""#program base().\\n&x{}."" == parse(""&x { }.""));
        REQUIRE(""#program base().\\n#false:-&x{}."" == parse("":-&x { }.""));
        REQUIRE(""#program base().\\n&x{} < 42."" == parse(""&x { } < 42.""));
        REQUIRE(""#program base().\\n#false:-&x{} < 42."" == parse("":-&x { } < 42.""));
        REQUIRE(""#program base().\\n#false:-&x{} < 42 + 17 ^ (- 1)."" == parse("":-&x { } < 42+17^(-1).""));
        REQUIRE(""#program base().\\n#false:-&x{} < 42 + 17 ^ - 1."" == parse("":-&x { } < 42+17^ -1.""));
        REQUIRE(""#program base().\\n#false:-&x{} < 42 + 17 ^- 1."" == parse("":-&x { } < 42+17^-1.""));
        REQUIRE(""#program base().\\n&x{u,v: ; u: ; u: ; : ; :p ; :p,q}."" == parse(""&x { u,v; u ; u: ; : ; :p; :p,q }.""));
        REQUIRE(""#program base().\\n&x{u: ; u: ; : ; :p ; :p,q}."" == parse(""&x { u ; u: ; : ; :p; :p,q }.""));
        REQUIRE(""#program base().\\n&x{i(u + v ^ (a +- 3 * b),7 + (1,) *** (2) - () + [a ; b] ? {1 ; 2 ; 3}):}."" == parse(""&x { i(u+v^(a+- 3 * b),7+(1,)***(2)-()+[a,b]?{1,2,3}) }.""));
    }

    SECTION(""theoryDefinition"") {
        REQUIRE(""#program base().\\n#theory t{}."" == parse(""#theory t { }.""));
        REQUIRE(""#program base().\\n#theory t{x{}}."" == parse(""#theory t { x { } }.""));
        REQUIRE(""#program base().\\n#theory t{x{};y{}}."" == parse(""#theory t { x { }; y{} }.""));
        REQUIRE(""#program base().\\n#theory t{x{++ :42,unary}}."" == parse(""#theory t { x { ++ : 42, unary } }.""));
        REQUIRE(""#program base().\\n#theory t{x{++ :42,unary,** :21,binary,left,-* :1,binary,right}}."" == parse(""#theory t { x { ++ : 42, unary; ** : 21, binary, left; -* : 1, binary, right } }.""));
        REQUIRE(""#program base().\\n#theory t{x{};&a/0:x,any}."" == parse(""#theory t { x{}; &a/0: x, any }.""));
        REQUIRE(""#program base().\\n#theory t{x{};&a/0:x,any;&b/0:x,head;&c/0:x,body;&d/0:x,directive}."" == parse(""#theory t { x{}; &a/0: x, any; &b/0: x, head; &c/0: x, body; &d/0: x, directive }.""));
        REQUIRE(""#program base().\\n#theory t{x{};&a/0:x,{+,-,++,**},x,any}."" == parse(""#theory t { x{}; &a/0: x, {+,-, ++, **}, x, any }.""));
    }

}

} } } // namespace Test Input Gringo

",16202,False,2404.5649712280215,median
"// Copyright 2018 The SwiftShader Authors. 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.

#include ""VkPhysicalDevice.hpp""

#include ""VkConfig.hpp""
#include ""VkStringify.hpp""
#include ""Pipeline/SpirvShader.hpp""  // sw::SIMD::Width
#include ""Reactor/Reactor.hpp""

#include <cstring>
#include <limits>

#ifdef __ANDROID__
#	include <android/hardware_buffer.h>
#endif

namespace vk {

PhysicalDevice::PhysicalDevice(const void *, void *mem)
{
}

const VkPhysicalDeviceFeatures &PhysicalDevice::getFeatures() const
{
	static const VkPhysicalDeviceFeatures features{
		VK_TRUE,   // robustBufferAccess
		VK_TRUE,   // fullDrawIndexUint32
		VK_TRUE,   // imageCubeArray
		VK_TRUE,   // independentBlend
		VK_FALSE,  // geometryShader
		VK_FALSE,  // tessellationShader
		VK_TRUE,   // sampleRateShading
		VK_FALSE,  // dualSrcBlend
		VK_FALSE,  // logicOp
		VK_TRUE,   // multiDrawIndirect
		VK_TRUE,   // drawIndirectFirstInstance
		VK_TRUE,   // depthClamp
		VK_TRUE,   // depthBiasClamp
		VK_TRUE,   // fillModeNonSolid
		VK_TRUE,   // depthBounds
		VK_FALSE,  // wideLines
		VK_TRUE,   // largePoints
		VK_FALSE,  // alphaToOne
		VK_FALSE,  // multiViewport
		VK_TRUE,   // samplerAnisotropy
		VK_TRUE,   // textureCompressionETC2
#ifdef SWIFTSHADER_ENABLE_ASTC
		VK_TRUE,  // textureCompressionASTC_LDR
#else
		VK_FALSE,  // textureCompressionASTC_LDR
#endif
		VK_TRUE,   // textureCompressionBC
		VK_TRUE,   // occlusionQueryPrecise
		VK_FALSE,  // pipelineStatisticsQuery
		VK_TRUE,   // vertexPipelineStoresAndAtomics
		VK_TRUE,   // fragmentStoresAndAtomics
		VK_FALSE,  // shaderTessellationAndGeometryPointSize
		VK_FALSE,  // shaderImageGatherExtended
		VK_TRUE,   // shaderStorageImageExtendedFormats
		VK_TRUE,   // shaderStorageImageMultisample
		VK_FALSE,  // shaderStorageImageReadWithoutFormat
		VK_FALSE,  // shaderStorageImageWriteWithoutFormat
		VK_TRUE,   // shaderUniformBufferArrayDynamicIndexing
		VK_TRUE,   // shaderSampledImageArrayDynamicIndexing
		VK_TRUE,   // shaderStorageBufferArrayDynamicIndexing
		VK_TRUE,   // shaderStorageImageArrayDynamicIndexing
		VK_TRUE,   // shaderClipDistance
		VK_TRUE,   // shaderCullDistance
		VK_FALSE,  // shaderFloat64
		VK_FALSE,  // shaderInt64
		VK_FALSE,  // shaderInt16
		VK_FALSE,  // shaderResourceResidency
		VK_FALSE,  // shaderResourceMinLod
		VK_FALSE,  // sparseBinding
		VK_FALSE,  // sparseResidencyBuffer
		VK_FALSE,  // sparseResidencyImage2D
		VK_FALSE,  // sparseResidencyImage3D
		VK_FALSE,  // sparseResidency2Samples
		VK_FALSE,  // sparseResidency4Samples
		VK_FALSE,  // sparseResidency8Samples
		VK_FALSE,  // sparseResidency16Samples
		VK_FALSE,  // sparseResidencyAliased
		VK_TRUE,   // variableMultisampleRate
		VK_FALSE,  // inheritedQueries
	};

	return features;
}

template<typename T>
static void getPhysicalDeviceSamplerYcbcrConversionFeatures(T *features)
{
	features->samplerYcbcrConversion = VK_TRUE;
}

template<typename T>
static void getPhysicalDevice16BitStorageFeatures(T *features)
{
	features->storageBuffer16BitAccess = VK_FALSE;
	features->storageInputOutput16 = VK_FALSE;
	features->storagePushConstant16 = VK_FALSE;
	features->uniformAndStorageBuffer16BitAccess = VK_FALSE;
}

template<typename T>
static void getPhysicalDeviceVariablePointersFeatures(T *features)
{
	features->variablePointersStorageBuffer = VK_FALSE;
	features->variablePointers = VK_FALSE;
}

template<typename T>
static void getPhysicalDevice8BitStorageFeaturesKHR(T *features)
{
	features->storageBuffer8BitAccess = VK_FALSE;
	features->uniformAndStorageBuffer8BitAccess = VK_FALSE;
	features->storagePushConstant8 = VK_FALSE;
}

template<typename T>
static void getPhysicalDeviceMultiviewFeatures(T *features)
{
	features->multiview = VK_TRUE;
	features->multiviewGeometryShader = VK_FALSE;
	features->multiviewTessellationShader = VK_FALSE;
}

template<typename T>
static void getPhysicalDeviceProtectedMemoryFeatures(T *features)
{
	features->protectedMemory = VK_FALSE;
}

template<typename T>
static void getPhysicalDeviceShaderDrawParameterFeatures(T *features)
{
	features->shaderDrawParameters = VK_FALSE;
}

template<typename T>
static void getPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR(T *features)
{
	features->separateDepthStencilLayouts = VK_TRUE;
}

template<typename T>
static void getPhysicalDeviceLineRasterizationFeaturesEXT(T *features)
{
	features->rectangularLines = VK_TRUE;
	features->bresenhamLines = VK_TRUE;
	features->smoothLines = VK_FALSE;
	features->stippledRectangularLines = VK_FALSE;
	features->stippledBresenhamLines = VK_FALSE;
	features->stippledSmoothLines = VK_FALSE;
}

template<typename T>
static void getPhysicalDeviceProvokingVertexFeaturesEXT(T *features)
{
	features->provokingVertexLast = VK_TRUE;
}

template<typename T>
static void getPhysicalDeviceHostQueryResetFeatures(T *features)
{
	features->hostQueryReset = VK_TRUE;
}

template<typename T>
static void getPhysicalDeviceImageRobustnessFeaturesEXT(T *features)
{
	features->robustImageAccess = VK_TRUE;
}

template<typename T>
static void getPhysicalDeviceShaderDrawParametersFeatures(T *features)
{
	features->shaderDrawParameters = VK_FALSE;
}

template<typename T>
static void getPhysicalDeviceVulkan11Features(T *features)
{
	getPhysicalDevice16BitStorageFeatures(features);
	getPhysicalDeviceMultiviewFeatures(features);
	getPhysicalDeviceVariablePointersFeatures(features);
	getPhysicalDeviceProtectedMemoryFeatures(features);
	getPhysicalDeviceSamplerYcbcrConversionFeatures(features);
	getPhysicalDeviceShaderDrawParametersFeatures(features);
}

template<typename T>
static void getPhysicalDeviceImagelessFramebufferFeatures(T *features)
{
	features->imagelessFramebuffer = VK_TRUE;
}

template<typename T>
static void getPhysicalDeviceShaderSubgroupExtendedTypesFeatures(T *features)
{
	features->shaderSubgroupExtendedTypes = VK_TRUE;
}

template<typename T>
static void getPhysicalDeviceScalarBlockLayoutFeatures(T *features)
{
	features->scalarBlockLayout = VK_TRUE;
}

#ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
template<typename T>
static void getPhysicalDeviceDeviceMemoryReportFeaturesEXT(T *features)
{
	features->deviceMemoryReport = VK_TRUE;
}
#endif  // SWIFTSHADER_DEVICE_MEMORY_REPORT

template<typename T>
static void getPhysicalDeviceUniformBufferStandardLayoutFeatures(T *features)
{
	features->uniformBufferStandardLayout = VK_TRUE;
}

template<typename T>
static void getPhysicalDeviceDescriptorIndexingFeatures(T *features)
{
	features->shaderInputAttachmentArrayDynamicIndexing = VK_FALSE;
	features->shaderUniformTexelBufferArrayDynamicIndexing = VK_FALSE;
	features->shaderStorageTexelBufferArrayDynamicIndexing = VK_FALSE;
	features->shaderUniformBufferArrayNonUniformIndexing = VK_FALSE;
	features->shaderSampledImageArrayNonUniformIndexing = VK_FALSE;
	features->shaderStorageBufferArrayNonUniformIndexing = VK_FALSE;
	features->shaderStorageImageArrayNonUniformIndexing = VK_FALSE;
	features->shaderInputAttachmentArrayNonUniformIndexing = VK_FALSE;
	features->shaderUniformTexelBufferArrayNonUniformIndexing = VK_FALSE;
	features->shaderStorageTexelBufferArrayNonUniformIndexing = VK_FALSE;
	features->descriptorBindingUniformBufferUpdateAfterBind = VK_FALSE;
	features->descriptorBindingSampledImageUpdateAfterBind = VK_FALSE;
	features->descriptorBindingStorageImageUpdateAfterBind = VK_FALSE;
	features->descriptorBindingStorageBufferUpdateAfterBind = VK_FALSE;
	features->descriptorBindingUniformTexelBufferUpdateAfterBind = VK_FALSE;
	features->descriptorBindingStorageTexelBufferUpdateAfterBind = VK_FALSE;
	features->descriptorBindingUpdateUnusedWhilePending = VK_FALSE;
	features->descriptorBindingPartiallyBound = VK_FALSE;
	features->descriptorBindingVariableDescriptorCount = VK_FALSE;
	features->runtimeDescriptorArray = VK_FALSE;
}

template<typename T>
static void getPhysicalDeviceVulkanMemoryModelFeatures(T *features)
{
	features->vulkanMemoryModel = VK_FALSE;
	features->vulkanMemoryModelDeviceScope = VK_FALSE;
	features->vulkanMemoryModelAvailabilityVisibilityChains = VK_FALSE;
}

template<typename T>
static void getPhysicalDeviceTimelineSemaphoreFeatures(T *features)
{
	features->timelineSemaphore = VK_TRUE;
}

template<typename T>
static void getPhysicalDeviceShaderAtomicInt64Features(T *features)
{
	features->shaderBufferInt64Atomics = VK_FALSE;
	features->shaderSharedInt64Atomics = VK_FALSE;
}

template<typename T>
static void getPhysicalDeviceShaderFloat16Int8Features(T *features)
{
	features->shaderFloat16 = VK_FALSE;
	features->shaderInt8 = VK_FALSE;
}

template<typename T>
static void getPhysicalDeviceBufferDeviceAddressFeatures(T *features)
{
	features->bufferDeviceAddress = VK_FALSE;
	features->bufferDeviceAddressCaptureReplay = VK_FALSE;
	features->bufferDeviceAddressMultiDevice = VK_FALSE;
}

template<typename T>
static void getPhysicalDeviceVulkan12Features(T *features)
{
	features->samplerMirrorClampToEdge = VK_FALSE;
	features->drawIndirectCount = VK_FALSE;
	getPhysicalDevice8BitStorageFeaturesKHR(features);
	getPhysicalDeviceShaderAtomicInt64Features(features);
	getPhysicalDeviceShaderFloat16Int8Features(features);
	features->descriptorIndexing = VK_FALSE;
	getPhysicalDeviceDescriptorIndexingFeatures(features);
	features->samplerFilterMinmax = VK_FALSE;
	getPhysicalDeviceScalarBlockLayoutFeatures(features);
	getPhysicalDeviceImagelessFramebufferFeatures(features);
	getPhysicalDeviceUniformBufferStandardLayoutFeatures(features);
	getPhysicalDeviceShaderSubgroupExtendedTypesFeatures(features);
	getPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR(features);
	getPhysicalDeviceHostQueryResetFeatures(features);
	getPhysicalDeviceTimelineSemaphoreFeatures(features);
	getPhysicalDeviceBufferDeviceAddressFeatures(features);
	getPhysicalDeviceVulkanMemoryModelFeatures(features);
	features->shaderOutputViewportIndex = VK_FALSE;
	features->shaderOutputLayer = VK_FALSE;
	features->subgroupBroadcastDynamicId = VK_TRUE;
}

template<typename T>
static void getPhysicalDeviceDepthClipEnableFeaturesExt(T *features)
{
	features->depthClipEnable = VK_TRUE;
}

void PhysicalDevice::getFeatures2(VkPhysicalDeviceFeatures2 *features) const
{
	features->features = getFeatures();
	VkBaseOutStructure *curExtension = reinterpret_cast<VkBaseOutStructure *>(features->pNext);
	while(curExtension != nullptr)
	{
		// Need to switch on an integer since Provoking Vertex isn't a part of the Vulkan spec.
		switch((int)curExtension->sType)
		{
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_1_FEATURES:
			getPhysicalDeviceVulkan11Features(reinterpret_cast<VkPhysicalDeviceVulkan11Features *>(curExtension));
			break;
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_1_2_FEATURES:
			getPhysicalDeviceVulkan12Features(reinterpret_cast<VkPhysicalDeviceVulkan12Features *>(curExtension));
			break;
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES:
			getPhysicalDeviceMultiviewFeatures(reinterpret_cast<VkPhysicalDeviceMultiviewFeatures *>(curExtension));
			break;
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES:
			getPhysicalDeviceVariablePointersFeatures(reinterpret_cast<VkPhysicalDeviceVariablePointersFeatures *>(curExtension));
			break;
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES:
			getPhysicalDevice16BitStorageFeatures(reinterpret_cast<VkPhysicalDevice16BitStorageFeatures *>(curExtension));
			break;
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES:
			getPhysicalDeviceSamplerYcbcrConversionFeatures(reinterpret_cast<VkPhysicalDeviceSamplerYcbcrConversionFeatures *>(curExtension));
			break;
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES:
			getPhysicalDeviceProtectedMemoryFeatures(reinterpret_cast<VkPhysicalDeviceProtectedMemoryFeatures *>(curExtension));
			break;
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES:
			getPhysicalDeviceShaderDrawParameterFeatures(reinterpret_cast<VkPhysicalDeviceShaderDrawParameterFeatures *>(curExtension));
			break;
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES:
			getPhysicalDeviceHostQueryResetFeatures(reinterpret_cast<VkPhysicalDeviceHostQueryResetFeatures *>(curExtension));
			break;
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_ROBUSTNESS_FEATURES_EXT:
			getPhysicalDeviceImageRobustnessFeaturesEXT(reinterpret_cast<VkPhysicalDeviceImageRobustnessFeaturesEXT *>(curExtension));
			break;
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT:
			getPhysicalDeviceLineRasterizationFeaturesEXT(reinterpret_cast<VkPhysicalDeviceLineRasterizationFeaturesEXT *>(curExtension));
			break;
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES:
			getPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR(reinterpret_cast<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures *>(curExtension));
			break;
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES_KHR:
			getPhysicalDevice8BitStorageFeaturesKHR(reinterpret_cast<VkPhysicalDevice8BitStorageFeaturesKHR *>(curExtension));
			break;
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROVOKING_VERTEX_FEATURES_EXT:
			getPhysicalDeviceProvokingVertexFeaturesEXT(reinterpret_cast<VkPhysicalDeviceProvokingVertexFeaturesEXT *>(curExtension));
			break;
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES:
			getPhysicalDeviceImagelessFramebufferFeatures(reinterpret_cast<VkPhysicalDeviceImagelessFramebufferFeatures *>(curExtension));
			break;
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES_KHR:
			getPhysicalDeviceShaderSubgroupExtendedTypesFeatures(reinterpret_cast<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures *>(curExtension));
			break;
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES:
			getPhysicalDeviceScalarBlockLayoutFeatures(reinterpret_cast<VkPhysicalDeviceScalarBlockLayoutFeatures *>(curExtension));
			break;
#ifdef SWIFTSHADER_DEVICE_MEMORY_REPORT
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEVICE_MEMORY_REPORT_FEATURES_EXT:
			getPhysicalDeviceDeviceMemoryReportFeaturesEXT(reinterpret_cast<VkPhysicalDeviceDeviceMemoryReportFeaturesEXT *>(curExtension));
			break;
#endif  // SWIFTSHADER_DEVICE_MEMORY_REPORT
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES:
			getPhysicalDeviceUniformBufferStandardLayoutFeatures(reinterpret_cast<VkPhysicalDeviceUniformBufferStandardLayoutFeatures *>(curExtension));
			break;
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES:
			getPhysicalDeviceVulkanMemoryModelFeatures(reinterpret_cast<VkPhysicalDeviceVulkanMemoryModelFeatures *>(curExtension));
			break;
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES:
			getPhysicalDeviceTimelineSemaphoreFeatures(reinterpret_cast<VkPhysicalDeviceTimelineSemaphoreFeatures *>(curExtension));
			break;
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES:
			getPhysicalDeviceShaderAtomicInt64Features(reinterpret_cast<VkPhysicalDeviceShaderAtomicInt64Features *>(curExtension));
			break;
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES:
			getPhysicalDeviceShaderFloat16Int8Features(reinterpret_cast<VkPhysicalDeviceShaderFloat16Int8Features *>(curExtension));
			break;
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES:
			getPhysicalDeviceBufferDeviceAddressFeatures(reinterpret_cast<VkPhysicalDeviceBufferDeviceAddressFeatures *>(curExtension));
			break;
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES:
			getPhysicalDeviceDescriptorIndexingFeatures(reinterpret_cast<VkPhysicalDeviceDescriptorIndexingFeatures *>(curExtension));
			break;
		case VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT:
			getPhysicalDeviceDepthClipEnableFeaturesExt(reinterpret_cast<VkPhysicalDeviceDepthClipEnableFeaturesEXT *>(curExtension));
			break;
		default:
			LOG_TRAP(""curExtension->pNext->sType = %s"", vk::Stringify(curExtension->sType).c_str());
			break;
		}
		curExtension = reinterpret_cast<VkBaseOutStructure *>(curExtension->pNext);
	}
}

VkSampleCountFlags PhysicalDevice::getSampleCounts() const
{
	return VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT;
}

const VkPhysicalDeviceLimits &PhysicalDevice::getLimits() const
{
	VkSampleCountFlags sampleCounts = getSampleCounts();

	static const VkPhysicalDeviceLimits limits = {
		1 << (vk::MAX_IMAGE_LEVELS_1D - 1),               // maxImageDimension1D
		1 << (vk::MAX_IMAGE_LEVELS_2D - 1),               // maxImageDimension2D
		1 << (vk::MAX_IMAGE_LEVELS_3D - 1),               // maxImageDimension3D
		1 << (vk::MAX_IMAGE_LEVELS_CUBE - 1),             // maxImageDimensionCube
		vk::MAX_IMAGE_ARRAY_LAYERS,                       // maxImageArrayLayers
		65536,                                            // maxTexelBufferElements
		16384,                                            // maxUniformBufferRange
		(1ul << 27),                                      // maxStorageBufferRange
		vk::MAX_PUSH_CONSTANT_SIZE,                       // maxPushConstantsSize
		4096,                                             // maxMemoryAllocationCount
		4000,                                             // maxSamplerAllocationCount
		131072,                                           // bufferImageGranularity
		0,                                                // sparseAddressSpaceSize (unsupported)
		MAX_BOUND_DESCRIPTOR_SETS,                        // maxBoundDescriptorSets
		16,                                               // maxPerStageDescriptorSamplers
		14,                                               // maxPerStageDescriptorUniformBuffers
		16,                                               // maxPerStageDescriptorStorageBuffers
		16,                                               // maxPerStageDescriptorSampledImages
		4,                                                // maxPerStageDescriptorStorageImages
		sw::RENDERTARGETS,                                // maxPerStageDescriptorInputAttachments
		128,                                              // maxPerStageResources
		96,                                               // maxDescriptorSetSamplers
		72,                                               // maxDescriptorSetUniformBuffers
		MAX_DESCRIPTOR_SET_UNIFORM_BUFFERS_DYNAMIC,       // maxDescriptorSetUniformBuffersDynamic
		24,                                               // maxDescriptorSetStorageBuffers
		MAX_DESCRIPTOR_SET_STORAGE_BUFFERS_DYNAMIC,       // maxDescriptorSetStorageBuffersDynamic
		96,                                               // maxDescriptorSetSampledImages
		24,                                               // maxDescriptorSetStorageImages
		sw::RENDERTARGETS,                                // maxDescriptorSetInputAttachments
		16,                                               // maxVertexInputAttributes
		vk::MAX_VERTEX_INPUT_BINDINGS,                    // maxVertexInputBindings
		2047,                                             // maxVertexInputAttributeOffset
		2048,                                             // maxVertexInputBindingStride
		sw::MAX_INTERFACE_COMPONENTS,                     // maxVertexOutputComponents
		0,                                                // maxTessellationGenerationLevel (unsupported)
		0,                                                // maxTessellationPatchSize (unsupported)
		0,                                                // maxTessellationControlPerVertexInputComponents (unsupported)
		0,                                                // maxTessellationControlPerVertexOutputComponents (unsupported)
		0,                                                // maxTessellationControlPerPatchOutputComponents (unsupported)
		0,                                                // maxTessellationControlTotalOutputComponents (unsupported)
		0,                                                // maxTessellationEvaluationInputComponents (unsupported)
		0,                                                // maxTessellationEvaluationOutputComponents (unsupported)
		0,                                                // maxGeometryShaderInvocations (unsupported)
		0,                                                // maxGeometryInputComponents (unsupported)
		0,                                                // maxGeometryOutputComponents (unsupported)
		0,                                                // maxGeometryOutputVertices (unsupported)
		0,                                                // maxGeometryTotalOutputComponents (unsupported)
		sw::MAX_INTERFACE_COMPONENTS,                     // maxFragmentInputComponents
		sw::RENDERTARGETS,                                // maxFragmentOutputAttachments
		1,                                                // maxFragmentDualSrcAttachments
		4,                                                // maxFragmentCombinedOutputResources
		16384,                                            // maxComputeSharedMemorySize
		{ 65535, 65535, 65535 },                          // maxComputeWorkGroupCount[3]
		128,                                              // maxComputeWorkGroupInvocations
		{ 128, 128, 64 },                                 // maxComputeWorkGroupSize[3]
		vk::SUBPIXEL_PRECISION_BITS,                      // subPixelPrecisionBits
		4,                                                // subTexelPrecisionBits
		4,                                                // mipmapPrecisionBits
		UINT32_MAX,                                       // maxDrawIndexedIndexValue
		UINT32_MAX,                                       // maxDrawIndirectCount
		vk::MAX_SAMPLER_LOD_BIAS,                         // maxSamplerLodBias
		16,                                               // maxSamplerAnisotropy
		16,                                               // maxViewports
		{ 4096, 4096 },                                   // maxViewportDimensions[2]
		{ -8192, 8191 },                                  // viewportBoundsRange[2]
		0,                                                // viewportSubPixelBits
		64,                                               // minMemoryMapAlignment
		vk::MIN_TEXEL_BUFFER_OFFSET_ALIGNMENT,            // minTexelBufferOffsetAlignment
		vk::MIN_UNIFORM_BUFFER_OFFSET_ALIGNMENT,          // minUniformBufferOffsetAlignment
		vk::MIN_STORAGE_BUFFER_OFFSET_ALIGNMENT,          // minStorageBufferOffsetAlignment
		sw::MIN_TEXEL_OFFSET,                             // minTexelOffset
		sw::MAX_TEXEL_OFFSET,                             // maxTexelOffset
		sw::MIN_TEXEL_OFFSET,                             // minTexelGatherOffset
		sw::MAX_TEXEL_OFFSET,                             // maxTexelGatherOffset
		-0.5,                                             // minInterpolationOffset
		0.5,                                              // maxInterpolationOffset
		4,                                                // subPixelInterpolationOffsetBits
		4096,                                             // maxFramebufferWidth
		4096,                                             // maxFramebufferHeight
		256,                                              // maxFramebufferLayers
		sampleCounts,                                     // framebufferColorSampleCounts
		sampleCounts,                                     // framebufferDepthSampleCounts
		sampleCounts,                                     // framebufferStencilSampleCounts
		sampleCounts,                                     // framebufferNoAttachmentsSampleCounts
		sw::RENDERTARGETS,                                // maxColorAttachments
		sampleCounts,                                     // sampledImageColorSampleCounts
		sampleCounts,                                     // sampledImageIntegerSampleCounts
		sampleCounts,                                     // sampledImageDepthSampleCounts
		sampleCounts,                                     // sampledImageStencilSampleCounts
		sampleCounts,                                     // storageImageSampleCounts
		1,                                                // maxSampleMaskWords
		VK_TRUE,                                          // timestampComputeAndGraphics
		1,                                                // timestampPeriod
		sw::MAX_CLIP_DISTANCES,                           // maxClipDistances
		sw::MAX_CULL_DISTANCES,                           // maxCullDistances
		sw::MAX_CLIP_DISTANCES + sw::MAX_CULL_DISTANCES,  // maxCombinedClipAndCullDistances
		2,                                                // discreteQueuePriorities
		{ 1.0, vk::MAX_POINT_SIZE },                      // pointSizeRange[2]
		{ 1.0, 1.0 },                                     // lineWidthRange[2] (unsupported)
		0.0,                                              // pointSizeGranularity (unsupported)
		0.0,                                              // lineWidthGranularity (unsupported)
		VK_TRUE,                                          // strictLines
		VK_TRUE,                                          // standardSampleLocations
		64,                                               // optimalBufferCopyOffsetAlignment
		64,                                               // optimalBufferCopyRowPitchAlignment
		256,                                              // nonCoherentAtomSize
	};

	return limits;
}

const VkPhysicalDeviceProperties &PhysicalDevice::getProperties() const
{
	auto getProperties = [&]() -> VkPhysicalDeviceProperties {
		VkPhysicalDeviceProperties properties = {
			API_VERSION,
			DRIVER_VERSION,
			VENDOR_ID,
			DEVICE_ID,
			VK_PHYSICAL_DEVICE_TYPE_CPU,  // deviceType
			"""",                           // deviceName
			SWIFTSHADER_UUID,             // pipelineCacheUUID
			getLimits(),                  // limits
			{}                            // sparseProperties
		};

		// Append Reactor JIT backend name and version
		snprintf(properties.deviceName, VK_MAX_PHYSICAL_DEVICE_NAME_SIZE,
		         ""%s (%s)"", SWIFTSHADER_DEVICE_NAME, rr::BackendName().c_str());

		return properties;
	};

	static const VkPhysicalDeviceProperties properties = getProperties();
	return properties;
}

template<typename T>
static void getIdProperties(T *properties)
{
	memset(properties->deviceUUID, 0, VK_UUID_SIZE);
	memset(properties->driverUUID, 0, VK_UUID_SIZE);
	memset(properties->deviceLUID, 0, VK_LUID_SIZE);

	memcpy(properties->deviceUUID, SWIFTSHADER_UUID, VK_UUID_SIZE);
	*((uint64_t *)properties->driverUUID) = DRIVER_VERSION;

	properties->deviceNodeMask = 0;
	properties->deviceLUIDValid = VK_FALSE;
}

void PhysicalDevice::getProperties(VkPhysicalDeviceIDProperties *properties) const
{
	getIdProperties(properties);
}

template<typename T>
static void getMaintenance3Properties(T *properties)
{
	properties->maxMemoryAllocationSize = MAX_MEMORY_ALLOCATION_SIZE;
	properties->maxPerSetDescriptors = 1024;
}

void PhysicalDevice::getProperties(VkPhysicalDeviceMaintenance3Properties *properties) const
{
	getMaintenance3Properties(properties);
}

template<typename T>
static void getMultiviewProperties(T *properties)
{
	properties->maxMultiviewViewCount = 6;
	properties->maxMultiviewInstanceIndex = 1u << 27;
}

void PhysicalDevice::getProperties(VkPhysicalDeviceMultiviewProperties *properties) const
{
	getMultiviewProperties(properties);
}

template<typename T>
static void getPointClippingProperties(T *properties)
{
	properties->pointClippingBehavior = VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES;
}

void PhysicalDevice::getProperties(VkPhysicalDevicePointClippingProperties *properties) const
{
	getPointClippingProperties(properties);
}

template<typename T>
static void getProtectedMemoryProperties(T *properties)
{
	properties->protectedNoFault = VK_FALSE;
}

void PhysicalDevice::getProperties(VkPhysicalDeviceProtectedMemoryProperties *properties) const
{
	getProtectedMemoryProperties(properties);
}

void PhysicalDevice::getProperties(VkPhysicalDeviceSubgroupProperties *properties) const
{
	properties->subgroupSize = sw::SIMD::Width;
	properties->supportedStages = VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT | VK_SHADER_STAGE_COMPUTE_BIT;
	properties->supportedOperations =
	    VK_SUBGROUP_FEATURE_BASIC_BIT |
	    VK_SUBGROUP_FEATURE_VOTE_BIT |
	    VK_SUBGROUP_FEATURE_ARITHMETIC_BIT |
	    VK_SUBGROUP_FEATURE_BALLOT_BIT |
	    VK_SUBGROUP_FEATURE_SHUFFLE_BIT |
	    VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT;
	properties->quadOperationsInAllStages = VK_FALSE;
}

void PhysicalDevice::getProperties(VkPhysicalDeviceVulkan11Properties *properties) const
{
	getIdProperties(properties);

	// We can't use templated functions for Vulkan11 & subgroup properties. The names of the
	// variables in VkPhysicalDeviceSubgroupProperties differ from the names in the Vulkan11
	// struct.
	VkPhysicalDeviceSubgroupProperties subgroupProperties = {};
	getProperties(&subgroupProperties);
	properties->subgroupSize = subgroupProperties.subgroupSize;
	properties->subgroupSupportedStages = subgroupProperties.supportedStages;
	properties->subgroupSupportedOperations = subgroupProperties.supportedOperations;
	properties->subgroupQuadOperationsInAllStages = subgroupProperties.quadOperationsInAllStages;

	getPointClippingProperties(properties);
	getMultiviewProperties(properties);
	getProtectedMemoryProperties(properties);
	getMaintenance3Properties(properties);
}

void PhysicalDevice::getProperties(const VkExternalMemoryHandleTypeFlagBits *handleType, VkExternalImageFormatProperties *properties) const
{
	VkExternalMemoryProperties *extMemProperties = &properties->externalMemoryProperties;
#if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
	if(*handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT)
	{
		extMemProperties->compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
		extMemProperties->exportFromImportedHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
		extMemProperties->externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
		return;
	}
#endif
#if SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER
	if(*handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)
	{
		extMemProperties->compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
		extMemProperties->exportFromImportedHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
		extMemProperties->externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT;
		return;
	}
#endif
#if VK_USE_PLATFORM_FUCHSIA
	if(handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA)
	{
		properties->compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA;
		properties->exportFromImportedHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA;
		properties->externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
		return;
	}
#endif
	extMemProperties->compatibleHandleTypes = 0;
	extMemProperties->exportFromImportedHandleTypes = 0;
	extMemProperties->externalMemoryFeatures = 0;
}

void PhysicalDevice::getProperties(const VkExternalMemoryHandleTypeFlagBits *handleType, VkExternalBufferProperties *properties) const
{
	VkExternalMemoryProperties *extMemProperties = &properties->externalMemoryProperties;
#if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
	if(*handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT)
	{
		extMemProperties->compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
		extMemProperties->exportFromImportedHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
		extMemProperties->externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
		return;
	}
#endif
#if SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER
	if(*handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)
	{
		extMemProperties->compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
		extMemProperties->exportFromImportedHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
		extMemProperties->externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
		return;
	}
#endif
#if VK_USE_PLATFORM_FUCHSIA
	if(handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA)
	{
		properties->compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA;
		properties->exportFromImportedHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_TEMP_ZIRCON_VMO_BIT_FUCHSIA;
		properties->externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
		return;
	}
#endif
	extMemProperties->compatibleHandleTypes = 0;
	extMemProperties->exportFromImportedHandleTypes = 0;
	extMemProperties->externalMemoryFeatures = 0;
}

void PhysicalDevice::getProperties(VkSamplerYcbcrConversionImageFormatProperties *properties) const
{
	properties->combinedImageSamplerDescriptorCount = 1;  // Need only one descriptor for YCbCr sampling.
}

#ifdef __ANDROID__
void PhysicalDevice::getProperties(VkPhysicalDevicePresentationPropertiesANDROID *properties) const
{
	properties->sharedImage = VK_FALSE;
}

void PhysicalDevice::getProperties(const VkPhysicalDeviceImageFormatInfo2 *pImageFormatInfo, VkAndroidHardwareBufferUsageANDROID *ahbProperties) const
{
	// Maps VkImageUsageFlags to AHB usage flags using this table from the Vulkan spec
	// https://www.khronos.org/registry/vulkan/specs/1.2-extensions/html/vkspec.html#memory-external-android-hardware-buffer-usage

	// VK_IMAGE_CREATE_PROTECTED_BIT not currently supported.
	ASSERT((pImageFormatInfo->flags & VK_IMAGE_CREATE_PROTECTED_BIT) == 0);

	// ""It must include at least one GPU usage flag (AHARDWAREBUFFER_USAGE_GPU_*), even if none of the corresponding Vulkan usages or flags are requested.""
	uint64_t ahbUsage = AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;

	// Already covered by the default GPU usage flag above.
	//
	// if ((vkUsageFlags & VK_IMAGE_USAGE_SAMPLED_BIT) || (vkUsageFlags & VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT))
	// {
	// 	 ahbUsage |= AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
	// }

	if((pImageFormatInfo->usage & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) || (pImageFormatInfo->usage & VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT))
	{
		ahbUsage |= AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER;
	}

	if(pImageFormatInfo->flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)
	{
		ahbUsage |= AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP;
	}

	if(pImageFormatInfo->flags & VK_IMAGE_CREATE_PROTECTED_BIT)
	{
		ahbUsage |= AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT;
	}

	ahbProperties->androidHardwareBufferUsage = ahbUsage;
}
#endif

void PhysicalDevice::getProperties(const VkPhysicalDeviceExternalBufferInfo *pExternalBufferInfo, VkExternalBufferProperties *pExternalBufferProperties) const
{
	VkExternalMemoryProperties *properties = &pExternalBufferProperties->externalMemoryProperties;

#if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD || SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER
	const VkExternalMemoryHandleTypeFlagBits *handleType = &pExternalBufferInfo->handleType;
#endif

#if SWIFTSHADER_EXTERNAL_MEMORY_OPAQUE_FD
	if(*handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT)
	{
		properties->compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
		properties->exportFromImportedHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT;
		properties->externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
		return;
	}
#endif
#if SWIFTSHADER_EXTERNAL_MEMORY_ANDROID_HARDWARE_BUFFER
	if(*handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)
	{
		properties->compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
		properties->exportFromImportedHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
		properties->externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT;
		return;
	}
#endif
	properties->compatibleHandleTypes = 0;
	properties->exportFromImportedHandleTypes = 0;
	properties->externalMemoryFeatures = 0;
}

void PhysicalDevice::getProperties(const VkPhysicalDeviceExternalFenceInfo *pExternalFenceInfo, VkExternalFenceProperties *pExternalFenceProperties) const
{
	pExternalFenceProperties->compatibleHandleTypes = 0;
	pExternalFenceProperties->exportFromImportedHandleTypes = 0;
	pExternalFenceProperties->externalFenceFeatures = 0;
}

void PhysicalDevice::getProperties(const VkPhysicalDeviceExternalSemaphoreInfo *pExternalSemaphoreInfo, VkExternalSemaphoreProperties *pExternalSemaphoreProperties) const
{
	for(const auto *nextInfo = reinterpret_cast<const VkBaseInStructure *>(pExternalSemaphoreInfo->pNext);
	    nextInfo != nullptr; nextInfo = nextInfo->pNext)
	{
		switch(nextInfo->sType)
		{
		case VK_STRUCTURE_TYPE_SEMAPHORE_TYPE_CREATE_INFO:
			{
				const auto *tlsInfo = reinterpret_cast<const VkSemaphoreTypeCreateInfo *>(nextInfo);
				// Timeline Semaphore does not support external semaphore
				if(tlsInfo->semaphoreType == VK_SEMAPHORE_TYPE_TIMELINE)
				{
					pExternalSemaphoreProperties->compatibleHandleTypes = 0;
					pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0;
					pExternalSemaphoreProperties->externalSemaphoreFeatures = 0;
					return;
				}
			}
			break;
		default:
			WARN(""nextInfo->sType = %s"", vk::Stringify(nextInfo->sType).c_str());
			break;
		}
	}

#if SWIFTSHADER_EXTERNAL_SEMAPHORE_OPAQUE_FD
	if(pExternalSemaphoreInfo->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT)
	{
		pExternalSemaphoreProperties->compatibleHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
		pExternalSemaphoreProperties->exportFromImportedHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT;
		pExternalSemaphoreProperties->externalSemaphoreFeatures = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT | VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT;
		return;
	}
#endif
#if VK_USE_PLATFORM_FUCHSIA
	if(pExternalSemaphoreInfo->handleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TEMP_ZIRCON_EVENT_BIT_FUCHSIA)
	{
		pExternalSemaphoreProperties->compatibleHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TEMP_ZIRCON_EVENT_BIT_FUCHSIA;
		pExternalSemaphoreProperties->exportFromImportedHandleTypes = VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_TEMP_ZIRCON_EVENT_BIT_FUCHSIA;
		pExternalSemaphoreProperties->externalSemaphoreFeatures = VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT | VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT;
		return;
	}
#endif
	pExternalSemaphoreProperties->compatibleHandleTypes = 0;
	pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0;
	pExternalSemaphoreProperties->externalSemaphoreFeatures = 0;
}

void PhysicalDevice::getProperties(VkPhysicalDeviceExternalMemoryHostPropertiesEXT *properties) const
{
	properties->minImportedHostPointerAlignment = REQUIRED_MEMORY_ALIGNMENT;
}

template<typename T>
static void getDriverProperties(T *properties)
{
	properties->driverID = VK_DRIVER_ID_GOOGLE_SWIFTSHADER_KHR;
	strcpy(properties->driverName, ""SwiftShader driver"");
	strcpy(properties->driverInfo, """");
	properties->conformanceVersion = { 1, 1, 3, 3 };
}

void PhysicalDevice::getProperties(VkPhysicalDeviceDriverPropertiesKHR *properties) const
{
	getDriverProperties(properties);
}

void PhysicalDevice::getProperties(VkPhysicalDeviceLineRasterizationPropertiesEXT *properties) const
{
	properties->lineSubPixelPrecisionBits = vk::SUBPIXEL_PRECISION_BITS;
}

void PhysicalDevice::getProperties(VkPhysicalDeviceProvokingVertexPropertiesEXT *properties) const
{
	properties->provokingVertexModePerPipeline = VK_TRUE;
}

template<typename T>
static void getFloatControlsProperties(T *properties)
{
	// The spec states:
	// shaderSignedZeroInfNanPreserveFloat32 is a boolean value indicating whether
	// sign of a zero, Nans and ±∞ can be preserved in 32-bit floating-point
	// computations. It also indicates whether the SignedZeroInfNanPreserve execution
	// mode can be used for 32-bit floating-point types.
	//
	// There are similar clauses for all the shader* bools present here.
	//
	// It does not state that an implementation must report its default behavior using
	// these variables. At this time SwiftShader does not expose any preserve, denormal,
	// or rounding controls.
	properties->denormBehaviorIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE;
	properties->roundingModeIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_NONE;
	properties->shaderSignedZeroInfNanPreserveFloat16 = VK_FALSE;
	properties->shaderSignedZeroInfNanPreserveFloat32 = VK_FALSE;
	properties->shaderSignedZeroInfNanPreserveFloat64 = VK_FALSE;
	properties->shaderDenormPreserveFloat16 = VK_FALSE;
	properties->shaderDenormPreserveFloat32 = VK_FALSE;
	properties->shaderDenormPreserveFloat64 = VK_FALSE;
	properties->shaderDenormFlushToZeroFloat16 = VK_FALSE;
	properties->shaderDenormFlushToZeroFloat32 = VK_FALSE;
	properties->shaderDenormFlushToZeroFloat64 = VK_FALSE;
	properties->shaderRoundingModeRTZFloat16 = VK_FALSE;
	properties->shaderRoundingModeRTZFloat32 = VK_FALSE;
	properties->shaderRoundingModeRTZFloat64 = VK_FALSE;
	properties->shaderRoundingModeRTEFloat16 = VK_FALSE;
	properties->shaderRoundingModeRTEFloat32 = VK_FALSE;
	properties->shaderRoundingModeRTEFloat64 = VK_FALSE;
}

void PhysicalDevice::getProperties(VkPhysicalDeviceFloatControlsProperties *properties) const
{
	getFloatControlsProperties(properties);
}

template<typename T>
static void getDescriptorIndexingProperties(T *properties)
{
	properties->maxUpdateAfterBindDescriptorsInAllPools = 0;
	properties->shaderUniformBufferArrayNonUniformIndexingNative = VK_FALSE;
	properties->shaderSampledImageArrayNonUniformIndexingNative = VK_FALSE;
	properties->shaderStorageBufferArrayNonUniformIndexingNative = VK_FALSE;
	properties->shaderStorageImageArrayNonUniformIndexingNative = VK_FALSE;
	properties->shaderInputAttachmentArrayNonUniformIndexingNative = VK_FALSE;
	properties->robustBufferAccessUpdateAfterBind = VK_FALSE;
	properties->quadDivergentImplicitLod = VK_FALSE;
	properties->maxPerStageDescriptorUpdateAfterBindSamplers = 0;
	properties->maxPerStageDescriptorUpdateAfterBindUniformBuffers = 0;
	properties->maxPerStageDescriptorUpdateAfterBindStorageBuffers = 0;
	properties->maxPerStageDescriptorUpdateAfterBindSampledImages = 0;
	properties->maxPerStageDescriptorUpdateAfterBindStorageImages = 0;
	properties->maxPerStageDescriptorUpdateAfterBindInputAttachments = 0;
	properties->maxPerStageUpdateAfterBindResources = 0;
	properties->maxDescriptorSetUpdateAfterBindSamplers = 0;
	properties->maxDescriptorSetUpdateAfterBindUniformBuffers = 0;
	properties->maxDescriptorSetUpdateAfterBindUniformBuffersDynamic = 0;
	properties->maxDescriptorSetUpdateAfterBindStorageBuffers = 0;
	properties->maxDescriptorSetUpdateAfterBindStorageBuffersDynamic = 0;
	properties->maxDescriptorSetUpdateAfterBindSampledImages = 0;
	properties->maxDescriptorSetUpdateAfterBindStorageImages = 0;
	properties->maxDescriptorSetUpdateAfterBindInputAttachments = 0;
}

void PhysicalDevice::getProperties(VkPhysicalDeviceDescriptorIndexingProperties *properties) const
{
	getDescriptorIndexingProperties(properties);
}

template<typename T>
static void getDepthStencilResolveProperties(T *properties)
{
	properties->supportedDepthResolveModes = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT | VK_RESOLVE_MODE_NONE;
	properties->supportedStencilResolveModes = VK_RESOLVE_MODE_SAMPLE_ZERO_BIT | VK_RESOLVE_MODE_NONE;
	properties->independentResolveNone = VK_TRUE;
	properties->independentResolve = VK_TRUE;
}

void PhysicalDevice::getProperties(VkPhysicalDeviceDepthStencilResolveProperties *properties) const
{
	getDepthStencilResolveProperties(properties);
}

template<typename T>
static void getSamplerFilterMinmaxProperties(T *properties)
{
	properties->filterMinmaxSingleComponentFormats = VK_FALSE;
	properties->filterMinmaxImageComponentMapping = VK_FALSE;
}

void PhysicalDevice::getProperties(VkPhysicalDeviceSamplerFilterMinmaxProperties *properties) const
{
	getSamplerFilterMinmaxProperties(properties);
}

template<typename T>
static void getTimelineSemaphoreProperties(T *properties)
{
	// Our implementation of Timeline Semaphores allows the timeline to advance to any value from any value.
	properties->maxTimelineSemaphoreValueDifference = (uint64_t)-1;
}

void PhysicalDevice::getProperties(VkPhysicalDeviceTimelineSemaphoreProperties *properties) const
{
	getTimelineSemaphoreProperties(properties);
}

void PhysicalDevice::getProperties(VkPhysicalDeviceVulkan12Properties *properties) const
{
	getDriverProperties(properties);
	getFloatControlsProperties(properties);
	getDescriptorIndexingProperties(properties);
	getDepthStencilResolveProperties(properties);
	getSamplerFilterMinmaxProperties(properties);
	getTimelineSemaphoreProperties(properties);
	properties->framebufferIntegerColorSampleCounts = VK_SAMPLE_COUNT_1_BIT;
}

bool PhysicalDevice::hasFeatures(const VkPhysicalDeviceFeatures &requestedFeatures) const
{
	const VkPhysicalDeviceFeatures &supportedFeatures = getFeatures();
	const VkBool32 *supportedFeature = reinterpret_cast<const VkBool32 *>(&supportedFeatures);
	const VkBool32 *requestedFeature = reinterpret_cast<const VkBool32 *>(&requestedFeatures);
	constexpr auto featureCount = sizeof(VkPhysicalDeviceFeatures) / sizeof(VkBool32);

	for(unsigned int i = 0; i < featureCount; i++)
	{
		if((requestedFeature[i] != VK_FALSE) && (supportedFeature[i] == VK_FALSE))
		{
			return false;
		}
	}

	return true;
}

void PhysicalDevice::GetFormatProperties(Format format, VkFormatProperties *pFormatProperties)
{
	pFormatProperties->linearTilingFeatures = 0;   // Unsupported format
	pFormatProperties->optimalTilingFeatures = 0;  // Unsupported format
	pFormatProperties->bufferFeatures = 0;         // Unsupported format

	switch(format)
	{
	// Formats which can be sampled *and* filtered
	case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
	case VK_FORMAT_R5G6B5_UNORM_PACK16:
	case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
	case VK_FORMAT_R8_UNORM:
	case VK_FORMAT_R8_SRGB:
	case VK_FORMAT_R8_SNORM:
	case VK_FORMAT_R8G8_UNORM:
	case VK_FORMAT_R8G8_SRGB:
	case VK_FORMAT_R8G8_SNORM:
	case VK_FORMAT_R8G8B8A8_UNORM:
	case VK_FORMAT_R8G8B8A8_SNORM:
	case VK_FORMAT_R8G8B8A8_SRGB:
	case VK_FORMAT_B8G8R8A8_UNORM:
	case VK_FORMAT_B8G8R8A8_SRGB:
	case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
	case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
	case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
	case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
	case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
	case VK_FORMAT_R16_UNORM:
	case VK_FORMAT_R16_SNORM:
	case VK_FORMAT_R16_SFLOAT:
	case VK_FORMAT_R16G16_UNORM:
	case VK_FORMAT_R16G16_SNORM:
	case VK_FORMAT_R16G16_SFLOAT:
	case VK_FORMAT_R16G16B16A16_UNORM:
	case VK_FORMAT_R16G16B16A16_SNORM:
	case VK_FORMAT_R16G16B16A16_SFLOAT:
	case VK_FORMAT_R32_SFLOAT:
	case VK_FORMAT_R32G32_SFLOAT:
	case VK_FORMAT_R32G32B32A32_SFLOAT:
	case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
	case VK_FORMAT_E5B9G9R9_UFLOAT_PACK32:
	case VK_FORMAT_BC1_RGB_UNORM_BLOCK:
	case VK_FORMAT_BC1_RGB_SRGB_BLOCK:
	case VK_FORMAT_BC1_RGBA_UNORM_BLOCK:
	case VK_FORMAT_BC1_RGBA_SRGB_BLOCK:
	case VK_FORMAT_BC2_UNORM_BLOCK:
	case VK_FORMAT_BC2_SRGB_BLOCK:
	case VK_FORMAT_BC3_UNORM_BLOCK:
	case VK_FORMAT_BC3_SRGB_BLOCK:
	case VK_FORMAT_BC4_UNORM_BLOCK:
	case VK_FORMAT_BC4_SNORM_BLOCK:
	case VK_FORMAT_BC5_UNORM_BLOCK:
	case VK_FORMAT_BC5_SNORM_BLOCK:
	case VK_FORMAT_BC6H_UFLOAT_BLOCK:
	case VK_FORMAT_BC6H_SFLOAT_BLOCK:
	case VK_FORMAT_BC7_UNORM_BLOCK:
	case VK_FORMAT_BC7_SRGB_BLOCK:
	case VK_FORMAT_ETC2_R8G8B8_UNORM_BLOCK:
	case VK_FORMAT_ETC2_R8G8B8_SRGB_BLOCK:
	case VK_FORMAT_ETC2_R8G8B8A1_UNORM_BLOCK:
	case VK_FORMAT_ETC2_R8G8B8A1_SRGB_BLOCK:
	case VK_FORMAT_ETC2_R8G8B8A8_UNORM_BLOCK:
	case VK_FORMAT_ETC2_R8G8B8A8_SRGB_BLOCK:
	case VK_FORMAT_EAC_R11_UNORM_BLOCK:
	case VK_FORMAT_EAC_R11_SNORM_BLOCK:
	case VK_FORMAT_EAC_R11G11_UNORM_BLOCK:
	case VK_FORMAT_EAC_R11G11_SNORM_BLOCK:
#ifdef SWIFTSHADER_ENABLE_ASTC
	case VK_FORMAT_ASTC_4x4_UNORM_BLOCK:
	case VK_FORMAT_ASTC_5x4_UNORM_BLOCK:
	case VK_FORMAT_ASTC_5x5_UNORM_BLOCK:
	case VK_FORMAT_ASTC_6x5_UNORM_BLOCK:
	case VK_FORMAT_ASTC_6x6_UNORM_BLOCK:
	case VK_FORMAT_ASTC_8x5_UNORM_BLOCK:
	case VK_FORMAT_ASTC_8x6_UNORM_BLOCK:
	case VK_FORMAT_ASTC_8x8_UNORM_BLOCK:
	case VK_FORMAT_ASTC_10x5_UNORM_BLOCK:
	case VK_FORMAT_ASTC_10x6_UNORM_BLOCK:
	case VK_FORMAT_ASTC_10x8_UNORM_BLOCK:
	case VK_FORMAT_ASTC_10x10_UNORM_BLOCK:
	case VK_FORMAT_ASTC_12x10_UNORM_BLOCK:
	case VK_FORMAT_ASTC_12x12_UNORM_BLOCK:
	case VK_FORMAT_ASTC_4x4_SRGB_BLOCK:
	case VK_FORMAT_ASTC_5x4_SRGB_BLOCK:
	case VK_FORMAT_ASTC_5x5_SRGB_BLOCK:
	case VK_FORMAT_ASTC_6x5_SRGB_BLOCK:
	case VK_FORMAT_ASTC_6x6_SRGB_BLOCK:
	case VK_FORMAT_ASTC_8x5_SRGB_BLOCK:
	case VK_FORMAT_ASTC_8x6_SRGB_BLOCK:
	case VK_FORMAT_ASTC_8x8_SRGB_BLOCK:
	case VK_FORMAT_ASTC_10x5_SRGB_BLOCK:
	case VK_FORMAT_ASTC_10x6_SRGB_BLOCK:
	case VK_FORMAT_ASTC_10x8_SRGB_BLOCK:
	case VK_FORMAT_ASTC_10x10_SRGB_BLOCK:
	case VK_FORMAT_ASTC_12x10_SRGB_BLOCK:
	case VK_FORMAT_ASTC_12x12_SRGB_BLOCK:
#endif
	case VK_FORMAT_D16_UNORM:
	case VK_FORMAT_D32_SFLOAT:
	case VK_FORMAT_D32_SFLOAT_S8_UINT:
		pFormatProperties->optimalTilingFeatures |=
		    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
		// [[fallthrough]]

	// Formats which can be sampled, but don't support filtering
	case VK_FORMAT_R8_UINT:
	case VK_FORMAT_R8_SINT:
	case VK_FORMAT_R8G8_UINT:
	case VK_FORMAT_R8G8_SINT:
	case VK_FORMAT_R8G8B8A8_UINT:
	case VK_FORMAT_R8G8B8A8_SINT:
	case VK_FORMAT_A8B8G8R8_UINT_PACK32:
	case VK_FORMAT_A8B8G8R8_SINT_PACK32:
	case VK_FORMAT_A2B10G10R10_UINT_PACK32:
	case VK_FORMAT_A2R10G10B10_UINT_PACK32:
	case VK_FORMAT_R16_UINT:
	case VK_FORMAT_R16_SINT:
	case VK_FORMAT_R16G16_UINT:
	case VK_FORMAT_R16G16_SINT:
	case VK_FORMAT_R16G16B16A16_UINT:
	case VK_FORMAT_R16G16B16A16_SINT:
	case VK_FORMAT_R32_UINT:
	case VK_FORMAT_R32_SINT:
	case VK_FORMAT_R32G32_UINT:
	case VK_FORMAT_R32G32_SINT:
	case VK_FORMAT_R32G32B32A32_UINT:
	case VK_FORMAT_R32G32B32A32_SINT:
	case VK_FORMAT_S8_UINT:
		pFormatProperties->optimalTilingFeatures |=
		    VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
		    VK_FORMAT_FEATURE_BLIT_SRC_BIT |
		    VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
		    VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
		break;

	// YCbCr formats:
	case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
	case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
		pFormatProperties->optimalTilingFeatures |=
		    VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT |
		    VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT |
		    VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
		    VK_FORMAT_FEATURE_TRANSFER_DST_BIT |
		    VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT;
		break;
	default:
		break;
	}

	switch(format)
	{
	case VK_FORMAT_R32_UINT:
	case VK_FORMAT_R32_SINT:
		pFormatProperties->optimalTilingFeatures |=
		    VK_FORMAT_FEATURE_STORAGE_IMAGE_ATOMIC_BIT;
		pFormatProperties->bufferFeatures |=
		    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_ATOMIC_BIT;
		// [[fallthrough]]
	case VK_FORMAT_R8G8B8A8_UNORM:
	case VK_FORMAT_R8G8B8A8_SNORM:
	case VK_FORMAT_R8G8B8A8_UINT:
	case VK_FORMAT_R8G8B8A8_SINT:
	case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
	case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
	case VK_FORMAT_A8B8G8R8_UINT_PACK32:
	case VK_FORMAT_A8B8G8R8_SINT_PACK32:
	case VK_FORMAT_R16G16B16A16_UINT:
	case VK_FORMAT_R16G16B16A16_SINT:
	case VK_FORMAT_R16G16B16A16_SFLOAT:
	case VK_FORMAT_R32_SFLOAT:
	case VK_FORMAT_R32G32_UINT:
	case VK_FORMAT_R32G32_SINT:
	case VK_FORMAT_R32G32_SFLOAT:
	case VK_FORMAT_R32G32B32A32_UINT:
	case VK_FORMAT_R32G32B32A32_SINT:
	case VK_FORMAT_R32G32B32A32_SFLOAT:
	// shaderStorageImageExtendedFormats
	case VK_FORMAT_R16G16_SFLOAT:
	case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
	case VK_FORMAT_R16_SFLOAT:
	case VK_FORMAT_R16G16B16A16_UNORM:
	case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
	case VK_FORMAT_R16G16_UNORM:
	case VK_FORMAT_R8G8_UNORM:
	case VK_FORMAT_R16_UNORM:
	case VK_FORMAT_R8_UNORM:
	case VK_FORMAT_R16G16B16A16_SNORM:
	case VK_FORMAT_R16G16_SNORM:
	case VK_FORMAT_R8G8_SNORM:
	case VK_FORMAT_R16_SNORM:
	case VK_FORMAT_R8_SNORM:
	case VK_FORMAT_R16G16_SINT:
	case VK_FORMAT_R8G8_SINT:
	case VK_FORMAT_R16_SINT:
	case VK_FORMAT_R8_SINT:
	case VK_FORMAT_A2B10G10R10_UINT_PACK32:
	case VK_FORMAT_R16G16_UINT:
	case VK_FORMAT_R8G8_UINT:
	case VK_FORMAT_R16_UINT:
	case VK_FORMAT_R8_UINT:
		pFormatProperties->optimalTilingFeatures |=
		    VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT;
		// [[fallthrough]]
		pFormatProperties->bufferFeatures |=
		    VK_FORMAT_FEATURE_STORAGE_TEXEL_BUFFER_BIT;
		break;
	default:
		break;
	}

	switch(format)
	{
	case VK_FORMAT_R5G6B5_UNORM_PACK16:
	case VK_FORMAT_A1R5G5B5_UNORM_PACK16:
	case VK_FORMAT_R8_UNORM:
	case VK_FORMAT_R8G8_UNORM:
	case VK_FORMAT_R8G8B8A8_UNORM:
	case VK_FORMAT_R8G8B8A8_SRGB:
	case VK_FORMAT_B8G8R8A8_UNORM:
	case VK_FORMAT_B8G8R8A8_SRGB:
	case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
	case VK_FORMAT_A8B8G8R8_SRGB_PACK32:
	case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
	case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
	case VK_FORMAT_R16_SFLOAT:
	case VK_FORMAT_R16G16_SFLOAT:
	case VK_FORMAT_R16G16B16A16_SFLOAT:
	case VK_FORMAT_R32_SFLOAT:
	case VK_FORMAT_R32G32_SFLOAT:
	case VK_FORMAT_R32G32B32A32_SFLOAT:
	case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
	case VK_FORMAT_R8_UINT:
	case VK_FORMAT_R8_SINT:
	case VK_FORMAT_R8G8_UINT:
	case VK_FORMAT_R8G8_SINT:
	case VK_FORMAT_R8G8B8A8_UINT:
	case VK_FORMAT_R8G8B8A8_SINT:
	case VK_FORMAT_A8B8G8R8_UINT_PACK32:
	case VK_FORMAT_A8B8G8R8_SINT_PACK32:
	case VK_FORMAT_A2B10G10R10_UINT_PACK32:
	case VK_FORMAT_A2R10G10B10_UINT_PACK32:
	case VK_FORMAT_R16_UINT:
	case VK_FORMAT_R16_SINT:
	case VK_FORMAT_R16G16_UINT:
	case VK_FORMAT_R16G16_SINT:
	case VK_FORMAT_R16G16B16A16_UINT:
	case VK_FORMAT_R16G16B16A16_SINT:
	case VK_FORMAT_R32_UINT:
	case VK_FORMAT_R32_SINT:
	case VK_FORMAT_R32G32_UINT:
	case VK_FORMAT_R32G32_SINT:
	case VK_FORMAT_R32G32B32A32_UINT:
	case VK_FORMAT_R32G32B32A32_SINT:
		pFormatProperties->optimalTilingFeatures |=
		    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT |
		    VK_FORMAT_FEATURE_BLIT_DST_BIT;
		break;
	case VK_FORMAT_S8_UINT:
	case VK_FORMAT_D16_UNORM:
	case VK_FORMAT_D32_SFLOAT:          // Note: either VK_FORMAT_D32_SFLOAT or VK_FORMAT_X8_D24_UNORM_PACK32 must be supported
	case VK_FORMAT_D32_SFLOAT_S8_UINT:  // Note: either VK_FORMAT_D24_UNORM_S8_UINT or VK_FORMAT_D32_SFLOAT_S8_UINT must be supported
		pFormatProperties->optimalTilingFeatures |=
		    VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT;
		break;
	default:
		break;
	}

	if(format.supportsColorAttachmentBlend())
	{
		pFormatProperties->optimalTilingFeatures |=
		    VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BLEND_BIT;
	}

	switch(format)
	{
	case VK_FORMAT_R8_UNORM:
	case VK_FORMAT_R8_SNORM:
	case VK_FORMAT_R8_UINT:
	case VK_FORMAT_R8_SINT:
	case VK_FORMAT_R8G8_UNORM:
	case VK_FORMAT_R8G8_SNORM:
	case VK_FORMAT_R8G8_UINT:
	case VK_FORMAT_R8G8_SINT:
	case VK_FORMAT_R8G8B8A8_UNORM:
	case VK_FORMAT_R8G8B8A8_SNORM:
	case VK_FORMAT_R8G8B8A8_UINT:
	case VK_FORMAT_R8G8B8A8_SINT:
	case VK_FORMAT_B8G8R8A8_UNORM:
	case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
	case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
	case VK_FORMAT_A8B8G8R8_UINT_PACK32:
	case VK_FORMAT_A8B8G8R8_SINT_PACK32:
	case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
	case VK_FORMAT_A2R10G10B10_SNORM_PACK32:
	case VK_FORMAT_A2R10G10B10_UINT_PACK32:
	case VK_FORMAT_A2R10G10B10_SINT_PACK32:
	case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
	case VK_FORMAT_A2B10G10R10_SNORM_PACK32:
	case VK_FORMAT_A2B10G10R10_UINT_PACK32:
	case VK_FORMAT_A2B10G10R10_SINT_PACK32:
	case VK_FORMAT_R16_UNORM:
	case VK_FORMAT_R16_SNORM:
	case VK_FORMAT_R16_UINT:
	case VK_FORMAT_R16_SINT:
	case VK_FORMAT_R16_SFLOAT:
	case VK_FORMAT_R16G16_UNORM:
	case VK_FORMAT_R16G16_SNORM:
	case VK_FORMAT_R16G16_UINT:
	case VK_FORMAT_R16G16_SINT:
	case VK_FORMAT_R16G16_SFLOAT:
	case VK_FORMAT_R16G16B16A16_UNORM:
	case VK_FORMAT_R16G16B16A16_SNORM:
	case VK_FORMAT_R16G16B16A16_UINT:
	case VK_FORMAT_R16G16B16A16_SINT:
	case VK_FORMAT_R16G16B16A16_SFLOAT:
	case VK_FORMAT_R32_UINT:
	case VK_FORMAT_R32_SINT:
	case VK_FORMAT_R32_SFLOAT:
	case VK_FORMAT_R32G32_UINT:
	case VK_FORMAT_R32G32_SINT:
	case VK_FORMAT_R32G32_SFLOAT:
	case VK_FORMAT_R32G32B32_UINT:
	case VK_FORMAT_R32G32B32_SINT:
	case VK_FORMAT_R32G32B32_SFLOAT:
	case VK_FORMAT_R32G32B32A32_UINT:
	case VK_FORMAT_R32G32B32A32_SINT:
	case VK_FORMAT_R32G32B32A32_SFLOAT:
		pFormatProperties->bufferFeatures |=
		    VK_FORMAT_FEATURE_VERTEX_BUFFER_BIT;
		break;
	default:
		break;
	}

	switch(format)
	{
	// Vulkan 1.1 mandatory
	case VK_FORMAT_R8_UNORM:
	case VK_FORMAT_R8_SNORM:
	case VK_FORMAT_R8_UINT:
	case VK_FORMAT_R8_SINT:
	case VK_FORMAT_R8G8_UNORM:
	case VK_FORMAT_R8G8_SNORM:
	case VK_FORMAT_R8G8_UINT:
	case VK_FORMAT_R8G8_SINT:
	case VK_FORMAT_R8G8B8A8_UNORM:
	case VK_FORMAT_R8G8B8A8_SNORM:
	case VK_FORMAT_R8G8B8A8_UINT:
	case VK_FORMAT_R8G8B8A8_SINT:
	case VK_FORMAT_B8G8R8A8_UNORM:
	case VK_FORMAT_A8B8G8R8_UNORM_PACK32:
	case VK_FORMAT_A8B8G8R8_SNORM_PACK32:
	case VK_FORMAT_A8B8G8R8_UINT_PACK32:
	case VK_FORMAT_A8B8G8R8_SINT_PACK32:
	case VK_FORMAT_A2B10G10R10_UNORM_PACK32:
	case VK_FORMAT_A2B10G10R10_UINT_PACK32:
	case VK_FORMAT_R16_UINT:
	case VK_FORMAT_R16_SINT:
	case VK_FORMAT_R16_SFLOAT:
	case VK_FORMAT_R16G16_UINT:
	case VK_FORMAT_R16G16_SINT:
	case VK_FORMAT_R16G16_SFLOAT:
	case VK_FORMAT_R16G16B16A16_UINT:
	case VK_FORMAT_R16G16B16A16_SINT:
	case VK_FORMAT_R16G16B16A16_SFLOAT:
	case VK_FORMAT_R32_UINT:
	case VK_FORMAT_R32_SINT:
	case VK_FORMAT_R32_SFLOAT:
	case VK_FORMAT_R32G32_UINT:
	case VK_FORMAT_R32G32_SINT:
	case VK_FORMAT_R32G32_SFLOAT:
	case VK_FORMAT_R32G32B32A32_UINT:
	case VK_FORMAT_R32G32B32A32_SINT:
	case VK_FORMAT_R32G32B32A32_SFLOAT:
	case VK_FORMAT_B10G11R11_UFLOAT_PACK32:
	// Optional
	case VK_FORMAT_A2R10G10B10_UNORM_PACK32:
	case VK_FORMAT_A2R10G10B10_UINT_PACK32:
		pFormatProperties->bufferFeatures |=
		    VK_FORMAT_FEATURE_UNIFORM_TEXEL_BUFFER_BIT;
		break;
	default:
		break;
	}

	if(pFormatProperties->optimalTilingFeatures)
	{
		pFormatProperties->linearTilingFeatures = VK_FORMAT_FEATURE_TRANSFER_SRC_BIT |
		                                          VK_FORMAT_FEATURE_TRANSFER_DST_BIT;

		if(!format.isCompressed())
		{
			if(pFormatProperties->optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)
			{
				pFormatProperties->linearTilingFeatures |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
			}
			if(pFormatProperties->optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT)
			{
				pFormatProperties->linearTilingFeatures |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
			}
		}
	}
}

void PhysicalDevice::getImageFormatProperties(Format format, VkImageType type, VkImageTiling tiling,
                                              VkImageUsageFlags usage, VkImageCreateFlags flags,
                                              VkImageFormatProperties *pImageFormatProperties) const
{
	pImageFormatProperties->sampleCounts = VK_SAMPLE_COUNT_1_BIT;
	pImageFormatProperties->maxArrayLayers = vk::MAX_IMAGE_ARRAY_LAYERS;
	pImageFormatProperties->maxExtent.depth = 1;

	switch(type)
	{
	case VK_IMAGE_TYPE_1D:
		pImageFormatProperties->maxMipLevels = vk::MAX_IMAGE_LEVELS_1D;
		pImageFormatProperties->maxExtent.width = 1 << (vk::MAX_IMAGE_LEVELS_1D - 1);
		pImageFormatProperties->maxExtent.height = 1;
		break;
	case VK_IMAGE_TYPE_2D:
		if(flags & VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT)
		{
			pImageFormatProperties->maxMipLevels = vk::MAX_IMAGE_LEVELS_CUBE;
			pImageFormatProperties->maxExtent.width = 1 << (vk::MAX_IMAGE_LEVELS_CUBE - 1);
			pImageFormatProperties->maxExtent.height = 1 << (vk::MAX_IMAGE_LEVELS_CUBE - 1);
		}
		else
		{
			pImageFormatProperties->maxMipLevels = vk::MAX_IMAGE_LEVELS_2D;
			pImageFormatProperties->maxExtent.width = 1 << (vk::MAX_IMAGE_LEVELS_2D - 1);
			pImageFormatProperties->maxExtent.height = 1 << (vk::MAX_IMAGE_LEVELS_2D - 1);

			VkFormatProperties props;
			GetFormatProperties(format, &props);
			auto features = tiling == VK_IMAGE_TILING_LINEAR ? props.linearTilingFeatures : props.optimalTilingFeatures;
			if(features & (VK_FORMAT_FEATURE_COLOR_ATTACHMENT_BIT | VK_FORMAT_FEATURE_DEPTH_STENCIL_ATTACHMENT_BIT))
			{
				// Only renderable formats make sense for multisample
				pImageFormatProperties->sampleCounts = getSampleCounts();
			}
		}
		break;
	case VK_IMAGE_TYPE_3D:
		pImageFormatProperties->maxMipLevels = vk::MAX_IMAGE_LEVELS_3D;
		pImageFormatProperties->maxExtent.width = 1 << (vk::MAX_IMAGE_LEVELS_3D - 1);
		pImageFormatProperties->maxExtent.height = 1 << (vk::MAX_IMAGE_LEVELS_3D - 1);
		pImageFormatProperties->maxExtent.depth = 1 << (vk::MAX_IMAGE_LEVELS_3D - 1);
		pImageFormatProperties->maxArrayLayers = 1;  // no 3D + layers
		break;
	default:
		UNREACHABLE(""VkImageType: %d"", int(type));
		break;
	}

	pImageFormatProperties->maxResourceSize = 1u << 31;  // Minimum value for maxResourceSize

	// ""Images created with tiling equal to VK_IMAGE_TILING_LINEAR have further restrictions on their limits and capabilities
	//  compared to images created with tiling equal to VK_IMAGE_TILING_OPTIMAL.""
	if(tiling == VK_IMAGE_TILING_LINEAR)
	{
		pImageFormatProperties->maxMipLevels = 1;
		pImageFormatProperties->maxArrayLayers = 1;
		pImageFormatProperties->sampleCounts = VK_SAMPLE_COUNT_1_BIT;
	}

	// ""Images created with a format from one of those listed in Formats requiring sampler Y'CbCr conversion for VK_IMAGE_ASPECT_COLOR_BIT image views
	//  have further restrictions on their limits and capabilities compared to images created with other formats.""
	if(format.isYcbcrFormat())
	{
		pImageFormatProperties->maxMipLevels = 1;  // TODO(b/151263485): This is relied on by the sampler to disable mipmapping for Y'CbCr image sampling.
		pImageFormatProperties->maxArrayLayers = 1;
		pImageFormatProperties->sampleCounts = VK_SAMPLE_COUNT_1_BIT;
	}
}

uint32_t PhysicalDevice::getQueueFamilyPropertyCount() const
{
	return 1;
}

VkQueueFamilyProperties PhysicalDevice::getQueueFamilyProperties() const
{
	VkQueueFamilyProperties properties = {};
	properties.minImageTransferGranularity.width = 1;
	properties.minImageTransferGranularity.height = 1;
	properties.minImageTransferGranularity.depth = 1;
	properties.queueCount = 1;
	properties.queueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT;
	properties.timestampValidBits = 64;

	return properties;
}

void PhysicalDevice::getQueueFamilyProperties(uint32_t pQueueFamilyPropertyCount,
                                              VkQueueFamilyProperties *pQueueFamilyProperties) const
{
	for(uint32_t i = 0; i < pQueueFamilyPropertyCount; i++)
	{
		pQueueFamilyProperties[i] = getQueueFamilyProperties();
	}
}

void PhysicalDevice::getQueueFamilyProperties(uint32_t pQueueFamilyPropertyCount,
                                              VkQueueFamilyProperties2 *pQueueFamilyProperties) const
{
	for(uint32_t i = 0; i < pQueueFamilyPropertyCount; i++)
	{
		pQueueFamilyProperties[i].queueFamilyProperties = getQueueFamilyProperties();
	}
}

const VkPhysicalDeviceMemoryProperties &PhysicalDevice::GetMemoryProperties()
{
	static const VkPhysicalDeviceMemoryProperties properties{
		1,  // memoryTypeCount
		{
		    // vk::MEMORY_TYPE_GENERIC_BIT
		    {
		        (VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT |
		         VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
		         VK_MEMORY_PROPERTY_HOST_COHERENT_BIT |
		         VK_MEMORY_PROPERTY_HOST_CACHED_BIT),  // propertyFlags
		        0                                      // heapIndex
		    },
		},
		1,  // memoryHeapCount
		{
		    {
		        1ull << 31,                      // size, FIXME(sugoi): This should be configurable based on available RAM
		        VK_MEMORY_HEAP_DEVICE_LOCAL_BIT  // flags
		    },
		}
	};

	return properties;
}

}  // namespace vk
",16163,True,2641.6039885829455,median
"---
title: Бүлэг 24. Локалчлал - I18N/L10N-ийн хэрэглээ болон тохируулга
part: хэсэг III. Системийн Удирдлага
prev: books/handbook/virtualization
next: books/handbook/cutting-edge
showBookMenu: true
weight: 28
path: ""/books/handbook/""
---

[[l10n]]
= Локалчлал - I18N/L10N-ийн хэрэглээ болон тохируулга
:doctype: book
:toc: macro
:toclevels: 1
:icons: font
:sectnums:
:sectnumlevels: 6
:sectnumoffset: 24
:partnums:
:source-highlighter: rouge
:experimental:
:images-path: books/handbook/l10n/

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::[]

[[l10n-synopsis]]
== Ерөнхий агуулга

FreeBSD нь дэлхий даяар байрласан хэрэглэгчид болон хувь нэмэр болгон оруулагчидтай маш тархмал төсөл юм. Энэ бүлэг Англиар ярьдаггүй хэрэглэгчдэд жинхэнэ ажлаа хийх боломж олгох FreeBSD-ийн интернационалчлал болон локалчлалын боломжуудыг хэлэлцэх болно. Систем болон програмын түвшингүүдийн аль алинд нь i18n шийдлийн олон үзэл бодлууд байдаг бөгөөд бид шаардлагатай тохиолдолд илүү тусгайлсан баримтын эхүүдийг хэрэглэгчдэд зааж өгөх болно.

Энэ бүлгийг уншсаны дараа, та дараах зүйлсийг мэдэх болно:

* Орчин үеийн үйлдлийн системүүд дээр хэлнүүд болон локалууд (locales) нь хэрхэн кодчилогддог талаар.
* Өөрийн нэвтрэх бүрхүүлийн хувьд локалыг хэрхэн тохируулах талаар.
* Англи биш хэлнүүдийн хувьд өөрийн консолыг хэрхэн тохируулах талаар.
* X Цонхны Системийг өөр хэлнүүдтэй хэрхэн үр дүнтэйгээр ашиглах талаар.
* i18n-нийцтэй програмуудыг бичих талаар илүү мэдээллийг хаанаас олох талаар.

Энэ бүлгийг уншихаасаа өмнө, та дараах зүйлсийг мэдэх шаардлагатай:

* Нэмэлт гуравдагч этгээдийн програмуудыг (crossref:ports[ports,Програм суулгах. Багцууд болон портууд]) хэрхэн суулгах талаар.

[[l10n-basics]]
== Үндсүүд

=== I18N/L10N гэж юу вэ?

Хөгжүүлэгчид интернационалчлалыг I18N гэж internationalization гэсэн үгийн эхний болон эцсийн үсгийн хоорондох үсгийн тоог оруулан богиносгосон юм. L10N нь бас адил журмаар ""localization""-с улбаалан нэрлэгдсэн юм. Хоёулаа нэгдсэн I18N/L10N аргууд, протоколууд болон програмууд нь хэрэглэгчдэд өөрсдийнх нь сонгосон хэлнүүдийг ашиглах боломжийг олгодог.

I18N програмууд нь сангуудын доорх I18N хэрэгслүүдийг ашиглан програмчлагдсан байдаг. Энэ нь энгийн файлыг бичих болон харуулагдсан цэснүүд, текстүүдийг хэл бүр уруу орчуулах боломжийг хөгжүүлэгчдэд олгоно. Бид энэ дадлыг мөрдөхийг програм зохиогчдоос шаргуу хүсдэг.

=== I18N/L10N-ийг би яагаад ашиглах ёстой гэж?

I18N/L10N нь Англи хэлнээс өөр хэл дээр өгөгдлийг харах, оруулах, эсвэл боловсруулахыг таныг хүсэх үед хэрэглэгддэг.

=== I18N чармайлтад ямар хэлнүүд дэмжигдсэн байдаг вэ?

I18N болон L10N нь зөвхөн FreeBSD зориулагдаагүй. Одоогоор хэрэглэгч дэлхийн гол гол хэлнүүдийн ихэнхийг сонгож болох бөгөөд гэхдээ энэ нь энд байгаа жагсаалтаар хязгаарлагдахгүй: Хятад, Герман, Япон, Солонгос, Франц, Орос, Вьетнам болон бусад хэлнүүдийг дурдаж болно.

[[using-localization]]
== Локалчлалыг ашиглах нь

Өөрийн бүх сүр жавхлангаараа I18N нь зөвхөн FreeBSD-д зориулагдаагүй бөгөөд энэ нь ёс заншил болсон байдаг. Энэ ёс заншлыг дагаж FreeBSD-д туслахыг бид танаас хүсдэг.

Локалчлалын тохируулгууд нь гурван гол ойлголт дээр тулгуурладаг: Хэлний код, Улсын код ба Кодчилол. Локалын нэрс эдгээр хэсгүүдээс дараах маягаар бүрэлдэн тогтоно:

[.programlisting]
....
LanguageCode_CountryCode.Encoding
....

=== Хэл болон Улсын кодууд

FreeBSD системийг тухайн хэл уруу (эсвэл I18N дэмждэг бусад UNIX(R) төст системүүд дээр) локалчлахын тулд хэрэглэгч тухайн улс болон хэлийг (улсын код нь програмд өгөгдсөн хэлний аль хувилбарыг ашиглахыг хэлж өгдөг) заах кодуудыг олж мэдэх хэрэгтэй. Мөн вэб хөтчүүд, SMTP/POP серверүүд зэрэг нь тэдгээр дээр тулгуурлан шийдэл гаргадаг. Дараах нь хэл/улсын кодны жишээнүүд юм:

[.informaltable]
[cols=""1,1"", frame=""none"", options=""header""]
|===
| Хэл/Улсын код
| Тайлбар

|en_US
|English буюу Англи - Нэгдсэн Улс

|ru_RU
|Орос улсад зориулсан Russian буюу Орос

|zh_TW
|Тайваньд зориулсан Уламжлалт Хятад хэл
|===

Байгаа локалчлалын жагсаалтыг дараах тушаалаар авч болно:

[source,shell]
....
% locale -a
....

=== Кодчилолууд

Зарим хэлнүүд 8-бит, өргөн эсвэл олон байт тэмдэгтүүд зэрэг ASCII биш кодчилолыг ашигладаг. Олон байт тэмдэгтүүдийн талаар илүү дэлгэрэнгүйг man:multibyte[3]-ээс үзнэ үү. Хуучин програмууд тэдгээрийг танидаггүй бөгөөд тэдгээрийг хянах тэмдэгтүүд гэж алддаг. Шинэ програмууд ихэвчлэн 8-бит тэмдэгтүүдийг танидаг. Шийдлээс хамаараад хэрэглэгчид програмыг өргөн эсвэл олон байт тэмдэгтийн дэмжлэгтэйгээр эмхэтгэх эсвэл зөвөөр тохируулах шаардлагатай байж болох юм. Өргөн эсвэл олон тэмдэгтүүдийг оруулж процесс хийж чадахын тулд link:https://www.FreeBSD.org/ports/[FreeBSD портын цуглуулга] хэл бүрийг өөр өөр програмуудтайгаар хангадаг. FreeBSD порт дахь харгалзах I18N баримтжуулалтаас лавлана уу.

Ялангуяа програмыг хэрхэн зөв тохируулах эсвэл зөв утгуудыг configure/Makefile/эмхэтгэгчид дамжуулахыг шийдэхдээ програмын баримтжуулалтаас харах хэрэгтэй болно.

Санаж байх ёстой зарим нэг зүйлүүд нь:

* Тухайн хэлний ганц C chars тэмдэгтийн олонлогууд (man:multibyte[3]-г үзнэ үү), өөрөөр хэлбэл ISO8859-1, ISO8859-15, KOI8-R, CP437.
* Өргөн эсвэл олон байт кодчилол, өөрөөр хэлбэл EUC, Big5.

Та тэмдэгтийн олонлогуудын идэвхтэй жагсаалтыг http://www.iana.org/assignments/character-sets[IANA Registry]-с шалгаж болно.

[NOTE]
====
FreeBSD нь X11-нийцтэй локалын кодчилолуудыг харин ашигладаг.
====

=== I18N програмууд

FreeBSD-ийн портууд болон багцын системд I18N програмууд нь амархан танигдахын тулд нэрэндээ `I18N`-тайгаар нэрлэгддэг. Гэхдээ тэдгээр нь хэрэгтэй хэлийг үргэлж дэмжсэн байдаггүй.

[[setting-locale]]
=== Локалыг тохируулах

Нэвтрэх бүрхүүл дээр локалын нэрний утгыг `LANG` уруу экспорт хийхэд ихэвчлэн хангалттай байдаг. Үүнийг хэрэглэгчийн [.filename]#~/.login_conf# файл эсвэл хэрэглэгчийн бүрхүүлийн эхлүүлэх файлд ([.filename]#~/.profile#, [.filename]#~/.bashrc#, [.filename]#~/.cshrc#) зааж өгч болно. `LC_CTYPE`, `LC_CTIME` зэрэг локал дэд олонлогуудыг тохируулах хэрэггүй. Дэлгэрэнгүй мэдээллийн талаар тухайн хэлний FreeBSD-ийн баримтаас лавлана уу.

Та өөрийн тохиргооны файлууддаа дараах хоёр орчны хувьсагчийг тохируулах хэрэгтэй:

* POSIX(R) man:setlocale[3] төрлийн функцуудад зориулсан `LANG`
* Програмуудын MIME тэмдэгтийн олонлогт зориулсан `MM_CHARSET`

Энэ нь хэрэглэгчийн бүрхүүлийн тохиргоо, тухайн програмын тохиргоо болон X11-ийн тохиргоог агуулдаг.

==== Локал аргуудыг тохируулах

Локалыг тохируулах хоёр арга байдаг бөгөөд хоёуланг доор тайлбарласан байгаа. Эхнийхийг (бидний зөвлөж байгааг) <<login-class,нэвтрэх ангилал>>д орчны хувьсагчуудыг зааж хоёр дахийг системийн бүрхүүлийн <<startup-file,эхлүүлэх файл>>д орчны хувьсагчийн заалтуудыг нэмснээр хийдэг.

[[login-class]]
===== Нэвтрэх ангилалуудын арга

Энэ арга нь бүрхүүл бүрийн эхлүүлэх файлд тухайн бүрхүүлийн заалтуудыг нэмэхийн оронд локалын нэр болон MIME тэмдэгтийн олонлогуудад хэрэгтэй орчны хувьсагчуудыг боломжит бүрхүүл бүрийн хувьд нэг л удаа заах боломжийг олгодог. <<usr-setup,Хэрэглэгчийн түвшний тохируулгыг>> хэрэглэгч өөрөө хийж болох бөгөөд <<adm-setup,Администраторын түвшний тохируулга>> нь супер хэрэглэгчийн зөвшөөрлүүдийг шаарддаг.

[[usr-setup]]
====== Хэрэглэгчийн түвшний тохируулга

Энд хэрэглэгчийн гэр сан дотор байрлах Latin-1 кодчилолын хувьд хоёр хувьсагчийг нь тохируулж өгсөн [.filename]#.login_conf# файлын хамгийн бага жишээ байна:

[.programlisting]
....
me:\\
	:charset=ISO-8859-1:\\
	:lang=de_DE.ISO8859-1:
....

Энд BIG-5 кодчилолд Уламжлалт Хятад хэлд зориулан хувьсагчуудыг тохируулж байгаа [.filename]#.login_conf# файлын жишээ байна. Зарим програм хангамжууд нь Хятад, Япон болон Солонгос хэлний хувьд локалын хувьсагчуудыг зөвөөр хүндэлдэггүй учраас илүү олон хувьсагчуудыг тохируулсныг эндээс харж болно.

[.programlisting]
....
#Users who do not wish to use monetary units or time formats
#of Taiwan can manually change each variable
me:\\
	:lang=zh_TW.Big5:\\
	:setenv=LC_ALL=zh_TW.Big5:\\
	:setenv=LC_COLLATE=zh_TW.Big5:\\
	:setenv=LC_CTYPE=zh_TW.Big5:\\
	:setenv=LC_MESSAGES=zh_TW.Big5:\\
	:setenv=LC_MONETARY=zh_TW.Big5:\\
	:setenv=LC_NUMERIC=zh_TW.Big5:\\
	:setenv=LC_TIME=zh_TW.Big5:\\
	:charset=big5:\\
	:xmodifiers=""@im=gcin"": #Set gcin as the XIM Input Server
....

Илүү дэлгэрэнгүйг <<adm-setup,Администраторын түвшний тохируулга>> болон man:login.conf[5]-с үзнэ үү.

[[adm-setup]]
===== Администраторын түвшний тохируулга

[.filename]#/etc/login.conf# дахь хэрэглэгчийн нэвтрэх ангилал зөв хэл тохируулсныг шалгана. Эдгээр тохируулгууд [.filename]#/etc/login.conf#-д байгаа эсэхийг шалгаарай:

[.programlisting]
....
language_name:Account Type Description:\\
	:charset=MIME_charset:\\
	:lang=locale_name:\\
	:tc=default:
....

Бидний урдны жишээний адил Latin-1-г сонговол энэ нь иймэрхүү харагдана:

[.programlisting]
....
german|German Users Accounts:\\
	:charset=ISO-8859-1:\\
	:lang=de_DE.ISO8859-1:\\
	:tc=default:
....

Хэрэглэгчийн нэвтрэх ангиллуудыг өөрчлөхөөсөө өмнө дараах тушаалыг ажиллуулж

[source,shell]
....
# cap_mkdb /etc/login.conf
....

шинэ тохиргоог системд харагдуулахаар [.filename]#/etc/login.conf#-д хийнэ.

===== Нэвтрэх ангиллуудыг man:vipw[8] ашиглан солих

Шинэ хэрэглэгчид нэмэхийн тулд `vipw` тушаал ашиглан оруулгыг иймэрхүү болгоно:

[.programlisting]
....
user:password:1111:11:language:0:0:User Name:/home/user:/bin/sh
....

===== Нэвтрэх ангиллуудыг man:adduser[8] ашиглан солих

Шинэ хэрэглэгчид нэмэхийн тулд `adduser` тушаал ашиглан доор дурдсаныг хийнэ:

* [.filename]#/etc/adduser.conf# файлд `defaultclass = language`-г тохируулна. Та энэ тохиолдолд бусад хэлнүүдийн бүх хэрэглэгчдэд зориулан `анхдагч` ангилалыг оруулах хэрэгтэйг санах хэрэгтэй.
* man:adduser[8]-с гарч ирэх асуулт бүрт 
+
[source,shell]
....
Enter login class: default []: 
....
+
асуултад тухайн хэлийг зааж өгөх бас нэг хувилбар байж болно.

* Өөр нэг арга нь нэмэхээр хүсэж байгаа өөр хэлний хэрэглэгч бүрийн хувьд доор дурдсаныг ашиглах явдал юм:
+
[source,shell]
....
# adduser -class language
....

===== Нэвтрэх ангиллуудыг man:pw[8] ашиглан солих

Хэрэв та man:pw[8]-г шинэ хэрэглэгч нэмэхийн тулд ашиглаж байгаа бол үүнийг иймэрхүү маягаар дуудаарай:

[source,shell]
....
# pw useradd user_name -L language
....

[[startup-file]]
===== Бүрхүүлийн эхлүүлэх файл арга

[NOTE]
====
Энэ аргыг зөвлөдөггүй, учир нь сонгосон боломжит бүрхүүл програм бүрийн хувьд өөр тохируулгыг шаарддаг. Оронд нь <<login-class,Нэвтрэх ангиллын аргыг>> ашиглаарай.
====

Локалын нэр болон MIME тэмдэгтийн олонлогийг нэмэхийн тулд доор үзүүлсэн хоёр орчны хувьсагчийг [.filename]#/etc/profile#-д болон/эсвэл бүрхүүлийн эхлүүлэх файл [.filename]#/etc/csh.login#-д зааж өгнө. Бид Герман хэлийг доор жишээ болгон ашиглах болно:

[.filename]#/etc/profile# файлд:

[.programlisting]
....
LANG=de_DE.ISO8859-1; export LANG
MM_CHARSET=ISO-8859-1; export MM_CHARSET
....

Эсвэл [.filename]#/etc/csh.login# файлд:

[.programlisting]
....
setenv LANG de_DE.ISO8859-1
setenv MM_CHARSET ISO-8859-1
....

Өөрөөр та дээрх заавруудыг [.filename]#/usr/shared/skel/dot.profile# файлд (дээрх [.filename]#/etc/profile#-д ашигласантай адил) эсвэл [.filename]#/usr/shared/skel/dot.login# файлд (дээрх [.filename]#/etc/csh.login#-д ашигласантай адил) нэмж болно.

X11-ийн хувьд:

[.filename]#$HOME/.xinitrc# файлд:

[.programlisting]
....
LANG=de_DE.ISO8859-1; export LANG
....

Эсвэл:

[.programlisting]
....
setenv LANG de_DE.ISO8859-1
....

Таны бүрхүүлээс хамаараад (дээр дурдсаныг үзнэ үү).

[[setting-console]]
=== Консол тохируулах

Бүх ганц C chars тэмдэгтийн олонлогуудын хувьд зөв консолын фонтуудыг [.filename]#/etc/rc.conf#-д асуултанд байгаа хэлний хувьд тохируулна:

[.programlisting]
....
font8x16=font_name
font8x14=font_name
font8x8=font_name
....

Эндэх _font_name_-ийг [.filename]#/usr/shared/syscons/fonts# сангаас [.filename]#.fnt# төгсгөлгүйгээр авсан.

Хэрэв шаардлагатай бол keymap болон screenmap-ийг өөрийн ганц C chars тэмдэгтийн олонлогийн хувьд `sysinstall` ашиглан зааж өгнө. sysinstall дотор байхдаа [.guimenuitem]#Configure#-г сонгоод дараа нь [.guimenuitem]#Console#-г сонгоно. Өөрөөр та доор дурдсаныг [.filename]#/etc/rc.conf#-д нэмж болно:

[.programlisting]
....
scrnmap=screenmap_name
keymap=keymap_name
keychange=""fkey_number sequence""
....

Эндэх _screenmap_name_-ийг [.filename]#/usr/shared/syscons/scrnmaps# сангаас [.filename]#.scm# төгсгөлгүйгээр авсан. Зохих оноогдсон фонттой screenmap нь псевдографик талбарт VGA адаптерийн фонтын тэмдэгтийн матриц дээр бит 8-ийг бит 9 уруу өргөтгөхөд ихэвчлэн тойрон гарах арга зам болгон хэрэглэгддэг, өөрөөр хэлбэл хэрэв дэлгэцийн фонт бит 8 багана ашиглаж байвал тэр талбараас үсэгнүүдийг шилжүүлэн гаргахын тулд хэрэглэгддэг.

Хэрэв та [.filename]#/etc/rc.conf#-д moused дэмонг идэвхжүүлэхийг дараах байдлаар тохируулсан бол:

[.programlisting]
....
moused_enable=""YES""
....

хулганы заагчийн мэдээллийг дараагийн хэсгээс шалгаарай.

Анхдагчаар man:syscons[4] драйверийн хулганы заагч нь тэмдэгтийн олонлогийн 0xd0-0xd3 хэсгийг эзэлдэг. Хэрэв таны хэл энэ хэсгийг ашигладаг бол заагчийн хэсгийг үүнээс гадна шилжүүлэх хэрэгтэй. FreeBSD-ийн хувьд тойрон гарах арга замыг идэвхжүүлэхийн тулд дараах мөрийг [.filename]#/etc/rc.conf#-д нэмнэ:

[.programlisting]
....
mousechar_start=3
....

Эндэх _keymap_name_-ийг [.filename]#/usr/shared/syscons/keymaps# сангаас [.filename]#.kbd# төгсгөлгүй авсан. Хэрэв та аль keymap-ийг ашиглах эсэхдээ эргэлзэж байвал man:kbdmap[1]-г ашиглаж дахин ачаалалгүйгээр keymap-уудыг тест хийж болно.

`keychange` нь функцын товчлууруудыг сонгосон терминалын төрөлтэй тааруулахын тулд програмчлахад ихэвчлэн хэрэгтэй байдаг, учир нь функцын товчлуурын дарааллуудыг товчлууруудын оноолтод тодорхойлж болдоггүй.

Бас консолын терминалын зөв төрлийг бүх `ttyv*` оруулгуудын хувьд [.filename]#/etc/ttys# файлд тохируулсан эсэхээ шалгаарай. Одоогийн урьдчилан тодорхойлсон зохицлууд нь:

[.informaltable]
[cols=""1,1"", frame=""none"", options=""header""]
|===
| Тэмдэгтийн Олонлог
| Терминалын Төрөл

|ISO8859-1 эсвэл ISO8859-15
|`cons25l1`

|ISO8859-2
|`cons25l2`

|ISO8859-7
|`cons25l7`

|KOI8-R
|`cons25r`

|KOI8-U
|`cons25u`

|CP437 (VGA default)
|`cons25`

|US-ASCII
|`cons25w`
|===

Өргөн эсвэл олон байт тэмдэгтүүд бүхий хэлнүүдийн хувьд өөрийн [.filename]#/usr/ports/language# сангаас зөв FreeBSD портоо ашиглаарай. Зарим портууд консол маягаар байхад түүнийг систем сериал vtty-үүд шигээр хардаг, ийм учраас та X11 болон псевдо-сериал консолын хувьд хангалттай vtty-үүдийг хадгалж байх шаардлагатай. Өөр хэлүүдийг консолд ашиглахын тулд энд програмуудын хэсэгчилсэн жагсаалт байна:

[.informaltable]
[cols=""1,1"", frame=""none"", options=""header""]
|===
| Хэл
| Байрлал

|Уламжлалт Хятад хэл (BIG-5)
|package:chinese/big5con[]

|Япон хэл
|package:japanese/kon2-16dot[] эсвэл package:japanese/mule-freewnn[]

|Солонгос хэл
|package:korean/han[]
|===

=== X11 тохируулах

X11 нь FreeBSD Төслийн нэг хэсэг биш боловч бид энд FreeBSD хэрэглэгчдэд зориулж зарим мэдээлэл орууллаа. Илүү дэлгэрэнгүйг http://www.x.org/[Xorg вэб хаягаас] эсвэл аль X11 сервер ашиглаж байгаа түүнийхээ вэб хаягаас лавлана уу.

[.filename]#~/.Xresources# файлд та програмуудад зориулсан I18N тохируулгуудыг (өөрөөр хэлбэл фонтууд, цэснүүд, гэх мэт.) тааруулж өгч болно.

==== Фонтуудыг үзүүлэх

Xorg сервер (package:x11-servers/xorg-server[]) суулгаад дараа нь хэлний TrueType(R) фонтуудыг суулгана. Зөв локалыг тохируулах нь танд цэснүүдийг сонгосон хэлээрээ харах зэрэг боломжийг олгоно.

==== Англи биш тэмдэгтүүдийг оруулах нь

X11 оруулах арга (XIM) нь бүх X11 клиентүүдэд зориулсан шинэ стандарт юм. Бүх X11 програмууд нь XIM оруулах серверүүдээс оролт авдаг XIM клиентүүд маягаар бичигдэх ёстой. Өөр өөр хэлнүүдэд зориулагдсан хэд хэдэн XIM серверүүд байдаг.

=== Хэвлэгч тохируулах

Зарим ганц C chars тэмдэгтийн олонлогууд нь ихэвчлэн хэвлэгчүүд дотор хатуугаар бичигдсэн байдаг. Өргөн эсвэл олон байт тэмдэгтийн олонлогууд нь тусгай тохируулга шаарддаг бөгөөд бид apsfilter програмыг хэрэглэхийг зөвлөдөг. Та бас PostScript(R) эсвэл PDF хэлбэрүүд уруу тухайн хэлний хөрвүүлэгчдийг ашиглан баримтыг хөрвүүлж болох юм.

=== Цөм ба файлын системүүд

FreeBSD-ийн хурдан файлын систем (FFS) нь 8-бит цэвэр учир үүнийг ямар ч ганц C chars тэмдэгтийн олонлогтой цуг ашиглаж болно (man:multibyte[3]-г үзнэ үү), гэхдээ тэмдэгтийн олонлогийн нэр файлын системд хадгалагддаггүй; өөрөөр хэлбэл энэ нь түүхий 8-бит бөгөөд кодчилолын дарааллын талаар юу ч мэддэггүй. Албан ёсоор FFS нь өргөн эсвэл олон байт тэмдэгтийн олонлогуудын аль ч хэлбэрийг дэмждэггүй. Гэхдээ зарим өргөн эсвэл олон байт тэмдэгтийн олонлогууд нь FFS-д ийм дэмжлэгийг идэвхжүүлэхэд зориулсан бие биеэсээ ангид засваруудтай байдаг. Тэдгээр нь цорын ганц ийш тийш хөрвүүлэх боломжгүй шийдлүүд буюу hack бөгөөд бид тэдгээрийг эх модонд оруулахгүй гэж шийдэцгээсэн юм. Тохирох хэлнүүдийн вэб хуудаснуудаас илүү дэлгэрэнгүй мэдээлэл болон засвар файлуудын талаар лавлана уу.

FreeBSD MS-DOS(R) файлын систем нь MS-DOS(R), Юникод тэмдэгтийн олонлогууд болон FreeBSD-ийн сонгосон файлын системийн тэмдэгтийн олонлогуудын хооронд хөрвүүлэх тохируулж болох боломж бүхий байдаг. Дэлгэрэнгүйг man:mount_msdosfs[8]-с үзнэ үү.

[[l10n-compiling]]
== I18N програмуудыг эмхэтгэх

FreeBSD-ийн олон портууд I18N дэмжлэгтэйгээр хөрвүүлэгдсэн байдаг. Тэдгээрийн зарим нь портын нэрэндээ -I18N гэж тэмдэглэгдсэн байдаг. Эдгээр болон бусад олон програмууд I18N-д зориулагдсан дэмжлэгтэйгээр бүтээгдсэн байдаг бөгөөд тусгай хэлэлцүүлэг шаардлагагүй юм.

Гэхдээ MySQL зэрэг зарим програмууд тусгайлсан charset бүхий байхаар тохируулагдсан [.filename]#Makefile# файлтай байх шаардлагатай. Үүнийг ихэвчлэн [.filename]#Makefile#-д эсвэл эхэд байх configure програмд утга дамжуулан хийдэг.

[[lang-setup]]
== FreeBSD-г өөр хэлнүүд уруу локалчлах

[[ru-localize]]
=== Орос хэл (KOI8-R Кодчилол)

KOI8-R кодчилолын талаар дэлгэрэнгүй мэдээллийг http://koi8.pp.ru/[KOI8-R Лавлахууд (Russian Net Character Set)]-с үзнэ үү.

==== Локал Тохируулах

Дараах мөрүүдийг өөрийн [.filename]#~/.login_conf# файлд нэмнэ:

[.programlisting]
....
me:My Account:\\
	:charset=KOI8-R:\\
	:lang=ru_RU.KOI8-R:
....

Энэ бүлгийн өмнөхөөс <<setting-locale,локал>> тохируулах жишээнүүдийг үзнэ үү.

==== Консол Тохируулга

* Дараах мөрийг өөрийн [.filename]#/etc/rc.conf# файлд нэмнэ:
+
[.programlisting]
....
mousechar_start=3
....

* Мөн дараах тохируулгуудыг [.filename]#/etc/rc.conf#-д ашиглана:
+
[.programlisting]
....
keymap=""ru.utf-8""
scrnmap=""utf-82cp866""
font8x16=""cp866b-8x16""
font8x14=""cp866-8x14""
font8x8=""cp866-8x8""
....

* [.filename]#/etc/ttys# файл дахь `ttyv*` оруулга болгоны хувьд `cons25r`-ийг терминалын төрөлд ашиглана.

Энэ бүлгийн өмнөхөөс <<setting-console,консол>> тохируулах жишээнүүдийг үзнэ үү.

==== Хэвлэгчийн Тохируулга

Орос тэмдэгтүүдтэй ихэнх хэвлэгчид CP866 гэсэн тоног төхөөрөмжийн код хуудастай ирдэг бөгөөд KOI8-R-с CP866 уруу хөрвүүлэхийн тулд тусгай гаралтын шүүгч хэрэгтэй болдог. Ийм шүүгч анхдагчаар [.filename]#/usr/libexec/lpr/ru/koi2alt# гэж суугддаг. Орос хэвлэгчийн [.filename]#/etc/printcap# оруулга иймэрхүү харагдах ёстой:

[.programlisting]
....
lp|Russian local line printer:\\
	:sh:of=/usr/libexec/lpr/ru/koi2alt:\\
	:lp=/dev/lpt0:sd=/var/spool/output/lpd:lf=/var/log/lpd-errs:
....

Дэлгэрэнгүй тайлбарын талаар man:printcap[5]-с үзнэ үү.

==== MS-DOS(R) FS болон Орос файлын нэрс

Дараах жишээ man:fstab[5] оруулга нь холбогдсон MS-DOS(R) файлын системүүд дээр Орос файлын нэрийн дэмжлэгийг идэвхжүүлдэг:

[.programlisting]
....
/dev/ad0s2      /dos/c  msdos   rw,-Wkoi2dos,-Lru_RU.KOI8-R 0 0
....

`-L` тохируулга ашиглагдсан локалын нэрийг сонгодог бөгөөд `-W` нь тэмдэгтийн хөрвүүлэлтийн хүснэгтийг заадаг. `-W` тохируулгыг ашиглахын тулд [.filename]#/usr#-г MS-DOS(R) хуваалтаас өмнө холбох хэрэгтэй, учир нь хөрвүүлэлтийн хүснэгтүүд [.filename]#/usr/libdata/msdosfs#-д байрладаг. Дэлгэрэнгүй мэдээллийг man:mount_msdosfs[8] гарын авлагын хуудаснаас үзнэ үү.

==== X11 тохируулга

. Эхлээд <<setting-locale,X биш локалын тохируулгыг>> тайлбарласнаар хийнэ.
. Хэрэв та Xorg-г ашиглаж байгаа бол package:x11-fonts/xorg-fonts-cyrillic[] багцыг суулгана.
+ 
Өөрийн [.filename]#/etc/X11/xorg.conf# файлын `""Files""` хэсгийг шалгаарай. Дараах мөр аль ч `FontPath` оруулгуудаас _өмнө_ нэмэгдсэн байх шаардлагатай:
+
[.programlisting]
....
FontPath   ""/usr/local/lib/X11/fonts/cyrillic""
....
+
[NOTE]
====
Өөр илүү олон кирилл фонтуудыг авахыг хүсвэл портуудаас үзнэ үү.
====

. Орос гарыг идэвхжүүлэхийн тулд өөрийн [.filename]#xorg.conf# файлын `""Keyboard""` хэсэгт доор дурдсаныг нэмээрэй:
+
[.programlisting]
....
Option ""XkbLayout""   ""us,ru""
Option ""XkbOptions""  ""grp:toggle""
....
+ 
Мөн `XkbDisable`-г хаасан (тайлбар болгосон) эсэхийг тэндээс шалгаарай.
+ 
`grp:toggle`-н хувьд RUS/LAT шилжүүлэгч kbd:[Right Alt] болох бөгөөд `grp:ctrl_shift_toggle` шилжүүлэгчийн хувьд kbd:[Ctrl+Shift] болно. `grp:caps_toggle`-н хувьд RUS/LAT шилжүүлэгч kbd:[CapsLock] байна. Хуучин kbd:[CapsLock] функцын хувьд kbd:[Shift+CapsLock] (зөвхөн LAT горимд) байсаар байна. `grp:caps_toggle` нь Xorg дээр тодорхойгүй шалтгааны улмаас ажилладаггүй.
+ 
Хэрэв та өөрийн гар дээрээ ""Windows(R)"" товчлууруудтай бол, зарим үсгэн товчлуурууд нь RUS горимд буруугаар тааруулагддагийг анзаарсан байх, өөрийн [.filename]#xorg.conf# файлдаа дараах мөрийг нэмээрэй:
+
[.programlisting]
....
Option ""XkbVariant"" "",winkeys""
....
+
[NOTE]
====
Орос XKB гар нь локалчлал хийгдээгүй програмуудтай ажиллахгүй байж болох юм.
====

[NOTE]
====
Хамгийн багаар локалчлагдсан програмууд `XtSetLanguageProc (NULL, NULL, NULL);` функцыг програмын эхэнд дуудах ёстой.

X11 програмуудыг локалчлах талаар дэлгэрэнгүй заавруудыг http://koi8.pp.ru/xwin.html[X Цонхны KOI8-R] хаягаас үзнэ үү.
====

=== Тайваньд зориулсан уламжлалт Хятад хэлний локалчлал

FreeBSD-Тайвань Төсөл олон Хятад портуудыг ашиглан FreeBSD-д зориулсан Хятад HOWTO-г http://netlab.cse.yzu.edu.tw/\\~statue/freebsd/zh-tut/[http://netlab.cse.yzu.edu.tw/~statue/freebsd/zh-tut/] дээр байрлуулсан байдаг. `FreeBSD Хятад HOWTO`-н одоогийн засварлагч нь Чуан-Шинг Шен mailto:statue@freebsd.sinica.edu.tw[statue@freebsd.sinica.edu.tw] юм. 

Чуан-Шинг Шен mailto:statue@freebsd.sinica.edu.tw[statue@freebsd.sinica.edu.tw] нь FreeBSD-Тайваний `zh-L10N-tut` ашиглан http://netlab.cse.yzu.edu.tw/\\~statue/cfc/[Хятад FreeBSD Цуглуулга (CFC)] үүсгэсэн байгаа. Багцууд болон скрипт файлууд link:ftp://freebsd.csie.nctu.edu.tw/pub/taiwan/CFC/[ftp://freebsd.csie.nctu.edu.tw/pub/taiwan/CFC/] дээр байгаа болно.

=== Герман хэлний локалчлал(бүх ISO 8859-1 хэлнүүдэд зориулсан)

Славен Резич mailto:eserte@cs.tu-berlin.de[eserte@cs.tu-berlin.de] нь FreeBSD машин дээр umlaut буюу Герман хэлний авиа өөрчлөгддөгийг тэмдэглэдэг хоёр цэгийг хэрхэн ашиглах талаар заавар бичсэн байгаа. Энэ заавар нь Герман хэл дээр бичигдсэн бөгөөд http://user.cs.tu-berlin.de/\\~eserte/FreeBSD/doc/umlaute/umlaute.html[http://user.cs.tu-berlin.de/~eserte/FreeBSD/doc/umlaute/umlaute.html] дээр байгаа болно.

=== Грек хэлний локалчлал

Никос Кокалис mailto:nickkokkalis@gmail.com[nickkokkalis@gmail.com] нь FreeBSD дээрх Грек хэлний дэмжлэгийн талаар бүрэн нийтлэл бичсэн байгаа. Энэ нь FreeBSD-ийн албан ёсны Грек баримтжуулалтын хэсэг болон https://www.FreeBSD.org/doc/el/articles/greek-language-support/[http://www.freebsd.org/doc/el/articles/greek-language-support/] хаягт орсон байдаг. Энэ нь _зөвхөн_ Грек хэл дээр юм.

=== Япон болон Солонгос хэлний локалчлал

Япон хэлний хувьд http://www.jp.FreeBSD.org/[http://www.jp.FreeBSD.org/]-д хандана уу, Солонгос хэлний хувьд http://www.kr.FreeBSD.org/[http://www.kr.FreeBSD.org/]-д хандана уу.

=== Англи биш FreeBSD баримтжуулалт

FreeBSD-ийн зарим хувь нэмэр оруулагчид FreeBSD-ийн баримтжуулалтын зарим хэсгийг орчуулсан байгаа. Тэдгээрийг link:https://www.FreeBSD.org/[эх сайт] дээрх холбоосуудаас эсвэл [.filename]#/usr/shared/doc# сангаас үзэж болох юм.
",12503,True,2638.2389749451577,median
"////
This guide is maintained in the main Quarkus repository
and pull requests should be submitted there:
https://github.com/quarkusio/quarkus/tree/main/docs/src/main/asciidoc
////
//= Simplified Hibernate ORM with Panache
= Hibernate ORM 和 Panache

include::./attributes.adoc[]
:config-file: application.properties

//Hibernate ORM is the de facto JPA implementation and offers you the full breadth of an Object Relational Mapper.
//It makes complex mappings possible, but it does not make simple and common mappings trivial.
//Hibernate ORM with Panache focuses on making your entities trivial and fun to write in Quarkus.
//
Hibernate ORM 是 JPA 的一种实现，它为您提供了对象关系映射。它使复杂的映射关系成为可能。带有 Panache 的 Hibernate ORM 专注于实体在 Quarkus 中的使用。



//== First: an example
== 首先一个简单的例子
//What we're doing in Panache is to allow you to write your Hibernate ORM entities like this:
在 Panache 中允许您这样编写 Hibernate ORM 实体：

[source,java]
----
public enum Status {
    Alive,
    Deceased
}

@Entity
public class Person extends PanacheEntity {
    public String name;
    public LocalDate birth;
    public Status status;

    public static Person findByName(String name){
        return find(""name"", name).firstResult();
    }

    public static List<Person> findAlive(){
        return list(""status"", Status.Alive);
    }

    public static void deleteStefs(){
        delete(""name"", ""Stef"");
    }
}
----

//You have noticed how much more compact and readable the code is?
//Does this look interesting? Read on!
您是否注意到代码更加紧凑和可读，这看起来有趣吗？请继续阅读。

//NOTE: the `list()` method might be surprising at first. It takes fragments of HQL (JP-QL) queries and contextualizes the rest. That makes for very concise but yet readable code.
NOTE: `list()` 方法起初可能有些令人惊讶，它采用 HQL(JP-QL) 查询片段作为参数将其他内容上下文化，这使得代码非常简洁，但不丢失可读性。

//NOTE: what was described above is essentially the link:https://www.martinfowler.com/eaaCatalog/activeRecord.html[active record pattern], sometimes just called the entity pattern.
//Hibernate with Panache also allows for the use of the more classical link:https://martinfowler.com/eaaCatalog/repository.html[repository pattern] via `PanacheRepository`.
NOTE: 上面描述的本质是 link:https://www.martinfowler.com/eaaCatalog/activeRecord.html[活动记录模式] ，有时也称之为实体模式。 Hibernate ORM 和 Panache 也允许  link:https://martinfowler.com/eaaCatalog/repository.html[仓库模式]


//== Solution
== 源码获取

//We recommend that you follow the instructions in the next sections and create the application step by step.
//However, you can go right to the completed example.
我们建议您按照本教程的说明一步一步完成应用程序的制作。但是，您可以直接跳转到完整实例。

//Clone the Git repository: `git clone {quickstarts-clone-url}`, or download an {quickstarts-archive-url}[archive].
克隆 git 仓库：`git clone {quickstarts-clone-url}` 或者下载  {quickstarts-archive-url}[源码].

//The solution is located in the `hibernate-orm-panache-quickstart` {quickstarts-tree-url}/hibernate-orm-panache-quickstart[directory].

本教程源码位于 {quickstarts-tree-url}/hibernate-orm-panache-quickstart[地址].


//== Setting up and configuring Hibernate ORM with Panache
== 配置 Hibernate ORM 和 Panache

//To get started:
执行顺序：

//* add your settings in `{config-file}`
* 将您的配置添加到 `{config-file}` 。
//* annotate your entities with `@Entity`
* 使用 `@Entity` 注解标记实体
//* make your entities extend `PanacheEntity` (optional if you are using the repository pattern)
* 让实体继承 `PanacheEntity` (可选项，如果您想要使用仓库模式)

//Follow the xref:hibernate-orm.adoc#setting-up-and-configuring-hibernate-orm[Hibernate set-up guide for all configuration].
按照 xref:hibernate-orm-CN.adoc#setting-up-and-configuring-hibernate-orm[Hibernate 配置教程]

//In your build file, add the following dependencies:
在您的项目中依赖项如下：

//* the Hibernate ORM with Panache extension
* Hibernate ORM 和 Panache 扩展
//* your JDBC driver extension (`quarkus-jdbc-postgresql`, `quarkus-jdbc-h2`, `quarkus-jdbc-mariadb`, ...)
* JDBC 驱动拓展 (`quarkus-jdbc-postgresql`, `quarkus-jdbc-h2`, `quarkus-jdbc-mariadb`, ...)

[source,xml,role=""primary asciidoc-tabs-target-sync-cli asciidoc-tabs-target-sync-maven""]
.pom.xml
----
<!-- Hibernate ORM specific dependencies -->
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-hibernate-orm-panache</artifactId>
</dependency>

<!-- JDBC driver dependencies -->
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-jdbc-postgresql</artifactId>
</dependency>
----

[source,gradle,role=""secondary asciidoc-tabs-target-sync-gradle""]
.build.gradle
----
// Hibernate ORM specific dependencies
implementation(""io.quarkus:quarkus-hibernate-orm-panache"")

// JDBC driver dependencies
implementation(""io.quarkus:quarkus-jdbc-postgresql"")
----

//Then add the relevant configuration properties in `{config-file}`.
然后在 `{config-file}` 文件中添加配置信息：

[source,properties]
----
# configure your datasource
quarkus.datasource.db-kind = postgresql
quarkus.datasource.username = sarah
quarkus.datasource.password = connor
quarkus.datasource.jdbc.url = jdbc:postgresql://localhost:5432/mydatabase

# drop and create the database at startup (use `update` to only update the schema)
quarkus.hibernate-orm.database.generation = drop-and-create
----

//== Solution 1: using the active record
== 方案1: 使用活动记录模式

//=== Defining your entity
=== 定义你的实体

//To define a Panache entity, simply extend `PanacheEntity`, annotate it with `@Entity` and add your
//columns as public fields:
首先需要定义 Panache 实体，这样的实体只需要继承 `PanacheEntity` , 使用注解 `@Entity` 标记并且添加属性字段。

[source,java]
----
@Entity
public class Person extends PanacheEntity {
    public String name;
    public LocalDate birth;
    public Status status;
}
----

//You can put all your JPA column annotations on the public fields. If you need a field to not be persisted, use the
//`@Transient` annotation on it. If you need to write accessors, you can:

您可以将所有 JPA 注解放在字段上。如果宁想要忽略某些字段可以使用 `@Transient` 注解

[source,java]
----
@Entity
public class Person extends PanacheEntity {
    public String name;
    public LocalDate birth;
    public Status status;

    // return name as uppercase in the model
    public String getName(){
        return name.toUpperCase();
    }

    // store all names in lowercase in the DB
    public void setName(String name){
        this.name = name.toLowerCase();
    }
}
----

//And thanks to our field access rewrite, when your users read `person.name` they will actually call your `getName()` accessor,
//and similarly for field writes and the setter.
//This allows for proper encapsulation at runtime as all fields calls will be replaced by the corresponding getter/setter calls.

由于我们对访问字段进行了自定义处理，当您的用户在获取 `person.name` 属性时会调用 `getName` ，对于数据字段的写入也进行了重写相关操作都会执行具体的set方法。在 Hibernate ORM 中允许您对 get/set 方法进行适当的封装。

//=== Most useful operations
=== 有用的操作

//Once you have written your entity, here are the most common operations you will be able to perform:
在编写实体后，您可以执行一下常见操作

[source,java]
----
// 创建 Person 对象
Person person = new Person();
person.name = ""Stef"";
person.birth = LocalDate.of(1910, Month.FEBRUARY, 1);
person.status = Status.Alive;

// 持久化
person.persist();

// 注意，一旦持久化，您无需显式保存实体：所有修改都会在事务提交时自动持久化。


// 检查是否持久化
if(person.isPersistent()){
    // 删除数据
    person.delete();
}

// 获取所有 Person
List<Person> allPersons = Person.listAll();

// 根据id查询 Person
person = Person.findById(personId);

// 进行可能存在的查询，在查询结果不存在时抛出异常
Optional<Person> optional = Person.findByIdOptional(personId);
person = optional.orElseThrow(() -> new NotFoundException());

// 查询 status 为 Status.Alive 的 Person
List<Person> livingPersons = Person.list(""status"", Status.Alive);

// 求 Person 数量
long countAll = Person.count();

// 统计 status 为 Status.Alive 的数量
long countAlive = Person.count(""status"", Status.Alive);

// 删除 status 为 Status.Alive 的数量
Person.delete(""status"", Status.Alive);

// 删除所有
Person.deleteAll();

// 根据 id 删除
boolean deleted = Person.deleteById(personId);

// 更新数据
Person.update(""name = 'Mortal' where status = ?1"", Status.Alive);

----

//All `list` methods have equivalent `stream` versions.
所有 `list` 方法都有等价的 `stream` 版本的方法

[source,java]
----
try (Stream<Person> persons = Person.streamAll()) {
    List<String> namesButEmmanuels = persons
        .map(p -> p.name.toLowerCase() )
        .filter( n -> ! ""emmanuel"".equals(n) )
        .collect(Collectors.toList());
}
----

//NOTE: The `stream` methods require a transaction to work. +
//As they perform I/O operations, they should be closed via the `close()` method or via a try-with-resource to close the underlying `ResultSet`.
//If not, you will see warnings from Agroal that will close the underlying `ResultSet` for you.
NOTE: 这些 `stream` 需要一个事务对象才能够工作。当它执行 I/O 操作时，他们应该通过 `close` 方法或者通过 try-with-resource 来关闭底层的 `ResultSet` 对象。如果没有，您将看到来自 Agroal 的经过，该警告将希望您关闭 `ResultSet` 对象。

//=== Adding entity methods
=== 添加实体方法

Add custom queries on your entities inside the entities themselves.
That way, you and your co-workers can find them easily, and queries are co-located with the object they operate on.
Adding them as static methods in your entity class is the Panache Active Record way.

在实体内部允许添加自定义方法完成自定义查询操作。这样，您和您的同时可以轻松找到他们，并且查询与操作对象位于同一个位置，将它们作为静态方法添加到实体类中这样的方式我们称之为 Panache Active Record。

[source,java]
----
@Entity
public class Person extends PanacheEntity {
    public String name;
    public LocalDate birth;
    public Status status;

    public static Person findByName(String name){
        return find(""name"", name).firstResult();
    }

    public static List<Person> findAlive(){
        return list(""status"", Status.Alive);
    }

    public static void deleteStefs(){
        delete(""name"", ""Stef"");
    }
}
----

//== Solution 2: using the repository pattern
== 方案2: 使用仓库模式


//=== Defining your entity'
=== 定义您的实体

//When using the repository pattern, you can define your entities as regular JPA entities.
使用仓库模式时，您可以将实体定义为常规的 JPA 实体。

[source,java]
----
@Entity
public class Person {
    @Id @GeneratedValue private Long id;
    private String name;
    private LocalDate birth;
    private Status status;

    public Long getId(){
        return id;
    }
    public void setId(Long id){
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public LocalDate getBirth() {
        return birth;
    }
    public void setBirth(LocalDate birth) {
        this.birth = birth;
    }
    public Status getStatus() {
        return status;
    }
    public void setStatus(Status status) {
        this.status = status;
    }
}
----

//TIP: If you don't want to bother defining getters/setters for your entities, you can make them extend `PanacheEntityBase` and
//Quarkus will generate them for you. You can even extend `PanacheEntity` and take advantage of the default ID it provides.
TIP: 如果您不想飞行的为实体定义 getters/setters 您可以继承 `PanacheEntityBase` ，Quarkus 将为您生成它们，您甚至可以继承 `PanacheEntity` 使用它来提供默认的ID。


//=== Defining your repository
=== 定义您的仓库

//When using Repositories, you get the exact same convenient methods as with the active record pattern, injected in your Repository,
//by making them implements `PanacheRepository`:

使用 Repositories 时，您可以获得与活动记录模式完全相同的便捷方法，通过实现 `PanacheRepository` 接口来获取方法

[source,java]
----
@ApplicationScoped
public class PersonRepository implements PanacheRepository<Person> {

   // put your custom logic here as instance methods

   public Person findByName(String name){
       return find(""name"", name).firstResult();
   }

   public List<Person> findAlive(){
       return list(""status"", Status.Alive);
   }

   public void deleteStefs(){
       delete(""name"", ""Stef"");
  }
}
----

//All the operations that are defined on `PanacheEntityBase` are available on your repository, so using it
//is exactly the same as using the active record pattern, except you need to inject it:

常规操作都在 `PanacheEntityBase` 类中有相关标记，因此使用它与活动记录模式相同，除了您需要注入它

[source,java]
----
@Inject
PersonRepository personRepository;

@GET
public long count(){
    return personRepository.count();
}
----

//=== Most useful operations
=== 有用的操作

//Once you have written your repository, here are the most common operations you will be able to perform:
编写完成仓库后，您可以执行一下常见操作：

[source,java]
----
// 创建 Person 对象
Person person = new Person();
person.setName(""Stef"");
person.setBirth(LocalDate.of(1910, Month.FEBRUARY, 1));
person.setStatus(Status.Alive);

// 持久化 Person 对象
personRepository.persist(person);

// 注意，一旦持久化，您无需显式保存实体：所有修改都会在事务提交时自动持久化。

// 检查是否持久化
if(personRepository.isPersistent(person)){
    // 删除数据
    personRepository.delete(person);
}

// 获取所有 Person
List<Person> allPersons = personRepository.listAll();

// 根据id查询 Person
person = personRepository.findById(personId);

// 进行可能存在的查询，在查询结果不存在时抛出异常
Optional<Person> optional = personRepository.findByIdOptional(personId);
person = optional.orElseThrow(() -> new NotFoundException());

// 查询 status 为 Status.Alive 的 Person
List<Person> livingPersons = personRepository.list(""status"", Status.Alive);

// 求 Person 数量
long countAll = personRepository.count();

// 统计 status 为 Status.Alive 的数量
long countAlive = personRepository.count(""status"", Status.Alive);

// 删除 status 为 Status.Alive 的数量
personRepository.delete(""status"", Status.Alive);

// 删除所有
personRepository.deleteAll();

// 根据 id 删除
boolean deleted = personRepository.deleteById(personId);

// 更新数据
personRepository.update(""name = 'Mortal' where status = ?1"", Status.Alive);

----

//All `list` methods have equivalent `stream` versions.
所有 `list` 方法都有等价的 `stream` 版本的方法

[source,java]
----
Stream<Person> persons = personRepository.streamAll();
List<String> namesButEmmanuels = persons
    .map(p -> p.name.toLowerCase() )
    .filter( n -> ! ""emmanuel"".equals(n) )
    .collect(Collectors.toList());
----

//NOTE: The `stream` methods require a transaction to work.
NOTE: 这些 `stream` 需要一个事务对象才能够工作。

//NOTE: The rest of the documentation show usages based on the active record pattern only,
//but keep in mind that they can be performed with the repository pattern as well.
//The repository pattern examples have been omitted for brevity.

NOTE: 文档的其他部分仅演示基于活动记录模式的用法，注意，他们也可以使用仓库模式执行。为了简洁期间，省略了仓库模式相关的代码。

//== Writing a JAX-RS resource
== 编写 JAX-RS 资源

//First, include one of the RESTEasy extensions to enable JAX-RS endpoints, for example, add the `io.quarkus:quarkus-resteasy-jackson` dependency for JAX-RS and JSON support.
首先，需要引入 RESTEasy 拓展以启动 JAX-RS 端点，例如，添加 `io.quarkus:quarkus-resteasy-jackson` 依赖项，该依赖项支持 JAX-RS 和 JSON 。

//Then, you can create the following resource to create/read/update/delete your Person entity:
然后，您可以创建资源对象，用于新增、读取、更新和删除 Person 实体：

[source,java]
----
@Path(""/persons"")
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
public class PersonResource {

    @GET
    public List<Person> list() {
        return Person.listAll();
    }

    @GET
    @Path(""/{id}"")
    public Person get(@PathParam(""id"") Long id) {
        return Person.findById(id);
    }

    @POST
    @Transactional
    public Response create(Person person) {
        person.persist();
        return Response.created(URI.create(""/persons/"" + person.id)).build();
    }

    @PUT
    @Path(""/{id}"")
    @Transactional
    public Person update(@PathParam(""id"") Long id, Person person) {
        Person entity = Person.findById(id);
        if(entity == null) {
            throw new NotFoundException();
        }

        // map all fields from the person parameter to the existing entity
        entity.name = person.name;

        return entity;
    }

    @DELETE
    @Path(""/{id}"")
    @Transactional
    public void delete(@PathParam(""id"") Long id) {
        Person entity = Person.findById(id);
        if(entity == null) {
            throw new NotFoundException();
        }
        entity.delete();
    }

    @GET
    @Path(""/search/{name}"")
    public Person search(@PathParam(""name"") String name) {
        return Person.findByName(name);
    }

    @GET
    @Path(""/count"")
    public Long count() {
        return Person.count();
    }
}
----

//NOTE: Be careful to use the `@Transactional` annotation on the operations that modify the database,
//you can add the annotation at the class level for simplicity purpose.

NOTE: 注意 `@Transactional` 需要在修改数据库操作上使用注解，为了简单期间，您可以在类级别添加该注解。

//== Advanced Query
== 高级查询

//=== Paging
=== 查询

//You should only use `list` and `stream` methods if your table contains small enough data sets. For larger data
//sets you can use the `find` method equivalents, which return a `PanacheQuery` on which you can do paging:
如果您的数据表数量足够小，您应该使用 `list` 和 `stream` 相关方法。 `stream` 对于较大数据集，您可以使用 `find` 等方法，它返回一个 `PanacheQuery` 对象，您可以在其纸上使用分页方法：

[source,java]
----
// 创建一个分页查询
PanacheQuery<Person> livingPersons = Person.find(""status"", Status.Alive);

// 分页数量为 25
livingPersons.page(Page.ofSize(25));

// 获取数量
List<Person> firstPage = livingPersons.list();

// 获取第二页
List<Person> secondPage = livingPersons.nextPage().list();

// 获取第7页
List<Person> page7 = livingPersons.page(Page.of(7, 25)).list();

// 获取总量
int numberOfPages = livingPersons.pageCount();

// 获取总量
long count = livingPersons.count();

// 链式调用
return Person.find(""status"", Status.Alive)
    .page(Page.ofSize(25))
    .nextPage()
    .stream()
----

//The `PanacheQuery` type has many other methods to deal with paging and returning streams.
`PanacheQuery` 类型有许多其他方法来处理分页和返回流。

//=== Using a range instead of pages
=== 使用范围查询

`PanacheQuery` also allows range-based queries.

`PanacheQuery` 允许基于范围查询

[source,java]
----
// 创建查询
PanacheQuery<Person> livingPersons = Person.find(""status"", Status.Alive);

// 让它使用一个范围：从索引 0 开始直到索引 24（包括）
livingPersons.range(0, 24);

// 获取范围内的数据
List<Person> firstRange = livingPersons.list();

// 要获得下一个范围，您需要再次调用范围
List<Person> secondRange = livingPersons.range(25, 49).list();
----

[WARNING]
====
//You cannot mix ranges and pages: if you use a range, all methods that depend on having a current page will throw an `UnsupportedOperationException`;
//you can switch back to paging using `page(Page)` or `page(int, int)`.

您不能够混合使用 range 和 page ，如果您使用了 range 并且依赖 page 会抛出 `UnsupportedOperationException` 异常，如果出现该异常建议切换回 page。
====

//=== Sorting
=== 排序

//All methods accepting a query string also accept the following simplified query form:
所有查询都接收以字符串的心声进行排序查询：

[source,java]
----
List<Person> persons = Person.list(""order by name,birth"");
----

//But these methods also accept an optional `Sort` parameter, which allows your to abstract your sorting:
这些方法也接受一个可选的 `Sort` 参数，它允许您抽象排序

[source,java]
----
List<Person> persons = Person.list(Sort.by(""name"").and(""birth""));

// and with more restrictions
List<Person> persons = Person.list(""status"", Sort.by(""name"").and(""birth""), Status.Alive);
----

//The `Sort` class has plenty of methods for adding columns and specifying sort direction.
`Sort` 有很多用于添加列或者指定排序方向的方法。

//=== Simplified queries
=== 简化查询

//Normally, HQL queries are of this form: `from EntityName [where ...] [order by ...]`, with optional elements
//at the end.
通常 HQL 查询采用以下形式编写：  `from EntityName [where ...] [order by ...]`

//If your select query does not start with `from`, we support the following additional forms:
如果您的查询不以 `from` 开头，我们将附加以下形式：


//- `order by ...` which will expand to `from EntityName order by ...`
- 在 `from EntityName order by ...` 后添加 `order by ...`
//- `<singleColumnName>` (and single parameter) which will expand to `from EntityName where <singleColumnName> = ?`
- 如果是单列查询会以：`from EntityName where <singleColumnName> = ?` 形式添加
//- `<query>` will expand to `from EntityName where <query>`
- 在`from EntityName where <query>` 中添加查询条件

//If your update query does not start with `update`, we support the following additional forms:
如果您的更新不以 `update` 开头，我们将附加以下形式：

//- `from EntityName ...` which will expand to `update from EntityName ...`
- 将 `from EntityName ...` 扩展为 `update from EntityName ...`
//- `set? <singleColumnName>` (and single parameter) which will expand to `update from EntityName set <singleColumnName> = ?`
- 如果是单列更新将会以 `update from EntityName set <singleColumnName> = ?` 形式添加
//- `set? <update-query>` will expand to `update from EntityName set <update-query>`
- 将 `set? <update-query>` 扩展为 `update from EntityName set <update-query>`

If your delete query does not start with `delete`, we support the following additional forms:

- `from EntityName ...` which will expand to `delete from EntityName ...`
- `<singleColumnName>` (and single parameter) which will expand to `delete from EntityName where <singleColumnName> = ?`
- `<query>` will expand to `delete from EntityName where <query>`

//NOTE: You can also write your queries in plain
//link:https://docs.jboss.org/hibernate/orm/5.4/userguide/html_single/Hibernate_User_Guide.html#hql[HQL]:
NOTE: 您还可以通过编写普通 link:https://docs.jboss.org/hibernate/orm/5.4/userguide/html_single/Hibernate_User_Guide.html#hql[HQL] 进行查询

[source,java]
----
Order.find(""select distinct o from Order o left join fetch o.lineItems"");
Order.update(""update from Person set name = 'Mortal' where status = ?"", Status.Alive);
----

//=== Named queries
=== 命名查询

//You can reference a named query instead of a (simplified) HQL query by prefixing its name with the '#' character. You can also use named queries for count, update and delete queries.
您可以通过再起名称前添加 `#` 符号来进行简化的命名查询，而不是简化 HQL 查询。您还可以将命名查询用在计数、更新和删除操作上

[source,java]
----
@Entity
@NamedQueries({
    @NamedQuery(name = ""Person.getByName"", query = ""from Person where name = ?1""),
    @NamedQuery(name = ""Person.countByStatus"", query = ""select count(*) from Person p where p.status = :status""),
    @NamedQuery(name = ""Person.updateStatusById"", query = ""update Person p set p.status = :status where p.id = :id""),
    @NamedQuery(name = ""Person.deleteById"", query = ""delete from Person p where p.id = ?1"")
})

public class Person extends PanacheEntity {
    public String name;
    public LocalDate birth;
    public Status status;

    public static Person findByName(String name){
        return find(""#Person.getByName"", name).firstResult();
    }

    public static long countByStatus(Status status) {
        return count(""#Person.countByStatus"", Parameters.with(""status"", status).map());
    }

    public static long updateStatusById(Status status, long id) {
        return update(""#Person.updateStatusById"", Parameters.with(""status"", status).and(""id"", id));
    }

    public static long deleteById(long id) {
        return delete(""#Person.deleteById"", id);
    }
}
----

[WARNING]
====
//Named queries can only be defined inside your JPA entity classes (being the Panache entity class, or the repository parameterized type),
//or on one of its super classes.
命名查询只能在您的 JPA 实体类（作为 Panache 实体类或者仓库模式的泛型类）内部或者其超类上定义。
====

//=== Query parameters
=== 参数查询

//You can pass query parameters by index (1-based) as shown below:
你可以按索引（从1开始）传递参数，如下所示

[source,java]
----
Person.find(""name = ?1 and status = ?2"", ""stef"", Status.Alive);
----

//Or by name using a `Map`:
或者按名称传递参数，这样需要使用 `Map` 结构，示例如下：

[source,java]
----
Map<String, Object> params = new HashMap<>();
params.put(""name"", ""stef"");
params.put(""status"", Status.Alive);
Person.find(""name = :name and status = :status"", params);
----

//Or using the convenience class `Parameters` either as is or to build a `Map`:
或者使用 `Parameters` 类来构建 `Map` 结构

[source,java]
----
// generate a Map
Person.find(""name = :name and status = :status"",
         Parameters.with(""name"", ""stef"").and(""status"", Status.Alive).map());

// use it as-is
Person.find(""name = :name and status = :status"",
         Parameters.with(""name"", ""stef"").and(""status"", Status.Alive));
----

//Every query operation accepts passing parameters by index (`Object...`), or by name (`Map<String,Object>` or `Parameters`).
每个查询操作都接受通过索引 (`Object...`) 或名称  (`Map<String,Object>` or `Parameters`) 的方式传递参数

//=== Query projection
=== 查询映射

Query projection can be done with the `project(Class)` method on the `PanacheQuery` object that is returned by the `find()` methods.
查询映射对象可以通过 `project(Class)` 方法将 `PanacheQuery` 对象的 `find` 方法进行处理。

//You can use it to restrict which fields will be returned by the database.
您可以使用它来限制数据库返回哪些字段。

//Hibernate will use **DTO projection** and generate a SELECT clause with the attributes from the projection class.
//This is also called **dynamic instantiation** or **constructor expression**, more info can be found on the Hibernate guide:
//link:https://docs.jboss.org/hibernate/orm/current/userguide/html_single/Hibernate_User_Guide.html#hql-select-clause[hql select clause]

Hibernate 将使用 **DTO** 映射并生成一个 SELECT 子句。这称为动态实例化（**dynamic instantiation**）或构造函数表达式（**constructor expression**），更多信息可以查看 link:https://docs.jboss.org/hibernate/orm/current/userguide/html_single/Hibernate_User_Guide.html#hql-select-clause[HQL SELECT 子句]



The projection class needs to be a valid Java Bean and have a constructor that contains all its attributes, this constructor will be used to
instantiate the projection DTO instead of using the entity class. This class must have a matching constructor with all the class attributes as parameters.

映射类需要是一个有效的 Java Bean 并且有一个包含所有属性的构造函数，这个构造函数将用于实例化映射对象，而不是使用实体类。此类不许有匹配的构造函数，并将所有属性作为构造参数。

[source,java]
----
import io.quarkus.runtime.annotations.RegisterForReflection;

@RegisterForReflection // <1>
public class PersonName {
    public final String name; // <2>

    public PersonName(String name){ // <3>
        this.name = name;
    }
}

// only 'name' will be loaded from the database
PanacheQuery<PersonName> query = Person.find(""status"", Status.Alive).project(PersonName.class);
----
//<1> The `@RegisterForReflection` annotation instructs Quarkus to keep the class and its members during the native compilation. More details about the `@RegisterForReflection` annotation can be found on  the xref:writing-native-applications-tips.adoc#registerForReflection[native application tips] page.
<1>  `@RegisterForReflection` 注解表示 Quarkus 在编译期间保留类以及成员变量，更多关于 `@RegisterForReflection` 注解的信息可以查看 xref:writing-native-applications-tips-CN.adoc#registerForReflection[原生应用提示] 文档
//<2> We use public fields here, but you can use private fields and getters/setters if you prefer.
<2> 在这里使用 public 修饰字段，如果您愿意可以使用 private 修饰字段和 getters/setters
//<3> This constructor will be used by Hibernate, it must be the only constructor in your class and have all the class attributes as parameters.
<3> 这个构造函数将被 Hibernate 使用，它必须是这个类中的唯一构造函数，并且具有所有成员变量作为构造参数


[WARNING]
====
//The implementation of the `project(Class)` method uses the constructor's parameter names to build the select clause of the query,
//so the compiler must be configured to store parameter names inside the compiled class.
//This is enabled by default if you are using the Quarkus Maven archetype. If you are not using it, add the property `<maven.compiler.parameters>true</maven.compiler.parameters>` to your `pom.xml`.
`project(Class)` 方法的实现使用构造函数的参数名称来构件 SELECT 子句，因此必须将编译器配置为：在编译后的类中存储参数名称。如果您使用 Quarkus Maven 骨架工程，则默认开启此功能。如果您没有使用 Quarkus Maven 骨架工程，请添加 `<maven.compiler.parameters>true</maven.compiler.parameters>` 属性到您的 `pom.xml` 文件.
====

//If in the DTO projection object you have a field from a referenced entity, you can use the `@ProjectedFieldName` annotation to provide the path for the SELECT statement.
如果在映射对象中有来自引用实体的字段，则可以使用 `@ProjectedFieldName` 注解为 SELECT 提供搜索路径。

[source,java]
----
@Entity
public class Dog extends PanacheEntity {
    public String name;
    public String race;
    @ManyToOne
    public Person owner;
}

@RegisterForReflection
public class DogDto {
    public String name;
    public String ownerName;

    public DogDto(String name, @ProjectedFieldName(""owner.name"") String ownerName) {  // <1>
        this.name = name;
        this.ownerName = ownerName;
    }
}

PanacheQuery<DogDto> query = Dog.findAll().project(DogDto.class);
----
//<1> The `ownerName` DTO constructor's parameter will be loaded from the `owner.name` HQL property.
<1> 构造函数中 `ownerName` 的取值将从 HQL 中的 `owner.name` 上获取。

//== Multiple Persistence Units
== 多单元持久化

//The support for multiple persistence units is described in detail in xref:hibernate-orm.adoc#multiple-persistence-units[the Hibernate ORM guide].
在 xref:hibernate-orm-CN.adoc#multiple-persistence-units[Hibernate ORM 教程] 中详细描述了 Hibernate 对多单元持久化的支持。使用 Panache 实现起来很简单：
//
//When using Panache, things are simple:
//
//* A given Panache entity can be attached to only a single persistence unit.
* 给定的 Panache 实体只能附加到单个持久化单元
//* Given that, Panache already provides the necessary plumbing to transparently find the appropriate `EntityManager` associated to a Panache entity.
* Panache 提供了必要的通道来找到与 Panache 实体联动的 `EntityManager`

//== Transactions
== 事务

//Make sure to wrap methods modifying your database (e.g. `entity.persist()`) within a transaction. Marking a
//CDI bean method `@Transactional` will do that for you and make that method a transaction boundary. We recommend doing
//so at your application entry point boundaries like your REST endpoint controllers.
确保修改数据库相关操作的方法封装在事务中（例如 `entity.persist()` ）。使用 `@Transactional` 注解标记 CDI Bean 方法，它将为您完成事务处理。我们建议在您的程序入口使用（例如 REST 端点控制器）

//JPA batches changes you make to your entities and sends changes (it's called flush) at the end of the transaction or before a query.
//This is usually a good thing as it's more efficient.
//But if you want to check optimistic locking failures, do object validation right away or generally want to get immediate feedback, you can force the flush operation by calling `entity.flush()` or even use `entity.persistAndFlush()` to make it a single method call. This will allow you to catch any `PersistenceException` that could occur when JPA send those changes to the database.
//Remember, this is less efficient so don't abuse it.
//And your transaction still has to be committed.

JPA 会批量处理您对实体所做的变化，并在事务结束或查询之前发送变化（称之为 *刷新* ）。这通常情况下是一件耗时，因为它更加有效。但是如果您想检查乐观锁失败或立即进行对象验证，您可以通过强制调用刷新操作（执行 `entity.flush()`  方法）或者使用 `entity.persistAndFlush()` 方法。这允许您捕获 `PersistenceException` 用来收集 JPA 与数据库交互是发送的异常情况。请记住，这样效率较低，请不要滥用它，而且您的事务仍然需要提交。

//Here is an example of the usage of the flush method to allow making a specific action in case of `PersistenceException`:
以下是 `flush` 方法的使用示例：

[source,java]
----
@Transactional
public void create(Parameter parameter){
    try {
        //Here I use the persistAndFlush() shorthand method on a Panache repository to persist to database then flush the changes.
        return parameterRepository.persistAndFlush(parameter);
    }
    catch(PersistenceException pe){
        LOG.error(""Unable to create the parameter"", pe);
        //in case of error, I save it to disk
        diskPersister.save(parameter);
    }
}
----

//== Lock management
== 锁管理

//Panache provides direct support for database locking with your entity/repository, using `findById(Object, LockModeType)` or `find().withLock(LockModeType)`.

Panache 中使用 `findById(Object, LockModeType)` 或者 `find().withLock(LockModeType)` 支持传入锁

//The following examples are for the active record pattern, but the same can be used with repositories.
以活动记录模式为例，锁的使用如下，这个方式同样适用于仓库模式

//=== First: Locking using findById().
=== 第一： 锁定 findById 方法

[source,java]
----
public class PersonEndpoint {

    @GET
    @Transactional
    public Person findByIdForUpdate(Long id){
        Person p = Person.findById(id, LockModeType.PESSIMISTIC_WRITE);
        //do something useful, the lock will be released when the transaction ends.
        return person;
    }

}
----

//=== Second: Locking in a find().
=== 第二： 锁定 find 方法

[source,java]
----
public class PersonEndpoint {

    @GET
    @Transactional
    public Person findByNameForUpdate(String name){
        Person p = Person.find(""name"", name).withLock(LockModeType.PESSIMISTIC_WRITE).findOne();
        //do something useful, the lock will be released when the transaction ends.
        return person;
    }

}
----

//Be careful that locks are released when the transaction ends, so the method that invokes the lock query must be annotated with the `@Transactional` annotation.
注意，事务结束时灰释放所，因此调用所查询的方法必须使用 `@Transactional` 注解。

//== Custom IDs
== 自定义 ID

//IDs are often a touchy subject, and not everyone's up for letting them handled by the framework, once again we
//have you covered.
//
//
//You can specify your own ID strategy by extending `PanacheEntityBase` instead of `PanacheEntity`. Then
//you just declare whatever ID you want as a public field:

ID 通常是一个敏感主题，并不是每一个人都愿意让框架处理它。您可以通过拓展来指定自己的 ID 策略，实体类继承 `PanacheEntityBase` 而不继承 `PanacheEntity`，您只需要声明 ID 字段：


[source,java]
----
@Entity
public class Person extends PanacheEntityBase {

    @Id
    @SequenceGenerator(
            name = ""personSequence"",
            sequenceName = ""person_id_seq"",
            allocationSize = 1,
            initialValue = 4)
    @GeneratedValue(strategy = GenerationType.SEQUENCE, generator = ""personSequence"")
    public Integer id;

    //...
}
----

//If you're using repositories, then you will want to extend `PanacheRepositoryBase` instead of `PanacheRepository`
//and specify your ID type as an extra type parameter:

如果您正在使用仓库模式，那么您应该实现 `PanacheRepositoryBase` 接口而不是 `PanacheRepository` 接口，`PanacheRepositoryBase` 接口允许您自定义 ID 类型。

[source,java]
----
@ApplicationScoped
public class PersonRepository implements PanacheRepositoryBase<Person,Integer> {
    //...
}
----

//== Mocking
== 模拟

//=== Using the active record pattern
=== 使用活动记录模式

//If you are using the active record pattern you cannot use Mockito directly as it does not support mocking static methods,
//but you can use the `quarkus-panache-mock` module which allows you to use Mockito to mock all provided static
//methods, including your own.
//
//Add this dependency to your `pom.xml`:
如果您使用的是活动记录模式，则不能够直接使用 Mockito ，因为它不支持模拟静态方法，但是您可以使用 `quarkus-panache-mock` 模块，它允许您使用 Mockito 模拟所提供的静态方法，依赖信息如下：

[source,xml]
----
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-panache-mock</artifactId>
    <scope>test</scope>
</dependency>
----


//Given this simple entity:
给定简单实体

[source,java]
----
@Entity
public class Person extends PanacheEntity {

    public String name;

    public static List<Person> findOrdered() {
        return find(""ORDER BY name"").list();
    }
}
----

//You can write your mocking test like this:
您可以向这样编写模拟测试

[source,java]
----
@QuarkusTest
public class PanacheFunctionalityTest {

    @Test
    public void testPanacheMocking() {
        PanacheMock.mock(Person.class);

        // Mocked classes always return a default value
        Assertions.assertEquals(0, Person.count());

        // Now let's specify the return value
        Mockito.when(Person.count()).thenReturn(23L);
        Assertions.assertEquals(23, Person.count());

        // Now let's change the return value
        Mockito.when(Person.count()).thenReturn(42L);
        Assertions.assertEquals(42, Person.count());

        // Now let's call the original method
        Mockito.when(Person.count()).thenCallRealMethod();
        Assertions.assertEquals(0, Person.count());

        // Check that we called it 4 times
        PanacheMock.verify(Person.class, Mockito.times(4)).count();// <1>

        // Mock only with specific parameters
        Person p = new Person();
        Mockito.when(Person.findById(12L)).thenReturn(p);
        Assertions.assertSame(p, Person.findById(12L));
        Assertions.assertNull(Person.findById(42L));

        // Mock throwing
        Mockito.when(Person.findById(12L)).thenThrow(new WebApplicationException());
        Assertions.assertThrows(WebApplicationException.class, () -> Person.findById(12L));

        // We can even mock your custom methods
        Mockito.when(Person.findOrdered()).thenReturn(Collections.emptyList());
        Assertions.assertTrue(Person.findOrdered().isEmpty());
        
        // Mocking a void method
        Person.voidMethod();

        // Make it throw
        PanacheMock.doThrow(new RuntimeException(""Stef2"")).when(Person.class).voidMethod();
        try {
            Person.voidMethod();
            Assertions.fail();
        } catch (RuntimeException x) {
            Assertions.assertEquals(""Stef2"", x.getMessage());
        }

        // Back to doNothing
        PanacheMock.doNothing().when(Person.class).voidMethod();
        Person.voidMethod();

        // Make it call the real method
        PanacheMock.doCallRealMethod().when(Person.class).voidMethod();
        try {
            Person.voidMethod();
            Assertions.fail();
        } catch (RuntimeException x) {
            Assertions.assertEquals(""void"", x.getMessage());
        }

        PanacheMock.verify(Person.class).findOrdered();
        PanacheMock.verify(Person.class, Mockito.atLeast(4)).voidMethod();
        PanacheMock.verify(Person.class, Mockito.atLeastOnce()).findById(Mockito.any());
        PanacheMock.verifyNoMoreInteractions(Person.class);
    }
}
----
//<1> Be sure to call your `verify` and `do*` methods on `PanacheMock` rather than `Mockito`, otherwise you won't know
//what mock object to pass.

<1> 请务必调用 `PanacheMock` 提供的 `verify` 方法和 `do*` 方法。而不是 `Mockito` 类中提供的方法，否则您将不知道要传递什么对象进行模拟。

//==== Mocking `EntityManager`, `Session` and entity instance methods
==== 模拟 `EntityManager` 、 `Session` 和实体实例化方法


//If you need to mock entity instance methods, such as `persist()` you can do it by mocking the Hibernate ORM `Session` object:
如果您需要模拟实体实例化方法，比如 `persist()` 方法，您可以通过模拟 Hibernate ORM Session 对象来实现：

[source,java]
----
@QuarkusTest
public class PanacheMockingTest {

    @InjectMock
    Session session;

    @BeforeEach
    public void setup() {
        Query mockQuery = Mockito.mock(Query.class);
        Mockito.doNothing().when(session).persist(Mockito.any());
        Mockito.when(session.createQuery(Mockito.anyString())).thenReturn(mockQuery);
        Mockito.when(mockQuery.getSingleResult()).thenReturn(0l);
    }

    @Test
    public void testPanacheMocking() {
        Person p = new Person();
        // mocked via EntityManager mocking
        p.persist();
        Assertions.assertNull(p.id);

        Mockito.verify(session, Mockito.times(1)).persist(Mockito.any());
    }
}
----

//=== Using the repository pattern
=== 使用仓库模式

//If you are using the repository pattern you can use Mockito directly, using the `quarkus-junit5-mockito` module,
//which makes mocking beans much easier:
如果您使用仓库模式，您可以直接使用 Mockito ，使用 `quarkus-junit5-mockito` 模块，这使得模拟 bean 更容易：

[source,xml]
----
<dependency>
    <groupId>io.quarkus</groupId>
    <artifactId>quarkus-junit5-mockito</artifactId>
    <scope>test</scope>
</dependency>
----

//Given this simple entity:
给定简单实体

[source,java]
----
@Entity
public class Person {

    @Id
    @GeneratedValue
    public Long id;

    public String name;
}
----

//And this repository:
仓库对象：

[source,java]
----
@ApplicationScoped
public class PersonRepository implements PanacheRepository<Person> {
    public List<Person> findOrdered() {
        return find(""ORDER BY name"").list();
    }
}
----

//You can write your mocking test like this:
您可以向这样编写模拟测试

[source,java]
----
@QuarkusTest
public class PanacheFunctionalityTest {
    @InjectMock
    PersonRepository personRepository;

    @Test
    public void testPanacheRepositoryMocking() throws Throwable {
        // Mocked classes always return a default value
        Assertions.assertEquals(0, personRepository.count());

        // Now let's specify the return value
        Mockito.when(personRepository.count()).thenReturn(23L);
        Assertions.assertEquals(23, personRepository.count());

        // Now let's change the return value
        Mockito.when(personRepository.count()).thenReturn(42L);
        Assertions.assertEquals(42, personRepository.count());

        // Now let's call the original method
        Mockito.when(personRepository.count()).thenCallRealMethod();
        Assertions.assertEquals(0, personRepository.count());

        // Check that we called it 4 times
        Mockito.verify(personRepository, Mockito.times(4)).count();

        // Mock only with specific parameters
        Person p = new Person();
        Mockito.when(personRepository.findById(12L)).thenReturn(p);
        Assertions.assertSame(p, personRepository.findById(12L));
        Assertions.assertNull(personRepository.findById(42L));

        // Mock throwing
        Mockito.when(personRepository.findById(12L)).thenThrow(new WebApplicationException());
        Assertions.assertThrows(WebApplicationException.class, () -> personRepository.findById(12L));

        Mockito.when(personRepository.findOrdered()).thenReturn(Collections.emptyList());
        Assertions.assertTrue(personRepository.findOrdered().isEmpty());

        // We can even mock your custom methods
        Mockito.verify(personRepository).findOrdered();
        Mockito.verify(personRepository, Mockito.atLeastOnce()).findById(Mockito.any());
        Mockito.verifyNoMoreInteractions(personRepository);
    }
}
----

//== How and why we simplify Hibernate ORM mappings
== 为什么要如此简化 Hibernate ORM 的映射

//When it comes to writing Hibernate ORM entities, there are a number of annoying things that users have grown used to
//reluctantly deal with, such as:
在编写 Hibernate ORM 实体时，用户已经习惯了不情愿的处理许多令人烦恼的事情，例如：

//- Duplicating ID logic: most entities need an ID, most people don't care how it's set, because it's not really
//relevant to your model.
- 重复 ID 逻辑，大多数实体都需要一个ID，大多数人都不关心它是如何设置的，因为它与您的模型并非直接相关

- Traditional EE patterns advise to split entity definition (the model) from the operations you can do on them
(DAOs, Repositories), but really that requires a split between the state and its operations even though
we would never do something like that for regular objects in the Object Oriented architecture, where state and methods
are in the same class. Moreover, this requires two classes per entity, and requires injection of the DAO or Repository
where you need to do entity operations, which breaks your edit flow and requires you to get out of the code you're
writing to set up an injection point before coming back to use it.
- 传统 EE 模型中建议将实体定义（模型）从您可以对它们的执行操作（DAO,仓库) 中分离，单实际上这需要在状态和操作之间进行分离。

//- Hibernate queries are super powerful, but overly verbose for common operations, requiring you to write queries even
//when you don't need all the parts.
- Hibernate 查询非常强大，但对于常见操作来说过于荣昌，及时您不需要所有部分，也需要编写查询。
//- Hibernate is very general-purpose, but does not make it trivial to do trivial operations that make up 90% of our
//model usage.
- Hibernate 是非常通用的，单不会让我们的模型使用率高达 90% 的琐碎操作变得轻而易举。

//With Panache, we took an opinionated approach to tackle all these problems:
借助 Panache ，我们采取了一种自以为是的方法来解决这些问题：

//- Make your entities extend `PanacheEntity`: it has an ID field that is auto-generated. If you require
//a custom ID strategy, you can extend `PanacheEntityBase` instead and handle the ID yourself.
- 您的实体通过继承 `PanacheEntity` ： 它有一个自动生成的 ID 字段，如果宁需要自定义 ID策略，则可以继承 `PanacheEntityBase` 拓展ID。
- Use public fields. Get rid of dumb getter and setters. Hibernate ORM w/o Panache also doesn't require you to use getters and setters,
but Panache will additionally generate all getters and setters that are missing, and rewrite every access to these fields to use the accessor methods. This way you can still
write _useful_ accessors when you need them, which will be used even though your entity users still use field accesses. This implies that from the Hibernate perspective you're using accessors via getters and setters even while it looks like field accessors.
//- With the active record pattern: put all your entity logic in static methods in your entity class and don't create DAOs.
//Your entity superclass comes with lots of super useful static methods, and you can add your own in your entity class.
//Users can just start using your entity `Person` by typing `Person.` and getting completion for all the operations in a single place.
- 使用活动记录模式，将所有实体逻辑放在实体的静态方法中，不需要创建DAO。您的实体类中会携带很多有用的静态方法，您可以在实体类中增加自己想要的方法，用户只需要在一个地方输入 `Person` 即可操作实体相关内容。

//- Don't write parts of the query that you don't need: write `Person.find(""order by name"")` or
//`Person.find(""name = ?1 and status = ?2"", ""stef"", Status.Alive)` or even better
//`Person.find(""name"", ""stef"")`.
- 不需要编写查询部分； 编写 `Person.find(""order by name"")` 、 `Person.find(""name = ?1 and status = ?2"", ""stef"", Status.Alive)` 甚至于 `Person.find(""name"", ""stef"")`

//That's all there is to it: with Panache, Hibernate ORM has never looked so trim and neat.
有了 Panache Hibernate ORM 从未看起来如此简单

//== Defining entities in external projects or jars
== 在外部项目或 jar 中定义实体

//Hibernate ORM with Panache relies on compile-time bytecode enhancements to your entities.
带有 Panache 的 Hibernate ORM 依赖于对实体的编译时字节码增强。



//It attempts to identify archives with Panache entities (and consumers of Panache entities)
//by the presence of the marker file `META-INF/panache-archive.marker`. Panache includes an
//annotation processor that will automatically create this file in archives that depend on
//Panache (even indirectly). If you have disabled annotation processors you may need to create
//this file manually in some cases.

它尝试通过标记文件  `META-INF/panache-archive.marker` 来识别 Panache 实体，Panache包含一个注解处理器，它将自动以来在 Panache （或者间接依赖）。如果您禁用了注解处理器，在某些情况下需要手动创建该文件。



//WARNING: If you include the jpa-modelgen annotation processor this will exclude the Panache
//annotation processor by default. If you do this you should either create the marker file
//yourself, or add the `quarkus-panache-common` as well, as shown below:
WARNING: 如果您包含 jpa-modelgen 注解处理器，在默认情况下是排除 Panache 注解处理器。如果您这样做，您应该自己创建标记文件，或者添加 `quarkus-panache-common` 依赖，


[source,xml]
----
<plugin>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>${compiler-plugin.version}</version>
    <configuration>
      <annotationProcessorPaths>
        <annotationProcessorPath>
          <groupId>org.hibernate</groupId>
          <artifactId>hibernate-jpamodelgen</artifactId>
          <version>${hibernate.version}</version>
        </annotationProcessorPath>
        <annotationProcessorPath>
          <groupId>io.quarkus</groupId>
          <artifactId>quarkus-panache-common</artifactId>
          <version>${quarkus.platform.version}</version>
        </annotationProcessorPath>
      </annotationProcessorPaths>
    </configuration>
</plugin>
----
",12039,False,2172.6007323922813,median
"//////////////////////////////////////////

  Licensed to the Apache Software Foundation (ASF) under one
  or more contributor license agreements.  See the NOTICE file
  distributed with this work for additional information
  regarding copyright ownership.  The ASF licenses this file
  to you under the Apache License, Version 2.0 (the
  ""License""); you may not use this file except in compliance
  with the License.  You may obtain a copy of the License at

    http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing,
  software distributed under the License is distributed on an
  ""AS IS"" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  KIND, either express or implied.  See the License for the
  specific language governing permissions and limitations
  under the License.

//////////////////////////////////////////

= Object orientation
:jls: https://docs.oracle.com/javase/specs/jls/se14/html/
:javabeans: https://download.oracle.com/otndocs/jcp/7224-javabeans-1.01-fr-spec-oth-JSpec/

This chapter covers the object orientation of the Groovy programming language.

== Types

=== Primitive types

Groovy supports the same primitive types as those defined by the {jls}[Java Language Specification]:

* integral types: `byte` (8 bit), `short` (16 bit), `int` (32 bit) and `long` (64 bit)
* floating-point types: `float` (32 bit) and `double` (64 bit)
* `boolean` type (exactly `true` or `false`)
* `char` type (16 bit, usable as a numeric type, representing an UTF-16 code)

While Groovy declares and stores primitive fields and variables as primitives, because it uses Objects for
everything, it autowraps references to primitives. Just like Java, the wrappers it uses are

[cols=""1,1"" options=""header""]
.primitive wrappers
|====
| Primitive type
| Wrapper class

| boolean
| Boolean

| char
| Character

| short
| Short

| int
| Integer

| long
| Long

| float
| Float

| double
| Double
|====

Here's an example using `int`

[source,groovy]
----
include::../test/PrimitiveTest.groovy[tags=primitive_references,indent=0]
----

Now you may be concerned that this means every time you use a mathematical operator on a reference to a primitive
that you'll incur the cost of unboxing and reboxing the primitive. But this is not the case, as Groovy will compile
your operators into their link:core-operators.html#_operator-overloading[method equivalents] and uses those instead.
Additionally, Groovy will automatically unbox to a primitive when calling a Java method that takes a primitive
parameter and automatically box primitive method return values from Java. However, be aware there are some
link:core-differences-java.html#_primitives_and_wrappers[differences] from Java's method resolution.

=== Class

Groovy classes are very similar to Java classes, and are compatible with Java ones at JVM level.
They may have methods, fields and properties (think JavaBeans properties but with less boilerplate).
Classes and class members can have the same modifiers (public, protected, private, static, etc) as in Java
with some minor differences at the source level which are explained shortly.

The key differences between Groovy classes and their Java counterparts are:

* Classes or methods with no visibility modifier are automatically public (a special annotation can be used to achieve package private visibility).
* Fields with no visibility modifier are turned into properties automatically, which results in less verbose code,
since explicit getter and setter methods aren't needed. More on this aspect will be covered in the <<fields,fields and properties section>>.
* Classes do not need to have the same base name as their source file definitions but it is highly recommended in most scenarios (see also the next point about scripts).
* One source file may contain one or more classes (but if a file contains any code not in a class, it is considered a script). Scripts are just classes with some
special conventions and will have the same name as their source file (so don't include a class definition within a script having the same name as the script source file).

The following code presents an example class.

[source,groovy]
----
include::../test/ClassTest.groovy[tags=class_definition,indent=0]
----
<1> class beginning, with the name `Person`
<2> string field and property named `name`
<3> method definition


==== Normal class

Normal classes refer to classes which are top level and concrete. This means they can be instantiated without restrictions from any other classes or scripts. This way, they can only be public (even though the `public` keyword may be suppressed). Classes are instantiated by calling their constructors, using the `new` keyword, as in the following snippet.

[source,groovy]
----
include::../test/ClassTest.groovy[tags=class_instantiation,indent=0]
----


==== Inner class

Inner classes are defined within another classes. The enclosing class can use the inner class as usual. On the other side, a inner class can access members of its enclosing class, even if they are private. Classes other than the enclosing class are not allowed to access inner classes. Here is an example:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=inner_class,indent=0]
----
<1> the inner class is instantiated and its method gets called
<2> inner class definition, inside its enclosing class
<3> even being private, a field of the enclosing class is accessed by the inner class

There are some reasons for using inner classes:

 * They increase encapsulation by hiding the inner class from other classes, which do not need to know about it. This also leads to cleaner packages and workspaces.
 * They provide a good organization, by grouping classes that are used by only one class.
 * They lead to more maintainable codes, since inner classes are near the classes that use them.

It is common for an inner class to be an implementation of some interface whose method(s) are needed by the outer class.
The code below illustrates this typical usage pattern, here being used with threads.

[source,groovy]
----
include::../test/ClassTest.groovy[tags=inner_class2,indent=0]
----

Note that the class `Inner2` is defined only to provide an implementation of the method `run` to class `Outer2`.
Anonymous inner classes help to eliminate verbosity in this case.
That topic is covered shortly.

Groovy 3+ also supports Java syntax for non-static inner class instantiation, for example:

[source,groovy]
--------------------------------------
include::../test/ClassTest.groovy[tags=inner_instantiation,indent=0]
--------------------------------------

===== Anonymous inner class

The earlier example of an inner class (`Inner2`) can be simplified with an anonymous inner class.
The same functionality can be achieved with the following code:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=anonymous_inner_class,indent=0]
----
<1> comparing with the last example of previous section, the `new Inner2()` was replaced by `new Runnable()` along with all its implementation
<2> the method `start` is invoked normally

Thus, there was no need to define a new class to be used just once.

==== Abstract class

Abstract classes represent generic concepts, thus, they cannot be instantiated, being created to be subclassed.
Their members include fields/properties and abstract or concrete methods.
Abstract methods do not have implementation, and must be implemented by concrete subclasses.

[source,groovy]
----
include::../test/ClassTest.groovy[tags=abstract_class,indent=0]
----
<1> abstract classes must be declared with `abstract` keyword
<2> abstract methods must also be declared with `abstract` keyword

Abstract classes are commonly compared to interfaces.
There are at least two important differences of choosing one or another.
First, while abstract classes may contain fields/properties and concrete methods, interfaces may contain only abstract methods (method signatures).
Moreover, one class can implement several interfaces, whereas it can extend just one class, abstract or not.

=== Inheritance

Inheritance in Groovy resembles inheritance in Java.
It provides a mechanism for a child class (or subclass) to reuse
code or properties from a parent (or super class).
Classes related through inheritance form an inheritance hierarchy.
Common behavior and members are pushed up the hierarchy to reduce duplication.
Specializations occur in child classes.

Different forms of inheritance are supported:

* _implementation_ inheritance where code (methods, fields or properties) from a <<superclass,superclass>> or from
one or more <<_traits,traits>> is reused by a child class
* _contract_ inheritance where a class promises to provide particular abstract methods defined in a <<superclass,superclass>>,
or defined in one or more <<_traits,traits>> or <<_interface,interfaces>>.

=== Interface

An interface defines a contract that a class needs to conform to.
An interface only defines a list of methods that need
to be implemented, but does not define the method's implementation.

[source,groovy]
----
include::../test/ClassTest.groovy[tags=interface_def_1,indent=0]
----
<1> an interface needs to be declared using the `interface` keyword
<2> an interface only defines method signatures

Methods of an interface are always *public*. It is an error to use `protected` or `private` methods in interfaces:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=protected_forbidden,indent=0]
----
<1> Using `protected` is a compile-time error

A class _implements_ an interface if it defines the interface in its `implements` list or if any of its superclasses
does:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=class_implements,indent=0]
----
<1> The `SystemGreeter` declares the `Greeter` interface using the `implements` keyword
<2> Then implements the required `greet` method
<3> Any instance of `SystemGreeter` is also an instance of the `Greeter` interface

An interface can extend another interface:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=extended_interface,indent=0]
----
<1> the `ExtendedGreeter` interface extends the `Greeter` interface using the `extends` keyword

It is worth noting that for a class to be an instance of an interface, it has to be explicit. For example, the following
class defines the `greet` method as it is declared in the `Greeter` interface, but does not declare `Greeter` in its
interfaces:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=no_structural_interface,indent=0]
----

In other words, Groovy does not define structural typing. It is however possible to make an instance of an object
implement an interface at runtime, using the `as` coercion operator:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=interface_coercion,indent=0]
----
<1> create an instance of `DefaultGreeter` that does not implement the interface
<2> coerce the instance into a `Greeter` at runtime
<3> the coerced instance implements the `Greeter` interface

You can see that there are two distinct objects: one is the source object, a `DefaultGreeter` instance, which does not
implement the interface. The other is an instance of `Greeter` that delegates to the coerced object.

TIP: Groovy interfaces do not support default implementation like Java 8 interfaces. If you are looking for something
similar (but not equal), <<_traits,traits>> are close to interfaces, but allow default implementation as well as other
important features described in this manual.

[[superclass]]
=== Superclass

Parent classes share visible fields, properties or methods with child classes.
A child class may have at most one parent class.
The `extends` keyword is used immediately prior to giving the superclass type.

=== Constructors

Constructors are special methods used to initialize an object with a specific state. As with normal methods,
it is possible for a class to declare more than one constructor, so long as each constructor has a unique
type signature. If an object doesn't require any parameters during construction, it may use a _no-arg_ constructor.
If no constructors are supplied, an empty no-arg constructor will be provided by the Groovy compiler.

Groovy supports two invocation styles:

* _positional parameters_ are used in a similar to how you would use Java constructors
* _named parameters_ allow you to specify parameter names when invoking the constructor.

==== Positional parameters

To create an object by using positional parameters, the respective class needs to declare one or more
constructors. In the case of multiple constructors, each must have a unique type signature. The constructors can also
added to the class using the gapi:groovy.transform.TupleConstructor[] annotation.

Typically, once at least one constructor is declared, the class can only be instantiated by having one of its
constructors called. It is worth noting that, in this case, you can't normally create the class with named parameters.
Groovy does support named parameters so long as the class contains a no-arg constructor or provides a constructor which
takes a `Map` argument as the first (and potentially only) argument - see the next section for details.

There are three forms of using a declared constructor. The first one is the normal Java way, with the `new` keyword.
The others rely on coercion of lists into the desired types. In this case, it is possible to coerce with the `as`
keyword and by statically typing the variable.

[source,groovy]
----
include::../test/ClassTest.groovy[tags=constructor_positional_parameters,indent=0]
----
<1> Constructor declaration
<2> Constructor invocation, classic Java way
<3> Constructor usage, using coercion with `as` keyword
<4> Constructor usage, using coercion in assignment

==== Named parameters

If no (or a no-arg) constructor is declared, it is possible to create objects by passing parameters in the form of a
map (property/value pairs). This can be in handy in cases where one wants to allow several combinations of parameters.
Otherwise, by using traditional positional parameters it would be necessary to declare all possible constructors.
Having a constructor where the first (and perhaps only) argument is a `Map` argument is also supported - such a
constructor may also be added using the gapi:groovy.transform.MapConstructor[] annotation.

[source,groovy]
----
include::../test/ClassTest.groovy[tags=constructor_named_parameters,indent=0]
----
<1> No constructor declared
<2> No parameters given in the instantiation
<3> `name` parameter given in the instantiation
<4> `age` parameter given in the instantiation
<5> `name` and `age` parameters given in the instantiation

It is important to highlight, however, that this approach gives more power to the constructor caller,
while imposing an increased responsibility on the caller to get the names and value types correct.
Thus, if greater control is desired, declaring constructors using positional parameters might be preferred.

Notes:

* While the example above supplied no constructor, you can also supply a no-arg constructor
or a constructor where the first argument is a `Map`, most typically it's the only argument.
* When no (or a no-arg) constructor is declared, Groovy replaces the named constructor call by a call
to the no-arg constructor followed by calls to the setter for each supplied named property.
* When the first argument is a Map, Groovy combines all named parameters into a Map (regardless of ordering)
and supplies the map as the first parameter. This can be a good approach if your properties are declared as
`final` (since they will be set in the constructor rather than after the fact with setters).
* You can support both named and positional construction
by supply both positional constructors as well as a no-arg or Map constructor.
* You can support hybrid construction by having a constructor where the first argument
is a Map but there are also additional positional parameters. Use this style with caution.

=== Methods

Groovy methods are quite similar to other languages. Some peculiarities will be shown in the next subsections. 

==== Method definition

A method is defined with a return type or with the `def` keyword, to make the return type untyped. A method can also receive any number of arguments, which may not have their types explicitly declared. Java modifiers can be used normally, and if no visibility modifier is provided, the method is public.

Methods in Groovy always return some value. If no `return` statement is provided, the value evaluated in the last line executed will be returned. For instance, note that none of the following methods uses the `return` keyword.

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=method_definition ,indent=0]
----
<1> Method with no return type declared and no parameter
<2> Method with explicit return type and no parameter
<3> Method with a parameter with no type defined
<4> Static method with a String parameter

==== Named parameters

Like constructors, normal methods can also be called with named parameters.
To support this notation, a convention is used where the first argument to the method is a `Map`.
In the method body, the parameter values can be accessed as in normal maps (`map.key`).
If the method has just a single Map argument, all supplied parameters must be named.

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=named_arguments ,indent=0]
----

===== Mixing named and positional parameters

Named parameters can be mixed with positional parameters.
The same convention applies, in this case, in addition to the `Map` argument as the first argument,
the method in question will have additional positional arguments as needed.
Supplied positional parameters when calling the method must be in order.
The named parameters can be in any position. They are grouped into the map and supplied as
the first parameter automatically.

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=named_arguments_with_additional_arguments ,indent=0]
----
<1> Method call with additional `number` argument of `Integer` type
<2> Method call with changed order of arguments


If we don't have the Map as the first argument, then a Map must be supplied for that argument instead of named parameters.
Failure to do so will lead to `groovy.lang.MissingMethodException`:

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=failed_named_arguments_with_additional_arguments ,indent=0]
----
<1> Method call throws `groovy.lang.MissingMethodException: No signature of method: foo() is applicable for argument types: (LinkedHashMap, Integer) values: [[name:Marie, age:1], 23]`, because the named argument `Map` parameter is not defined as the first argument

Above exception can be avoided if we replace named arguments with an explicit `Map` argument:

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=explicit_named_arguments_with_additional_arguments ,indent=0]
----
<1> Explicit `Map` argument in place of named arguments makes invocation valid

TIP: Although Groovy allows you to mix named and positional parameters, it can lead to unnecessary confusion.
Mix named and positional arguments with caution.

==== Default arguments

Default arguments make parameters optional. If the argument is not supplied, the method assumes a default value.

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=default_arguments ,indent=0]
----

Note that no mandatory parameter can be defined after a default parameter is present, only other default parameters.

==== Varargs

Groovy supports methods with a variable number of arguments. They are defined like this: `def foo(p1, ..., pn, T... args)`.
Here `foo` supports `n` arguments by default, but also an unspecified number of further arguments exceeding `n`.

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=varargs_example,indent=0]
----

This example defines a method `foo`, that can take any number of arguments, including no arguments at all.
`args.length` will return the number of arguments given. Groovy allows `T[]` as a alternative notation to `T...`.
That means any method with an array as last parameter is seen by Groovy as a method that can take a variable number of arguments.

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=varargs_array_notation,indent=0]
----

If a method with varargs is called with `null` as the vararg parameter, then the argument will be `null` and not an array of length one with `null` as the only element.

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=varargs_null_parameter,indent=0]
----

If a varargs method is called with an array as an argument, then the argument will be that array instead of an array of length one containing the given array as the only element.

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=varargs_array_parameter,indent=0]
----

Another important point are varargs in combination with method overloading. In case of method overloading Groovy will select the most specific method.
For example if a method `foo` takes a varargs argument of type `T` and another method `foo` also takes one argument of type `T`, the second method is preferred.

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=varargs_method_overloading,indent=0]
----

==== Method selection algorithm

Dynamic Groovy supports https://en.wikipedia.org/wiki/Multiple_dispatch[multiple dispatch] (aka multimethods).
When calling a method, the actual method invoked is determined
dynamically based on the run-time type of methods arguments.
First the method name and number of arguments will be considered (including allowance for varargs),
and then the type of each argument.
Consider the following method definitions:

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=multi_methods,indent=0]
----

Perhaps as expected, calling `method` with `String` and `Integer` parameters,
invokes our third method definition.

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=call_single_method,indent=0]
----

Of more interest here is when the types are not known at compile time.
Perhaps the arguments are declared to be of type `Object` (a list of such objects in our case).
Java would determine that the `method(Object, Object)` variant would be selected in all
cases (unless casts were used) but as can be seen in the following example, Groovy uses the runtime type
and will invoke each of our methods once (and normally, no casting is needed):

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=call_multi_methods,indent=0]
----

For each of the first two of our three method invocations an exact match of argument types was found.
For the third invocation, an exact match of `method(Integer, Integer)` wasn't found but `method(Object, Object)`
is still valid and will be selected.

Method selection then is about finding the _closest fit_ from valid method candidates which have compatible
parameter types.
So, `method(Object, Object)` is also valid for the first two invocations but is not as close a match
as the variants where types exactly match.
To determine the closest fit, the runtime has a notion of the _distance_ an actual argument
type is away from the declared parameter type and tries to minimise the total distance across all parameters.

The following table illustrates some factors which affect the distance calculation.

[cols=""1,1"" options=""header""]
|====
| Aspect
| Example

| Directly implemented interfaces match more closely than ones from further up the inheritance hierarchy.
a| Given these interface and method definitions:

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=multi_method_distance_interfaces,indent=0]
----

The directly implemented interface will match:

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=multi_method_distance_interfaces_usage,indent=0]
----

| An Object array is preferred over an Object.
a|
[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=object_array_over_object,indent=0]
----

| Non-vararg variants are favored over vararg variants.
a|
[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=non_varargs_over_vararg,indent=0]
----

| If two vararg variants are applicable, the one which uses the minimum number of vararg arguments is preferred.
a|
[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=minimal_varargs,indent=0]
----

| Interfaces are preferred over super classes.
a|
[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=multi_method_distance_interface_over_super,indent=0]
----

| For a primitive argument type, a declared parameter type which is the same or slightly larger is preferred.
a|
[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=primitive_larger_over_smaller,indent=0]
----
|====

In the case where two variants have exactly the same distance, this is deemed ambiguous and will cause a runtime exception:

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=multi_method_ambiguous,indent=0]
----

Casting can be used to select the desired method:

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=multi_method_ambiguous_cast,indent=0]
----


==== Exception declaration

Groovy automatically allows you to treat checked exceptions like unchecked exceptions.
This means that you don't need to declare any checked exceptions that a method may throw
as shown in the following example which can throw a `FileNotFoundException` if the file isn't found:

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=idiomatic_method_declaration,indent=0]
----

Nor will you be required to surround the call to the `badRead` method in the previous example within a try/catch
block - though you are free to do so if you wish.

If you wish to declare any exceptions that your code might throw (checked or otherwise) you are free to do so.
Adding exceptions won't change how the code is used from any other Groovy code but can be seen as documentation
for the human reader of your code. The exceptions will become part of the method declaration in the bytecode,
so if your code might be called from Java, it might be useful to include them.
Using an explicit checked exception declaration is illustrated in the following example:

[source,groovy]
----
include::../test/objectorientation/MethodsTest.groovy[tags=checked_method_declaration,indent=0]
----

=== Fields and Properties

[[fields]]
==== Fields

A field is a member of a class or a trait which has:

* a mandatory _access modifier_ (`public`, `protected`, or `private`)
* one or more optional _modifiers_ (`static`, `final`, `synchronized`)
* an optional _type_
* a mandatory _name_

[source,groovy]
----
include::../test/ClassTest.groovy[tags=field_declaration,indent=0]
----
<1> a `private` field named `id`, of type `int`
<2> a `protected` field named `description`, of type `String`
<3> a `public static final` field named _DEBUG_ of type `boolean`

A field may be initialized directly at declaration:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=field_initialization,indent=0]
----
<1> the private field `id` is initialized with `IDGenerator.next()`

It is possible to omit the type declaration of a field. This is however considered a bad practice and in general it
is a good idea to use strong typing for fields:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=typing_fields,indent=0]
----
<1> the field `mapping` doesn't declare a type
<2> the field `mapping` has a strong type

The difference between the two is important if you want to use optional type checking later.
It is also important as a way to document the class design.
However, in some cases like scripting or if you want to rely on duck typing it may be useful
to omit the type.

[[properties]]
==== Properties

A property is an externally visible feature of a class. Rather than just using a public field to represent
such features (which provides a more limited abstraction and would restrict refactoring possibilities),
the typical approach in Java is to follow the conventions outlined in the
{javabeans}[JavaBeans Specification], i.e. represent the property using a
combination of a private backing field and getters/setters. Groovy follows these same conventions
but provides a simpler way to define the property. You can define a property with:

* an *absent* access modifier (no `public`, `protected` or `private`)
* one or more optional _modifiers_ (`static`, `final`, `synchronized`)
* an optional _type_
* a mandatory _name_

Groovy will then generate the getters/setters appropriately. For example:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=properties_definition,indent=0]
----
<1> creates a backing `private String name` field, a `getName` and a `setName` method
<2> creates a backing `private int age` field, a `getAge` and a `setAge` method

If a property is declared `final`, no setter is generated:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=readonly_property,indent=0]
----
<1> defines a read-only property of type `String`
<2> defines a read-only property of type `int`
<3> assigns the `name` parameter to the `name` field
<4> assigns the `age` parameter to the `age` field

Properties are accessed by name and will call the getter or setter transparently, unless the code is in the class
which defines the property:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=property_access,indent=0]
----
<1> `this.name` will directly access the field because the property is accessed from within the class that defines it
<2> similarily a read access is done directly on the `name` field
<3> write access to the property is done outside of the `Person` class so it will implicitly call `setName`
<4> read access to the property is done outside of the `Person` class so it will implicitly call `getName`
<5> this will call the `name` method on `Person` which performs a direct access to the field
<6> this will call the `title` method on `Person` which performs a direct read access to the field

It is worth noting that this behavior of accessing the backing field directly is done in order to prevent a stack
overflow when using the property access syntax within a class that defines the property.

It is possible to list the properties of a class thanks to the meta `properties` field of an instance:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=properties_meta,indent=0]
----

By convention, Groovy will recognize properties even if there is no backing field
provided there are getters or setters
that follow the Java Beans specification. For example:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=pseudo_properties,indent=0]
----
<1> writing `p.name` is allowed because there is a pseudo-property `name`
<2> reading `p.age` is allowed because there is a pseudo-readonly property `age`
<3> writing `p.groovy` is allowed because there is a pseudo-writeonly property `groovy`

This syntactic sugar is at the core of many DSLs written in Groovy.

===== Property naming conventions

It is generally recommended that the first two letters of a property name are
lowercase and for multi-word properties that camel case is used.
In those cases, generated getters and setters will have a name formed by capitalizing the
property name and adding a `get` or `set` prefix (or optionally ""is"" for a boolean getter).
So, `getLength` would be a getter  for a `length` property and `setFirstName` a setter for a `firstName` property.
`isEmpty` might be the getter method name for a property named `empty`.

[NOTE]
====
Property names starting with a capital letter would have getters/setters with just the prefix added.
So, the property `Foo` is allowed even though it isn't following the recommended naming conventions.
For this property, the accessor methods would be `setFoo` and `getFoo`.
A consequence of this is that you aren't allowed to have both a `foo` and a `Foo` property,
since they would have the same named accessor methods.
====

The JavaBeans specification makes a special case for properties which typically might be acronyms.
If the first two letters of a property name are uppercase, no capitalization is performed
(or more importantly, no decapitalization is done if generating the property name from the accessor method name).
So, `getURL` would be the getter for a `URL` property.

[NOTE]
====
Because of the special ""acronym handling"" property naming logic in the JavaBeans specification, the
conversion to and from a property name are non-symmetrical. This leads to some strange edge cases.
Groovy adopts a naming convention that avoids one ambiguity that might seem a little strange but
was popular at the time of Groovy's design and has remained (so far) for historical reasons.
Groovy looks at the second letter of a property name. If that is a capital, the property is deemed to be
one of the acronym style properties and no capitalization is done, otherwise normal capitalization is done.
Although we _never_ recommend it, it does allow you to have what might seem like ""duplicate named"" properties,
e.g. you can have `aProp` and `AProp`, or `pNAME` and `PNAME`. The getters would be `getaProp` and `getAProp`,
and `getpNAME` and `getPNAME` respectively.
====

===== Modifiers on a property

We have already seen that properties are defined by omitting the visibility modifier.
In general, any other modifiers, e.g. `transient` would be copied across to the field.
Two special cases are worth noting:

* `final`, which we saw earlier is for read-only properties, is copied onto the backing field but also causes no setter to be defined
* `static` is copied onto the backing field but also causes the accessor methods to be static

If you wish to have a modifier like `final` also carried over to the accessor methods,
you can write your properties long hand or consider using a <<split-properties,split property definition>>.

===== Annotations on a property

Annotations, including those associated with AST transforms,
are copied on to the backing field for the property.
This allows AST transforms which are applicable to fields to
be applied to properties, e.g.:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=annotated_properties,indent=0]
----
<1> Confirms no eager initialization
<2> Normal property access
<3> Confirms initialization upon property access

[[split-properties]]
===== Split property definition with an explicit backing field

Groovy's property syntax is a convenient shorthand when your class design
follows certain conventions which align with common JavaBean practice.
If your class doesn't exactly fit these conventions,
you can certainly write the getter, setter and backing field long hand like you would in Java.
However, Groovy does provide a split definition capability which still provides
a shortened syntax while allowing slight adjustments to the conventions.
For a split definition, you write a field and a property with the same name and type.
Only one of the field or property may have an initial value.

For split properties, annotations on the field remain on the backing field for the property.
Annotations on the property part of the definition are copied onto the getter and setter methods.

This mechanism allows a number of common variations that property users may wish
to use if the standard property definition doesn't exactly fit their needs.
For example, if the backing field should be `protected` rather than `private`:

[source,groovy]
----
class HasPropertyWithProtectedField {
    protected String name  // <1>
    String name            // <2>
}
----
<1> Protected backing field for name property instead of normal private one
<2> Declare name property

Or, the same example but with a package-private backing field:

[source,groovy]
----
class HasPropertyWithPackagePrivateField {
    String name                // <1>
    @PackageScope String name  // <2>
}
----
<1> Declare name property
<2> Package-private backing field for name property instead of normal private one

As a final example, we may wish to apply method-related AST transforms,
or in general, any annotation to the setters/getters,
e.g. to have the accessors be synchronized:

[source,groovy]
----
class HasPropertyWithSynchronizedAccessorMethods {
    private String name        // <1>
    @Synchronized String name  // <2>
}
----
<1> Backing field for name property
<2> Declare name property with annotation for setter/getter

===== Explicit accessor methods

The automatic generation of accessor methods doesn't occur if there
is an explicit definition of the getter or setter in the class.
This allows you to modify the normal behavior of such a getter or setter if needed.
Inherited accessor methods aren't normally considered but if an inherited
accessor method is marked final, that will also cause no generation of an
additional accessor method to honor the `final` requirement of no subclassing of such methods.

=== Annotation

[[ann-definition]]
==== Annotation definition

An annotation is a kind of special interface dedicated at annotating elements of the code. An annotation is a type which
superinterface is the jdk:java.lang.annotation.Annotation[Annotation] interface. Annotations are declared in a very
similar way to interfaces, using the `@interface` keyword:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=define_annotation,indent=0]
----

An annotation may define members in the form of methods without bodies and an optional default value. The possible
member types are limited to:

* primitive types
* jdk:java.lang.String[Strings]
* jdk:java.lang.Class[Classes]
* an jdk:java.lang.Enum[enumeration]
* another jdk:java.lang.annotation.Annotation[annotation type]
* or any array of the above

For example:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=ann_member_string,indent=0]
include::../test/ClassTest.groovy[tags=ann_member_string_default,indent=0]
include::../test/ClassTest.groovy[tags=ann_member_int,indent=0]
include::../test/ClassTest.groovy[tags=ann_member_class,indent=0]
include::../test/ClassTest.groovy[tags=ann_member_annotation,indent=0]
include::../test/ClassTest.groovy[tags=ann_member_enum,indent=0]
----
<1> an annotation defining a `value` member of type `String`
<2> an annotation defining a `value` member of type `String` with a default value of `something`
<3> an annotation defining a `step` member of type the primitive type `int`
<4> an annotation defining a `appliesTo` member of type `Class`
<5> an annotation defining a `value` member which type is an array of another annotation type
<6> an annotation defining a `dayOfWeek` member which type is the enumeration type `DayOfWeek`

Unlike in the Java language, in Groovy, an annotation can be used to alter the semantics of the language. It is especially
true of AST transformations which will generate code based on annotations.

[[ann-placement]]
==== Annotation placement

An annotation can be applied on various elements of the code:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=apply_annotation_1,indent=0]
----
<1> `@SomeAnnotation` applies to the `someMethod` method
<2> `@SomeAnnotation` applies to the `SomeClass` class
<3> `@SomeAnnotation` applies to the `var` variable

In order to limit the scope where an annotation can be applied, it is necessary to declare it on the annotation
definition, using the jdk:java.lang.annotation.Target[Target] annotation. For example, here is how you would
declare that an annotation can be applied to a class or a method:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=ann_target,indent=0]
----
<1> the `@Target` annotation is meant to annotate an annotation with a scope.
<2> `@SomeAnnotation` will therefore only be allowed on `TYPE` or `METHOD`

The list of possible targets is available in the jdk:java.lang.annotation.ElementType[ElementType enumeration].

WARNING: Groovy does not support the jdk:java.lang.annotation.ElementType#TYPE_PARAMETER[TYPE_PARAMETER] and
jdk:java.lang.annotation.ElementType#TYPE_PARAMETER[TYPE_USE] element types which were introduced in Java 8.

==== Annotation member values

When an annotation is used, it is required to set at least all members that do not have a default value. For example:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=annotation_value_set,indent=0]
----

However it is possible to omit `value=` in the declaration of the value of an annotation if the member `value` is the
only one being set:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=annotation_value_set_option,indent=0]
----
<1> we can omit the `statusCode` because it has a default value, but `value` needs to be set
<2> since `value` is the only mandatory member without a default, we can omit `value=`
<3> if both `value` and `statusCode` need to be set, it is required to use `value=` for the default `value` member

==== Retention policy

The visibility of an annotation depends on its retention policy. The retention policy of an annotation is set using
the jdk:java.lang.annotation.Retention[Retention] annotation:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=ann_retention,indent=0]
----
<1> the `@Retention` annotation annotates the `@SomeAnnotation` annotation
<2> so `@SomeAnnotation` will have a `SOURCE` retention

The list of possible retention targets and description is available in the
jdk:java.lang.annotation.RetentionPolicy[RetentionPolicy] enumeration. The
choice usually depends on whether you want an annotation to be visible at
compile time or runtime.

==== Closure annotation parameters

An interesting feature of annotations in Groovy is that you can use a closure as an annotation value. Therefore
annotations may be used with a wide variety of expressions and still have IDE support. For example, imagine a
framework where you want to execute some methods based on environmental constraints like the JDK version or the OS.
One could write the following code:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=closure_ann_example,indent=0]
----

For the `@OnlyIf` annotation to accept a `Closure` as an argument, you only have to declare the `value` as a `Class`:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=closure_ann_def,indent=0]
----

To complete the example, let's write a sample runner that would use that information:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=closure_ann_runner,indent=0]
----
<1> create a new instance of the class passed as an argument (the task class)
<2> emulate an environment which is JDK 6 and not Windows
<3> iterate on all declared methods of the task class
<4> if the method is public and takes no-argument
<5> try to find the `@OnlyIf` annotation
<6> if it is found get the `value` and create a new `Closure` out of it
<7> set the `delegate` of the closure to our environment variable
<8> call the closure, which is the annotation closure. It will return a `boolean`
<9> if it is `true`, call the method
<10> if the method is not annotated with `@OnlyIf`, execute the method anyway
<11> after that, return the task object

Then the runner can be used this way:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=closure_ann_runner_exec,indent=0]
----

==== Meta-annotations

===== Declaring meta-annotations

Meta-annotations, also known as annotation aliases are annotations that
are replaced at compile time by other annotations (one meta-annotation
is an alias for one or more annotations). Meta-annotations can be used to
reduce the size of code involving multiple annotations.

Let’s start with a simple example. Imagine you have the `@Service`
and `@Transactional` annotations and that you want to annotate a class
with both:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=transactionalservice_class,indent=0]
----

Given the multiplication of annotations that you could add to the same class, a meta-annotation
could help by reducing the two annotations with a single one having the very same semantics. For example,
we might want to write this instead:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=transactionalservice_class2,indent=0]
----
<1> `@TransactionalService` is a meta-annotation

A meta-annotation is declared as a regular annotation but annotated with `@AnnotationCollector` and the
list of annotations it is collecting. In our case, the `@TransactionalService` annotation can be written:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=metaann_ts,indent=0]
----
<1> annotate the meta-annotation with `@Service`
<2> annotate the meta-annotation with `@Transactional`
<3> annotate the meta-annotation with `@AnnotationCollector`

[[meta-ann-behavior]]
===== Behavior of meta-annotations

Groovy supports both _precompiled_ and _source form_
meta-annotations. This means that your meta-annotation _may_ be
precompiled, or you can have it in the same source tree as the one you
are currently compiling.

INFO: Meta-annotations are a Groovy-only feature. There is
no chance for you to annotate a Java class with a meta-annotation and
hope it will do the same as in Groovy. Likewise, you cannot write a
meta-annotation in Java: both the meta-annotation definition *and* usage
have to be Groovy code. But you can happily collect Java annotations
and Groovy annotations within your meta-annotation.

When the Groovy compiler encounters a class annotated with a
meta-annotation, it *replaces* it with the collected annotations. So,
in our previous example, it will
replace `@TransactionalService` with `@Transactional` and `@Service`:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=annotations_expanded,indent=0]
----

The conversion from a meta-annotation to the collected annotations is performed during the
_semantic analysis_ compilation phase. 

In addition to replacing the alias with the collected annotations, a meta-annotation is capable of
processing them, including arguments.

[[meta-ann-members]]
===== Meta-annotation parameters

Meta-annotations can collect annotations which have parameters. To illustrate this,
we will imagine two annotations, each of them accepting one argument:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=collected_ann_explosive,indent=0]
----

And suppose that you want create a meta-annotation named `@Explosive`:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=collected_ann_explosive,indent=0]
include::../test/ClassTest.groovy[tags=collector_ann_explosive,indent=0]
----

By default, when the annotations are replaced, they will get the
annotation parameter values *as they were defined in the alias*. More interesting,
the meta-annotation supports overriding specific values:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=example_bomb,indent=0]
----
<1> the `after` value provided as a parameter to `@Explosive` overrides the one defined in the `@Timeout` annotation

If two annotations define the same parameter name, the default processor
will copy the annotation value to all annotations that accept this parameter:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=collector_ann_same_values,indent=0]
----
<1> the `@Foo` annotation defines the `value` member of type `String`
<2> the `@Bar` annotation also defines the `value` member of type `String`
<3> the `@FooBar` meta-annotation aggregates `@Foo` and `@Bar`
<4> class `Bob` is annotated with `@Foo` and `@Bar`
<5> the value of the `@Foo` annotation on `Bob` is `a`
<6> while the value of the `@Bar` annotation on `Bob` is `b`
<7> class `Joe` is annotated with `@FooBar`
<8> then the value of the `@Foo` annotation on `Joe` is `a`
<9> and the value of the `@Bar` annotation on `Joe` is also `a`

In the second case, the meta-annotation value was copied in
both `@Foo` and `@Bar` annotations.

WARNING: It is a compile time error if the collected annotations define the same members
with incompatible types. For example if on the previous example `@Foo` defined a value of
type `String` but `@Bar` defined a value of type `int`.

It is however possible to customize the behavior of meta-annotations and describe how collected
annotations are expanded. We'll look at how to do that shortly but first there is an advanced
processing option to cover.

[[handling_duplicate_annotations]]
===== Handling duplicate annotations

The `@AnnotationCollector` annotation supports a `mode` parameter which can be used to
alter how the default processor handles annotation replacement in the presence of
duplicate annotations.

INFO: Custom processors (discussed next) may or may not support this parameter.

As an example, suppose you create a meta-annotation containing the `@ToString` annotation
and then place your meta-annotation on a class that already has an explicit `@ToString`
annotation. Should this be an error? Should both annotations be applied? Does one take
priority over the other? There is no correct answer. In some scenarios it might be
quite appropriate for any of these answers to be correct. So, rather than trying to
preempt one correct way to handle the duplicate annotation issue, Groovy let's you
write your own custom meta-annotation processors (covered next) and let's you write
whatever checking logic you like within AST transforms - which are a frequent target for
aggregating. Having said that, by simply setting the `mode`, a number of commonly
expected scenarios are handled automatically for you within any extra coding.
The behavior of the `mode` parameter is determined by the `AnnotationCollectorMode`
enum value chosen and is summarized in the following table.

|================================
| Mode | Description
| DUPLICATE | Annotations from the annotation collection will always be inserted. After all transforms have been run, it will be an error if multiple annotations (excluding those with SOURCE retention) exist.
| PREFER_COLLECTOR | Annotations from the collector will be added and any existing annotations with the same name will be removed.
| PREFER_COLLECTOR_MERGED | Annotations from the collector will be added and any existing annotations with the same name will be removed but any new parameters found within existing annotations will be merged into the added annotation.
| PREFER_EXPLICIT | Annotations from the collector will be ignored if any existing annotations with the same name are found.
| PREFER_EXPLICIT_MERGED | Annotations from the collector will be ignored if any existing annotations with the same name are found but any new parameters on the collector annotation will be added to existing annotations.
|================================

[[meta-ann-processor]]
===== Custom annotation processors

A custom annotation processor will let you choose how to expand a
meta-annotation into collected annotations. The behaviour of the meta-annotation is,
in this case, totally up to you. To do this, you must:

* create a meta-annotation processor, extending gapi:org.codehaus.groovy.transform.AnnotationCollectorTransform[AnnotationCollectorTransform]
* declare the processor to be used in the meta-annotation declaration

To illustrate this, we are going to explore how the meta-annotation `@CompileDynamic` is implemented.

`@CompileDynamic` is a meta-annotation that expands itself
to `@CompileStatic(TypeCheckingMode.SKIP)`. The problem is that the
default meta annotation processor doesn’t support enums and the
annotation value `TypeCheckingMode.SKIP` is one.

The naive implementation here would not work:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=compiledynamic_naive,indent=0]
----

Instead, we will define it like this:

[source,groovy]
----
include::../test/ClassTest.groovy[tags=compiledynamic_def_fixed,indent=0]
----

The first thing you may notice is that our interface is no longer
annotated with `@CompileStatic`. The reason for this is that we rely on
the `processor` parameter instead, that references a class which
will *generate* the annotation.

Here is how the custom processor is implemented:

[source,groovy]
.CompileDynamicProcessor.groovy
----
include::../test/ClassTest.groovy[tags=compiledynamic_processor,indent=0]
----
<1> our custom processor is written in Groovy, and for better compilation performance, we use static compilation
<2> the custom processor has to extend gapi:org.codehaus.groovy.transform.AnnotationCollectorTransform[AnnotationCollectorTransform]
<3> create a class node representing the `@CompileStatic` annotation type
<4> create a class node representing the `TypeCheckingMode` enum type
<5> `collector` is the `@AnnotationCollector` node found in the meta-annotation. Usually unused.
<6> `aliasAnnotationUsage` is the meta-annotation being expanded, here it is `@CompileDynamic`
<7> `aliasAnnotated` is the node being annotated with the meta-annotation
<8> `sourceUnit` is the `SourceUnit` being compiled
<9> we create a new annotation node for `@CompileStatic`
<10> we create an expression equivalent to `TypeCheckingMode.SKIP`
<11> we add that expression to the annotation node, which is now `@CompileStatic(TypeCheckingMode.SKIP)`
<12> return the generated annotation

In the example, the `visit` method is the only method which has to be overridden. It is meant to return a list of
annotation nodes that will be added to the node annotated with the meta-annotation. In this example, we return a
single one corresponding to `@CompileStatic(TypeCheckingMode.SKIP)`.

[[generics]]
=== Generics

(TBD)


include::_traits.adoc[leveloffset=+1]

",12180,False,2076.939905942678,median
"/* Copyright 2020 Stanford University, NVIDIA Corporation
 *
 * Licensed under the Apache License, Version 2.0 (the ""License"");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an ""AS IS"" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// Layout descriptors for Realm RegionInstances

// NOP but useful for IDE's
#include ""realm/indexspace.h""

namespace Realm {

  // TODO: move to helper include file
  template <typename T, typename T2>
  inline T round_up(T val, T2 step)
  {
    T rem = val % step;
    if(rem == 0)
      return val;
    else
      return val + (step - rem);
  }

  template <typename T>
  inline T max(T a, T b)
  {
    return((a > b) ? a : b);
  }

  template <typename T>
  inline T gcd(T a, T b)
  {
    while(a != b) {
      if(a > b)
	a -= b;
      else
	b -= a;
    }
    return a;
  }

  template <typename T>
  inline T lcm(T a, T b)
  {
    // TODO: more efficient way?
    return(a * b / gcd(a, b));
  }
  

  ////////////////////////////////////////////////////////////////////////
  //
  // class InstanceLayoutGeneric

  inline InstanceLayoutGeneric::InstanceLayoutGeneric(void)
    : bytes_used(0)
    , alignment_reqd(0)
  {}

  template <typename S>
  /*static*/ inline InstanceLayoutGeneric *InstanceLayoutGeneric::deserialize_new(S& deserializer)
  {
    return Serialization::PolymorphicSerdezHelper<InstanceLayoutGeneric>::deserialize_new(deserializer);
  }

  inline InstanceLayoutGeneric::~InstanceLayoutGeneric(void)
  {}

  template <int N, typename T>
  /*static*/ InstanceLayoutGeneric *InstanceLayoutGeneric::choose_instance_layout(IndexSpace<N,T> is,
										  const InstanceLayoutConstraints& ilc,
										  int *dim_order)
  {
    std::vector<Rect<N,T> > piece_bounds;
    if(is.dense()) {
      // dense case is nice and simple
      if(!is.bounds.empty())
	piece_bounds.push_back(is.bounds);
    } else {
      // we need precise data for non-dense index spaces (the original
      //  'bounds' on the IndexSpace is often VERY conservative)
      SparsityMapPublicImpl<N,T> *impl = is.sparsity.impl();
      const std::vector<SparsityMapEntry<N,T> >& entries = impl->get_entries();
      if(!entries.empty()) {
	// TODO: set some sort of threshold for merging entries
	typename std::vector<SparsityMapEntry<N,T> >::const_iterator it = entries.begin();
	Rect<N,T> bbox = is.bounds.intersection(it->bounds);
	while(++it != entries.end())
	  bbox = bbox.union_bbox(is.bounds.intersection(it->bounds));
	if(!bbox.empty())
	  piece_bounds.push_back(bbox);
      }
    }

    return choose_instance_layout<N,T>(is, piece_bounds, ilc, dim_order);
  }

  template <int N, typename T>
  /*static*/ InstanceLayoutGeneric *InstanceLayoutGeneric::choose_instance_layout(IndexSpace<N,T> is,
										  const std::vector<Rect<N,T> >& covering,
										  const InstanceLayoutConstraints& ilc,
										  int* dim_order)
  {
    InstanceLayout<N,T> *layout = new InstanceLayout<N,T>;
    layout->bytes_used = 0;
    // require 32B alignment of each instance piece for vectorizing goodness
    layout->alignment_reqd = 32;
    layout->space = is;

    // if the index space is empty, all fields can use the same empty
    //  piece list
    if(covering.empty()) {
      layout->piece_lists.resize(1);
      for(std::vector<InstanceLayoutConstraints::FieldGroup>::const_iterator it = ilc.field_groups.begin();
	  it != ilc.field_groups.end();
	  ++it)
	for(std::vector<InstanceLayoutConstraints::FieldInfo>::const_iterator it2 = it->begin();
	    it2 != it->end();
	    ++it2) {
	  InstanceLayoutGeneric::FieldLayout& fl = layout->fields[it2->field_id];
	  fl.list_idx = 0;
	  fl.rel_offset = 0;
	  fl.size_in_bytes = it2->size;
	}
      return layout;
    }
    
    // we'll merge piece lists that have the same gsize/galign values, so
    //  track that
    std::map<std::pair<size_t, size_t>, size_t> pl_indexes, pl_starts, pl_sizes;

    // reserve space so that we don't have to copy piece lists as we grow
    layout->piece_lists.reserve(ilc.field_groups.size());
    for(size_t i = 0; i < ilc.field_groups.size(); i++) {
      const InstanceLayoutConstraints::FieldGroup& fg = ilc.field_groups[i];

      // figure out layout of fields in group - this is constant across the
      //  pieces
      size_t gsize = 0;
      size_t galign = 1;
      // we can't set field offsets in a single pass because we don't know
      //  the whole group's alignment until we look at every field
      std::map<FieldID, size_t> field_offsets;
      std::map<FieldID, int> field_sizes;
      for(std::vector<InstanceLayoutConstraints::FieldInfo>::const_iterator it2 = fg.begin();
	  it2 != fg.end();
	  ++it2) {
	size_t offset;
	if(it2->fixed_offset) {
	  offset = it2->offset;
	} else {
	  // if not specified, field goes at the end of all known fields
	  //  (or a bit past if alignment is a concern)
	  offset = gsize;
	  if(it2->alignment > 1)
	    offset = round_up(offset, it2->alignment);
	}
	// increase size and alignment if needed
	gsize = max(gsize, offset + it2->size);
	if((it2->alignment > 1) && ((galign % it2->alignment) != 0))
	  galign = lcm(galign, size_t(it2->alignment));
	field_offsets[it2->field_id] = offset;
	field_sizes[it2->field_id] = it2->size;
      }
      if(galign > 1) {
	// group size needs to be rounded up to match group alignment
	gsize = round_up(gsize, galign);

	// overall instance alignment layout must be compatible with group
	layout->alignment_reqd = lcm(layout->alignment_reqd, galign);
      }

      std::pair<size_t, size_t> pl_key(gsize, galign);
      std::map<std::pair<size_t, size_t>, size_t>::const_iterator it = pl_indexes.find(pl_key);
      size_t li;
      size_t reuse_offset;
      if(it != pl_indexes.end()) {
	li = it->second;
	size_t piece_start = round_up(layout->bytes_used, galign);
	reuse_offset = piece_start - pl_starts[pl_key];

	// we're not going to create piece lists, but we still have to update
	//  the overall size
	layout->bytes_used = piece_start + pl_sizes[pl_key];
      } else {
	li = layout->piece_lists.size();
	layout->piece_lists.resize(li + 1);
	reuse_offset = 0;
	pl_indexes[pl_key] = li;

	// create the piece list
	InstancePieceList<N,T>& pl = layout->piece_lists[li];
	pl.pieces.reserve(covering.size());

	size_t pl_start = round_up(layout->bytes_used, galign);
	for(typename std::vector<Rect<N,T> >::const_iterator it = covering.begin();
	    it != covering.end();
	    ++it) {
	  Rect<N,T> bbox = *it;
	  // TODO: bloat bbox for block size if desired
	  Rect<N,T> bloated = bbox;

	  // always create an affine piece for now
	  AffineLayoutPiece<N,T> *piece = new AffineLayoutPiece<N,T>;
	  piece->bounds = bbox;

	  // starting point for piece is first galign-aligned location above
	  //  existing pieces
	  size_t piece_start = round_up(layout->bytes_used, galign);
	  piece->offset = piece_start;
	  size_t stride = gsize;
	  for(int i = 0; i < N; i++) {
	    const int dim = dim_order[i];
	    assert((0 <= dim) && (dim < N));
	    piece->strides[dim] = stride;
	    piece->offset -= bloated.lo[dim] * stride;
	    stride *= (bloated.hi[dim] - bloated.lo[dim] + 1);
	  }

	  // final value of stride is total bytes used by piece - use that
	  //  to set new instance footprint
	  layout->bytes_used = piece_start + stride;
	  
	  pl.pieces.push_back(piece);
	}
	pl_starts[pl_key] = pl_start;
	pl_sizes[pl_key] = layout->bytes_used - pl_start;
      }
      
      // now that the we know which piece list we are using, we can set the
      //  actual field offsets
      for(std::map<FieldID, size_t>::const_iterator it2 = field_offsets.begin();
	  it2 != field_offsets.end();
	  ++it2) {
	// should not have seen this field before
	assert(layout->fields.count(it2->first) == 0);
	InstanceLayoutGeneric::FieldLayout& fl = layout->fields[it2->first];
	fl.list_idx = li;
	fl.rel_offset = /*group_offset +*/ it2->second + reuse_offset;
	fl.size_in_bytes = field_sizes[it2->first];
      }

    }

    return layout;
  }

  template <typename S>
  inline bool serialize(S& serializer, const InstanceLayoutGeneric& ilg)
  {
    return Serialization::PolymorphicSerdezHelper<InstanceLayoutGeneric>::serialize(serializer, ilg);
  }

  inline std::ostream& operator<<(std::ostream& os, const InstanceLayoutGeneric& ilg)
  {
    ilg.print(os);
    return os;
  }


  ////////////////////////////////////////////////////////////////////////
  //
  // class InstanceLayoutPiece<N,T>

  template <int N, typename T>
  inline InstanceLayoutPiece<N,T>::InstanceLayoutPiece(void)
    : layout_type(PieceLayoutTypes::InvalidLayoutType)
  {}

  template <int N, typename T>
  inline InstanceLayoutPiece<N,T>::InstanceLayoutPiece(PieceLayoutTypes::LayoutType _layout_type)
    : layout_type(_layout_type)
  {}

  template <int N, typename T>
  inline InstanceLayoutPiece<N,T>::InstanceLayoutPiece(PieceLayoutTypes::LayoutType _layout_type,
						       const Rect<N,T>& _bounds)
    : layout_type(_layout_type)
    , bounds(_bounds)
  {}

  template <int N, typename T>
  template <typename S>
  /*static*/ inline InstanceLayoutPiece<N,T> *InstanceLayoutPiece<N,T>::deserialize_new(S& deserializer)
  {
    return Serialization::PolymorphicSerdezHelper<InstanceLayoutPiece<N,T> >::deserialize_new(deserializer);
  }

  template <int N, typename T>
  inline InstanceLayoutPiece<N,T>::~InstanceLayoutPiece(void)
  {}

  template <int N, typename T, typename S>
  inline bool serialize(S& serializer, const InstanceLayoutPiece<N,T>& ilp)
  {
    return Serialization::PolymorphicSerdezHelper<InstanceLayoutPiece<N,T> >::serialize(serializer, ilp);
  }

  template <int N, typename T>
  inline std::ostream& operator<<(std::ostream& os, const InstanceLayoutPiece<N,T>& ilp)
  {
    ilp.print(os);
    return os;
  }


  ////////////////////////////////////////////////////////////////////////
  //
  // class AffineLayoutPiece<N,T>

  template <int N, typename T>
  inline AffineLayoutPiece<N,T>::AffineLayoutPiece(void)
    : InstanceLayoutPiece<N,T>(PieceLayoutTypes::AffineLayoutType)
  {}

  template <int N, typename T>
  template <typename S>
  /*static*/ inline InstanceLayoutPiece<N,T> *AffineLayoutPiece<N,T>::deserialize_new(S& s)
  {
    AffineLayoutPiece<N,T> *alp = new AffineLayoutPiece<N,T>;
    if((s >> alp->bounds) &&
       (s >> alp->strides) &&
       (s >> alp->offset)) {
      return alp;
    } else {
      delete alp;
      return 0;
    }
  }

  template <int N, typename T>
  inline InstanceLayoutPiece<N,T> *AffineLayoutPiece<N,T>::clone(void) const
  {
    AffineLayoutPiece<N,T> *copy = new AffineLayoutPiece<N,T>;
    copy->bounds = this->bounds;
    copy->strides = this->strides;
    copy->offset = this->offset;
    return copy;
  }

  template <int N, typename T>
  inline size_t AffineLayoutPiece<N,T>::calculate_offset(const Point<N,T>& p) const
  {
    return offset + strides.dot(p);
  }

  template <int N, typename T>
  inline void AffineLayoutPiece<N,T>::relocate(size_t base_offset)
  {
    offset += base_offset;
  }

  template <int N, typename T>
  void AffineLayoutPiece<N,T>::print(std::ostream& os) const
  {
    os << this->bounds << ""->affine("" << strides << ""+"" << offset << "")"";
  }

  template <int N, typename T>
  size_t AffineLayoutPiece<N,T>::lookup_inst_size() const
  {
    return sizeof(PieceLookup::AffinePiece<N,T>);
  }

  template <int N, typename T>
  PieceLookup::Instruction *AffineLayoutPiece<N,T>::create_lookup_inst(void *ptr, unsigned next_delta) const
  {
    PieceLookup::AffinePiece<N,T> *ap = new(ptr) PieceLookup::AffinePiece<N,T>(next_delta);
    ap->bounds = this->bounds;
    ap->base = offset;
    ap->strides = strides;
    return ap;
  }

  template <int N, typename T>
  template <typename S>
  inline bool AffineLayoutPiece<N,T>::serialize(S& s) const
  {
    return ((s << this->bounds) &&
	    (s << strides) &&
	    (s << offset));
  }


  ////////////////////////////////////////////////////////////////////////
  //
  // class InstancePieceList<N,T>

  template <int N, typename T>
  inline InstancePieceList<N,T>::InstancePieceList(void)
  {}

  template <int N, typename T>
  inline InstancePieceList<N,T>::~InstancePieceList(void)
  {
    for(typename std::vector<InstanceLayoutPiece<N,T> *>::const_iterator it = pieces.begin();
	it != pieces.end();
	++it)
      delete *it;
  }

  template <int N, typename T>
  inline const InstanceLayoutPiece<N,T> *InstancePieceList<N,T>::find_piece(Point<N,T> p) const
  {
    for(typename std::vector<InstanceLayoutPiece<N,T> *>::const_iterator it = pieces.begin();
	it != pieces.end();
	++it)
      if((*it)->bounds.contains(p))
	return *it;
    return 0;
  }

  template <int N, typename T>
  inline void InstancePieceList<N,T>::relocate(size_t base_offset)
  {
    for(typename std::vector<InstanceLayoutPiece<N,T> *>::const_iterator it = pieces.begin();
	it != pieces.end();
	++it)
      (*it)->relocate(base_offset);
  }

  template <int N, typename T, typename S>
  inline bool serialize(S& s, const InstancePieceList<N,T>& ipl)
  {
    return ipl.serialize(s);
  }

  template <int N, typename T, typename S>
  inline bool deserialize(S& s, InstancePieceList<N,T>& ipl)
  {
    return ipl.deserialize(s);
  }

  template <int N, typename T>
  template <typename S>
  inline bool InstancePieceList<N,T>::serialize(S& s) const
  {
    size_t len = pieces.size();
    if(!(s << len)) return false;
    for(size_t i = 0; i < len; i++)
      if(!(s << *(pieces[i]))) return false;
    return true;
  }
    
  template <int N, typename T>
  template <typename S>
  inline bool InstancePieceList<N,T>::deserialize(S& s)
  {
    size_t len;
    if(!(s >> len)) return false;
    pieces.resize(len);
    for(size_t i = 0; i < len; i++) {
      InstanceLayoutPiece<N,T> *ilp = InstanceLayoutPiece<N,T>::deserialize_new(s);
      if(!ilp)
	return false;
      pieces[i] = ilp;
    }
    return true;
  }

  template <int N, typename T>
  inline std::ostream& operator<<(std::ostream& os, const InstancePieceList<N,T>& ipl)
  {
    os << '[';
    bool first = true;
    for(typename std::vector<InstanceLayoutPiece<N,T> *>::const_iterator it = ipl.pieces.begin();
	it != ipl.pieces.end();
	++it) {
      if(!first) os << "", "";
      first = false;
      os << *(*it);
    }
    os << ']';
    return os;
  }


  ////////////////////////////////////////////////////////////////////////
  //
  // class InstanceLayout<N,T>

  template <int N, typename T>
  inline InstanceLayout<N,T>::InstanceLayout(void)
  {}

  template <int N, typename T>
  template <typename S>
  /*static*/ InstanceLayoutGeneric *InstanceLayout<N,T>::deserialize_new(S& s)
  {
    InstanceLayout<N,T> *il = new InstanceLayout<N,T>;
    if((s >> il->bytes_used) &&
       (s >> il->alignment_reqd) &&
       (s >> il->fields) &&
       (s >> il->space) &&
       (s >> il->piece_lists)) {
      return il;
    } else {
      delete il;
      return 0;
    }
  }

  template <int N, typename T>
  InstanceLayout<N,T>::~InstanceLayout(void)
  {}

  template <int N, typename T>
  InstanceLayoutGeneric *InstanceLayout<N,T>::clone(void) const
  {
    InstanceLayout<N,T> *copy = new InstanceLayout<N,T>;
    copy->bytes_used = bytes_used;
    copy->alignment_reqd = alignment_reqd;
    copy->fields = fields;
    copy->space = space;
    copy->piece_lists.resize(piece_lists.size());
    for(size_t i = 0; i < piece_lists.size(); i++) {
      copy->piece_lists[i].pieces.resize(piece_lists[i].pieces.size());
      for(size_t j = 0; j < piece_lists[i].pieces.size(); j++)
	copy->piece_lists[i].pieces[j] = piece_lists[i].pieces[j]->clone();
    }
    return copy;
  }

  // adjusts offsets of pieces to start from 'base_offset'
  template <int N, typename T>
  void InstanceLayout<N,T>::relocate(size_t base_offset)
  {
    for(typename std::vector<InstancePieceList<N,T> >::iterator it = piece_lists.begin();
	it != piece_lists.end();
	++it)
      it->relocate(base_offset);
  }

  template <int N, typename T>
  void InstanceLayout<N,T>::print(std::ostream& os) const
  {
    os << ""Layout(bytes="" << bytes_used << "", align="" << alignment_reqd
       << "", fields={"";
    bool first = true;
    for(std::map<FieldID, FieldLayout>::const_iterator it = fields.begin();
	it != fields.end();
	++it) {
      if(!first) os << "", "";
      first = false;
      os << it->first << ""="" << it->second.list_idx << ""+"" << it->second.rel_offset;
    }
    os << ""}, lists=["";
    {
      bool first = true;
      for(typename std::vector<InstancePieceList<N,T> >::const_iterator it = piece_lists.begin();
	  it != piece_lists.end();
	  ++it) {
	if(!first) os << "", "";
	first = false;
	os << *it;
      }
    }
    os << ""])"";
  }

  // computes the offset of the specified field for an element - this
  //  is generally much less efficient than using a layout-specific accessor
  template <int N, typename T>
  inline size_t InstanceLayout<N,T>::calculate_offset(Point<N,T> p, FieldID fid) const
  {
    // first look up the field to see which piece list it uses (and get offset)
    std::map<FieldID, InstanceLayoutGeneric::FieldLayout>::const_iterator it = fields.find(fid);
    assert(it != fields.end());

    const InstanceLayoutPiece<N,T> *ilp = piece_lists[it->second.list_idx].find_piece(p);
    assert(ilp != 0);
    size_t offset = ilp->calculate_offset(p);
    // add in field's offset
    offset += it->second.rel_offset;
    return offset;
  }

  template <int N, typename T>
  template <typename S>
  inline bool InstanceLayout<N,T>::serialize(S& s) const
  {
    return ((s << bytes_used) &&
	    (s << alignment_reqd) &&
	    (s << fields) &&
	    (s << space) &&
	    (s << piece_lists));
  }
      

  ////////////////////////////////////////////////////////////////////////
  //
  // class AccessorRefHelper<FT>

  template <typename FT>
  inline AccessorRefHelper<FT>::AccessorRefHelper(RegionInstance _inst,
						  size_t _offset)
    : inst(_inst)
    , offset(_offset)
  {}

  // ""read""
  template <typename FT>
  inline AccessorRefHelper<FT>::operator FT(void) const
  {
    FT val;
    inst.read_untyped(offset, &val, sizeof(FT));
    return val;
  }

  // ""write""
  template <typename FT>
  inline AccessorRefHelper<FT>& AccessorRefHelper<FT>::operator=(const FT& newval)
  {
    inst.write_untyped(offset, &newval, sizeof(FT));
    return *this;
  }

  template <typename FT>
  inline AccessorRefHelper<FT>& AccessorRefHelper<FT>::operator=(
                                  const AccessorRefHelper<FT>& rhs)
  {
    const FT newval = rhs; 
    inst.write_untyped(offset, &newval, sizeof(FT));
    return *this;
  }

  template <typename FT>
  inline std::ostream& operator<<(std::ostream& os, const AccessorRefHelper<FT>& arh)
  {
    FT val;
    arh.inst.read_untyped(arh.offset, &val, sizeof(FT));
    os << val;
    return os;
  }


  namespace PieceLookup {

    ////////////////////////////////////////////////////////////////////////
    //
    // class PieceLookup::Instruction

    inline Instruction::Instruction(uint32_t _data)
      : data(_data)
    {}

    
    inline Opcodes::Opcode Instruction::opcode() const
    {
      return static_cast<Opcodes::Opcode>(data & 0xff);
    }

    
    inline const Instruction *Instruction::skip(size_t bytes) const
    {
      unsigned delta = (bytes + 15) >> 4;
      return this->jump(delta);
    }

    
    inline const Instruction *Instruction::jump(unsigned delta) const
    {
      return reinterpret_cast<const Instruction *>(reinterpret_cast<uintptr_t>(this) +
						   (delta << 4));
    }


    ////////////////////////////////////////////////////////////////////////
    //
    // class PieceLookup::AffinePiece<N,T>

    template <int N, typename T>
    AffinePiece<N,T>::AffinePiece(unsigned next_delta)
      : Instruction(PieceLookup::Opcodes::OP_AFFINE_PIECE + (next_delta << 8))
    {}

    template <int N, typename T>
    
    unsigned AffinePiece<N,T>::delta() const
    {
      return (data >> 8);
    }

    template <int N, typename T>
    
    const Instruction *AffinePiece<N,T>::next() const
    {
      return this->skip(sizeof(AffinePiece<N,T>));
    }


    ////////////////////////////////////////////////////////////////////////
    //
    // class PieceLookup::SplitPlane<N,T>

    template <int N, typename T>
    SplitPlane<N,T>::SplitPlane(int _split_dim, T _split_plane,
				unsigned _next_delta)
      : Instruction(Opcodes::OP_SPLIT1 +
		    (_split_dim << 8) +
		    (_next_delta << 16))
      , split_plane(_split_plane)
    {}

    template <int N, typename T>
    void SplitPlane<N,T>::set_delta(unsigned _next_delta)
    {
      this->data = ((this->data & 0xffff) +
		    (_next_delta << 16));
    }

    template <int N, typename T>
    
    unsigned SplitPlane<N,T>::delta() const
    {
      return (data >> 16);
    }

    template <int N, typename T>
    
    int SplitPlane<N,T>::split_dim() const
    {
      return (data >> 8) & 0xff;
    }

    template <int N, typename T>
    
    const Instruction *SplitPlane<N,T>::next(const Point<N,T>& p) const
    {
      if(p[this->split_dim()] < split_plane)
	return this->skip(sizeof(SplitPlane<N,T>));
      else
	return this->jump(this->delta());
    }

    template <int N, typename T>
    
    bool SplitPlane<N,T>::splits_rect(const Rect<N,T>& r) const
    {
      return ((r.lo[this->split_dim()] < split_plane) &&
	      (r.hi[this->split_dim()] >= split_plane));
    }


  };


  ////////////////////////////////////////////////////////////////////////
  //
  // class GenericAccessor<FT,N,T>

  template <typename FT, int N, typename T>
  inline GenericAccessor<FT,N,T>::GenericAccessor(void)
    : inst(RegionInstance::NO_INST)
    , piece_list(0)
    , rel_offset(0)
    , prev_piece(0)
  {}

  // GenericAccessor constructors always work, but the is_compatible(...)
  //  calls are still available for templated code

  // implicitly tries to cover the entire instance's domain
  template <typename FT, int N, typename T>
  inline GenericAccessor<FT,N,T>::GenericAccessor(RegionInstance inst,
						  FieldID field_id,
						  size_t subfield_offset /*= 0*/)
  {
    this->inst = inst;

    // find the right piece list for our field
    const InstanceLayout<N,T> *layout = checked_cast<const InstanceLayout<N,T> *>(inst.get_layout());
    std::map<FieldID, InstanceLayoutGeneric::FieldLayout>::const_iterator it = layout->fields.find(field_id);
    assert(it != layout->fields.end());

    this->piece_list = &layout->piece_lists[it->second.list_idx];
    this->rel_offset = it->second.rel_offset + subfield_offset;
    this->prev_piece = 0;
  }

  // limits domain to a subrectangle (doesn't matter for generic accessor)
  template <typename FT, int N, typename T>
  inline GenericAccessor<FT,N,T>::GenericAccessor(RegionInstance inst,
						  FieldID field_id,
						  const Rect<N,T>& subrect,
						  size_t subfield_offset /*= 0*/)
  {
    this->inst = inst;

    // find the right piece list for our field
    const InstanceLayout<N,T> *layout = checked_cast<const InstanceLayout<N,T> *>(inst.get_layout());
    std::map<FieldID, InstanceLayoutGeneric::FieldLayout>::const_iterator it = layout->fields.find(field_id);
    assert(it != layout->fields.end());

    this->piece_list = &layout->piece_lists[it->second.list_idx];
    this->rel_offset = it->second.rel_offset + subfield_offset;
    this->prev_piece = 0;
  }

  template <typename FT, int N, typename T>
  inline GenericAccessor<FT,N,T>::~GenericAccessor(void)
  {}

  template <typename FT, int N, typename T>
  inline /*static*/ bool GenericAccessor<FT,N,T>::is_compatible(RegionInstance inst,
								size_t field_offset)
  {
    return true;
  }

  template <typename FT, int N, typename T>
  inline /*static*/ bool GenericAccessor<FT,N,T>::is_compatible(RegionInstance inst,
								size_t field_offset,
								const Rect<N,T>& subrect)
  {
    return true;
  }

  template <typename FT, int N, typename T>
  template <typename INST>
  inline /*static*/ bool GenericAccessor<FT,N,T>::is_compatible(const INST &instance,
								unsigned field_id)
  {
    return true;
  }

  template <typename FT, int N, typename T>
  template <typename INST>
  inline /*static*/ bool GenericAccessor<FT,N,T>::is_compatible(const INST &instance,
								unsigned field_id,
								const Rect<N,T>& subrect)
  {
    return true;
  }

  template <typename FT, int N, typename T>
  inline FT GenericAccessor<FT,N,T>::read(const Point<N,T>& p)
  {
    size_t offset = this->get_offset(p);
    FT val;
    inst.read_untyped(offset, &val, sizeof(FT));
    return val;
  }

  template <typename FT, int N, typename T>
  inline void GenericAccessor<FT,N,T>::write(const Point<N,T>& p, FT newval)
  {
    size_t offset = this->get_offset(p);
    inst.write_untyped(offset, &newval, sizeof(FT));
  }

  // this returns a ""reference"" that knows how to do a read via operator FT
  //  or a write via operator=
  template <typename FT, int N, typename T>
  inline AccessorRefHelper<FT> GenericAccessor<FT,N,T>::operator[](const Point<N,T>& p)
  {
    size_t offset = this->get_offset(p);
    return AccessorRefHelper<FT>(inst, offset);
  }

  // not a const method because of the piece caching
  template <typename FT, int N, typename T>
  inline size_t GenericAccessor<FT,N,T>::get_offset(const Point<N,T>& p)
  {
    const InstanceLayoutPiece<N,T> *mypiece = prev_piece;
    if(!mypiece || !mypiece->bounds.contains(p)) {
      mypiece = piece_list->find_piece(p);
      assert(mypiece);
      prev_piece = mypiece;
    }
    size_t offset = mypiece->calculate_offset(p);
    // add in field (or subfield) adjustment
    offset += rel_offset;
    return offset;
  }

  template <typename FT, int N, typename T>
  inline std::ostream& operator<<(std::ostream& os, const GenericAccessor<FT,N,T>& a)
  {
    os << ""GenericAccessor{ offset="" << a.rel_offset << "" list="" << *a.piece_list << "" }"";
    return os;
  }


  ////////////////////////////////////////////////////////////////////////
  //
  // class AffineAccessor<FT,N,T>

  template <typename FT, int N, typename T>
  
  inline AffineAccessor<FT,N,T>::AffineAccessor(void)
  {}  

  template <typename FT, int N, typename T>
  
  inline void AffineAccessor<FT,N,T>::reset()
  {
    base = 0;
  }

  // NOTE: these constructors will die horribly if the conversion is not
  //  allowed - call is_compatible(...) first if you're not sure

  // implicitly tries to cover the entire instance's domain
  template <typename FT, int N, typename T>
  inline AffineAccessor<FT,N,T>::AffineAccessor(RegionInstance inst,
						FieldID field_id,
						size_t subfield_offset /*= 0*/)
  {
    reset(inst, field_id, subfield_offset);
  }
    
  template <typename FT, int N, typename T>
  inline void AffineAccessor<FT,N,T>::reset(RegionInstance inst,
					    FieldID field_id,
					    size_t subfield_offset /*= 0*/)
  {
    const InstanceLayout<N,T> *layout = checked_cast<const InstanceLayout<N,T> *>(inst.get_layout());
    std::map<FieldID, InstanceLayoutGeneric::FieldLayout>::const_iterator it = layout->fields.find(field_id);
    assert(it != layout->fields.end());
    const InstancePieceList<N,T>& ipl = layout->piece_lists[it->second.list_idx];
    
    // Special case for empty instances
    if(ipl.pieces.empty()) {
      base = 0;
      for(int i = 0; i < N; i++) strides[i] = 0;
      return;
    }

    // this constructor only works if there's exactly one piece and it's affine
    assert(ipl.pieces.size() == 1);
    const InstanceLayoutPiece<N,T> *ilp = ipl.pieces[0];
    assert((ilp->layout_type == PieceLayoutTypes::AffineLayoutType));
    const AffineLayoutPiece<N,T> *alp = static_cast<const AffineLayoutPiece<N,T> *>(ilp);
    base = reinterpret_cast<uintptr_t>(inst.pointer_untyped(0,
							    layout->bytes_used));
    assert(base != 0);
    base += alp->offset + it->second.rel_offset + subfield_offset;
    strides = alp->strides;
#if defined(REALM_ACCESSOR_DEBUG) || defined(REALM_USE_KOKKOS)
    bounds = alp->bounds;
#endif
#ifdef REALM_USE_KOKKOS
    bounds_specified = false;
#endif
#ifdef REALM_ACCESSOR_DEBUG
    dbg_inst = inst;
#endif
  }

  // limits domain to a subrectangle
  template <typename FT, int N, typename T>
  AffineAccessor<FT,N,T>::AffineAccessor(RegionInstance inst,
					 FieldID field_id, const Rect<N,T>& subrect,
					 size_t subfield_offset /*= 0*/)
  {
    reset(inst, field_id, subrect, subfield_offset);
  }
  
  template <typename FT, int N, typename T>
  void AffineAccessor<FT,N,T>::reset(RegionInstance inst,
				     FieldID field_id, const Rect<N,T>& subrect,
				     size_t subfield_offset /*= 0*/)
  {
    const InstanceLayout<N,T> *layout = checked_cast<const InstanceLayout<N,T> *>(inst.get_layout());
    std::map<FieldID, InstanceLayoutGeneric::FieldLayout>::const_iterator it = layout->fields.find(field_id);
    assert(it != layout->fields.end());
    const InstancePieceList<N,T>& ipl = layout->piece_lists[it->second.list_idx];

    // special case for empty regions
    if(subrect.empty()) {
      base = 0;
      for(int i = 0; i < N; i++) strides[i] = 0;
    } else {
      // find the piece that holds the lo corner of the subrect and insist it
      //  exists, covers the whole subrect, and is affine
      const InstanceLayoutPiece<N,T> *ilp = ipl.find_piece(subrect.lo);
      assert(ilp && ilp->bounds.contains(subrect));
      assert((ilp->layout_type == PieceLayoutTypes::AffineLayoutType));
      const AffineLayoutPiece<N,T> *alp = static_cast<const AffineLayoutPiece<N,T> *>(ilp);
      base = reinterpret_cast<uintptr_t>(inst.pointer_untyped(0,
							      layout->bytes_used));
      assert(base != 0);
      base += alp->offset + it->second.rel_offset + subfield_offset;
      strides = alp->strides;
    }
#if defined(REALM_ACCESSOR_DEBUG) || defined(REALM_USE_KOKKOS)
    bounds = subrect;  // stay inside the subrect we were given
#endif
#ifdef REALM_USE_KOKKOS
    bounds_specified = true;
#endif
#ifdef REALM_ACCESSOR_DEBUG
    dbg_inst = inst;
#endif
  }

  // these two constructors build accessors that incorporate an
  //  affine coordinate transform before the lookup in the actual instance
  template <typename FT, int N, typename T>
  template <int N2, typename T2>
  inline AffineAccessor<FT,N,T>::AffineAccessor(RegionInstance inst,
						const Matrix<N2, N, T2>& transform,
						const Point<N2, T2>& offset,
						FieldID field_id,
						size_t subfield_offset /*= 0*/)
  {
    reset(inst, transform, offset, field_id, subfield_offset);
  }
  
  template <typename FT, int N, typename T>
  template <int N2, typename T2>
  inline void AffineAccessor<FT,N,T>::reset(RegionInstance inst,
					    const Matrix<N2, N, T2>& transform,
					    const Point<N2, T2>& offset,
					    FieldID field_id,
					    size_t subfield_offset /*= 0*/)
  {
    // instance's dimensionality should be <N2,T2>
    const InstanceLayout<N2,T2> *layout = checked_cast<const InstanceLayout<N2,T2> *>(inst.get_layout());
    std::map<FieldID, InstanceLayoutGeneric::FieldLayout>::const_iterator it = layout->fields.find(field_id);
    assert(it != layout->fields.end());
    const InstancePieceList<N2,T2>& ipl = layout->piece_lists[it->second.list_idx];
    
    // Special case for empty instances
    if(ipl.pieces.empty()) {
      base = 0;
      for(int i = 0; i < N; i++) strides[i] = 0;
      return;
    }

    // this constructor only works if there's exactly one piece and it's affine
    assert(ipl.pieces.size() == 1);
    const InstanceLayoutPiece<N2,T2> *ilp = ipl.pieces[0];
    assert((ilp->layout_type == PieceLayoutTypes::AffineLayoutType));
    const AffineLayoutPiece<N2,T2> *alp = static_cast<const AffineLayoutPiece<N2,T2> *>(ilp);
    base = reinterpret_cast<uintptr_t>(inst.pointer_untyped(0,
							    layout->bytes_used));
    assert(base != 0);
    base += alp->offset + it->second.rel_offset + subfield_offset;
    // to get the effect of transforming every accessed x to Ax+b, we
    //  add strides.b to the offset and left-multiply s'*A to get strides
    //  that go directly from the view's space to the element's offset
    //  in the instance
    base += alp->strides.dot(offset);
    for(int i = 0; i < N; i++) {
      strides[i] = 0;
      for(int j = 0; j < N2; j++)
	strides[i] += alp->strides[j] * transform.rows[j][i];
    }
#if defined(REALM_ACCESSOR_DEBUG) || defined(REALM_USE_KOKKOS)
    // can't determine bounds here...
    for(int i = 0; i < N; i++)
      bounds.lo[i] = bounds.hi[i] = 0;
#endif
#ifdef REALM_ACCESSOR_DEBUG
    dbg_inst = inst;
#endif
  }

  // note that the subrect here is in in the accessor's indexspace
  //  (from which the corresponding subrectangle in the instance can be
  //  easily determined)
  template <typename FT, int N, typename T>
  template <int N2, typename T2>
  inline AffineAccessor<FT,N,T>::AffineAccessor(RegionInstance inst,
						const Matrix<N2, N, T2>& transform,
						const Point<N2, T2>& offset,
						FieldID field_id,
						const Rect<N,T>& subrect,
						size_t subfield_offset /*= 0*/)
  {
    reset(inst, transform, offset, field_id, subrect, subfield_offset);
  }
  
  template <typename FT, int N, typename T>
  template <int N2, typename T2>
  inline void AffineAccessor<FT,N,T>::reset(RegionInstance inst,
					    const Matrix<N2, N, T2>& transform,
					    const Point<N2, T2>& offset,
					    FieldID field_id,
					    const Rect<N,T>& subrect,
					    size_t subfield_offset /*= 0*/)
  {
    // instance's dimensionality should be <N2,T2>
    const InstanceLayout<N2,T2> *layout = checked_cast<const InstanceLayout<N2,T2> *>(inst.get_layout());
    std::map<FieldID, InstanceLayoutGeneric::FieldLayout>::const_iterator it = layout->fields.find(field_id);
    assert(it != layout->fields.end());
    const InstancePieceList<N2,T2>& ipl = layout->piece_lists[it->second.list_idx];

    // special case for empty regions
    if(subrect.empty()) {
      base = 0;
      for(int i = 0; i < N; i++) strides[i] = 0;
    } else {
      // if the subrect isn't empty, compute the bounding box of the image
      //  of the subrectangle through the transform - this is a bit ugly
      //  to account for negative elements in the matrix
      Rect<N2,T2> subrect_image(offset, offset);
      for(int i = 0; i < N2; i++)
	for(int j = 0; j < N; j++) {
	  T2 e = transform.rows[i][j];
	  if(e > 0) {
	    subrect_image.lo[i] += e * subrect.lo[j];
	    subrect_image.hi[i] += e * subrect.hi[j];
	  }
	  if(e < 0) {
	    subrect_image.lo[i] += e * subrect.hi[j];
	    subrect_image.hi[i] += e * subrect.lo[j];
	  }
	}
    
      // find the piece that holds the lo corner of the subrect and insist it
      //  exists, covers the whole subrect, and is affine
      const InstanceLayoutPiece<N2,T2> *ilp = ipl.find_piece(subrect_image.lo);
      assert(ilp && ilp->bounds.contains(subrect_image));
      assert((ilp->layout_type == PieceLayoutTypes::AffineLayoutType));
      const AffineLayoutPiece<N2,T2> *alp = static_cast<const AffineLayoutPiece<N2,T2> *>(ilp);
      base = reinterpret_cast<uintptr_t>(inst.pointer_untyped(0,
							      layout->bytes_used));
      assert(base != 0);
      base += alp->offset + it->second.rel_offset + subfield_offset;
      // to get the effect of transforming every accessed x to Ax+b, we
      //  add strides.b to the offset and left-multiply s'*A to get strides
      //  that go directly from the view's space to the element's offset
      //  in the instance
      base += alp->strides.dot(offset);
      for(int i = 0; i < N; i++) {
	strides[i] = 0;
	for(int j = 0; j < N2; j++)
	  strides[i] += alp->strides[j] * transform.rows[j][i];
      }
    }
#if defined(REALM_ACCESSOR_DEBUG) || defined(REALM_USE_KOKKOS)
    bounds = subrect;  // stay inside the subrect we were given
#endif
#ifdef REALM_USE_KOKKOS
    bounds_specified = true;
#endif
#ifdef REALM_ACCESSOR_DEBUG
    dbg_inst = inst;
#endif
  }

  template <typename FT, int N, typename T>
  
  inline AffineAccessor<FT,N,T>::~AffineAccessor(void)
  {}

  template <typename FT, int N, typename T>
  inline /*static*/ bool AffineAccessor<FT,N,T>::is_compatible(RegionInstance inst, FieldID field_id)
  {
    const InstanceLayout<N,T> *layout = checked_cast<const InstanceLayout<N,T> *>(inst.get_layout());
    std::map<FieldID, InstanceLayoutGeneric::FieldLayout>::const_iterator it = layout->fields.find(field_id);
    if(it == layout->fields.end())
      return false;
    const InstancePieceList<N,T>& ipl = layout->piece_lists[it->second.list_idx];
    
    // this constructor only works if there's exactly one piece and it's affine
    if(ipl.pieces.size() != 1)
      return false;
    const InstanceLayoutPiece<N,T> *ilp = ipl.pieces[0];
    if(ilp->layout_type != PieceLayoutTypes::AffineLayoutType)
      return false;
    void *base = inst.pointer_untyped(0, layout->bytes_used);
    if(base == 0)
      return false;

    // all checks passed!
    return true;
  }

  template <typename FT, int N, typename T>
  inline /*static*/ bool AffineAccessor<FT,N,T>::is_compatible(RegionInstance inst, FieldID field_id, const Rect<N,T>& subrect)
  {
    const InstanceLayout<N,T> *layout = checked_cast<const InstanceLayout<N,T> *>(inst.get_layout());
    std::map<FieldID, InstanceLayoutGeneric::FieldLayout>::const_iterator it = layout->fields.find(field_id);
    if(it == layout->fields.end())
      return false;
    const InstancePieceList<N,T>& ipl = layout->piece_lists[it->second.list_idx];

    // as long as we had the right field, we're always compatible with an
    //  empty subrect
    if(subrect.empty())
      return true;
    
    // find the piece that holds the lo corner of the subrect and insist it
    //  exists, covers the whole subrect, and is affine
    const InstanceLayoutPiece<N,T> *ilp = ipl.find_piece(subrect.lo);
    if(!(ilp && ilp->bounds.contains(subrect)))
      return false;
    if(ilp->layout_type != PieceLayoutTypes::AffineLayoutType)
      return false;
    void *base = inst.pointer_untyped(0, layout->bytes_used);
    if(base == 0)
      return false;

    // all checks passed!
    return true;
  }

  template <typename FT, int N, typename T>
  template <int N2, typename T2>
  inline /*static*/ bool AffineAccessor<FT,N,T>::is_compatible(RegionInstance inst,
							       const Matrix<N2, N, T2>& transform,
							       const Point<N2, T2>& offset,
							       FieldID field_id)
  {
    // instance's dimensionality should be <N2,T2>
    const InstanceLayout<N2,T2> *layout = checked_cast<const InstanceLayout<N2,T2> *>(inst.get_layout());
    std::map<FieldID, InstanceLayoutGeneric::FieldLayout>::const_iterator it = layout->fields.find(field_id);
    if(it == layout->fields.end())
      return false;
    const InstancePieceList<N2,T2>& ipl = layout->piece_lists[it->second.list_idx];
    
    // this constructor only works if there's exactly one piece and it's affine
    if(ipl.pieces.size() != 1)
      return false;
    const InstanceLayoutPiece<N2,T2> *ilp = ipl.pieces[0];
    if(ilp->layout_type != PieceLayoutTypes::AffineLayoutType)
      return false;
    void *base = inst.pointer_untyped(0, layout->bytes_used);
    if(base == 0)
      return false;

    // all checks passed!
    return true;
  }

  template <typename FT, int N, typename T>
  template <int N2, typename T2>
  inline /*static*/ bool AffineAccessor<FT,N,T>::is_compatible(RegionInstance inst,
							       const Matrix<N2, N, T2>& transform,
							       const Point<N2, T2>& offset,
							       FieldID field_id, const Rect<N,T>& subrect)
  {
    // instance's dimensionality should be <N2,T2>
    const InstanceLayout<N2,T2> *layout = checked_cast<const InstanceLayout<N2,T2> *>(inst.get_layout());
    std::map<FieldID, InstanceLayoutGeneric::FieldLayout>::const_iterator it = layout->fields.find(field_id);
    if(it == layout->fields.end())
      return false;
    const InstancePieceList<N2,T2>& ipl = layout->piece_lists[it->second.list_idx];

    // as long as we had the right field, we're always compatible with an
    //  empty subrect
    if(subrect.empty())
      return true;

    // if the subrect isn't empty, compute the bounding box of the image
    //  of the subrectangle through the transform - this is a bit ugly
    //  to account for negative elements in the matrix
    Rect<N2,T2> subrect_image(offset, offset);
    for(int i = 0; i < N2; i++)
      for(int j = 0; j < N; j++) {
	T2 e = transform.rows[i][j];
	if(e > 0) {
	  subrect_image.lo[i] += e * subrect.lo[j];
	  subrect_image.hi[i] += e * subrect.hi[j];
	}
	if(e < 0) {
	  subrect_image.lo[i] += e * subrect.hi[j];
	  subrect_image.hi[i] += e * subrect.lo[j];
	}
      }
    
    // find the piece that holds the lo corner of the subrect and insist it
    //  exists, covers the whole subrect, and is affine
    const InstanceLayoutPiece<N2,T2> *ilp = ipl.find_piece(subrect_image.lo);
    if(!(ilp && ilp->bounds.contains(subrect_image)))
      return false;
    if(ilp->layout_type != PieceLayoutTypes::AffineLayoutType)
      return false;
    void *base = inst.pointer_untyped(0, layout->bytes_used);
    if(base == 0)
      return false;

    // all checks passed!
    return true;
  }

  template <typename FT, int N, typename T>
  
  inline FT *AffineAccessor<FT,N,T>::ptr(const Point<N,T>& p) const
  {
    return this->get_ptr(p);
  }

  template <typename FT, int N, typename T>
  
  inline FT AffineAccessor<FT,N,T>::read(const Point<N,T>& p) const
  {
    return *(this->get_ptr(p));
  }

  template <typename FT, int N, typename T>
  
  inline void AffineAccessor<FT,N,T>::write(const Point<N,T>& p, FT newval) const
  {
    *(this->get_ptr(p)) = newval;
  }

  template <typename FT, int N, typename T>
  
  inline FT& AffineAccessor<FT,N,T>::operator[](const Point<N,T>& p) const
  {
    return *(this->get_ptr(p));
  }

  template <typename FT, int N, typename T>
  
  inline bool AffineAccessor<FT,N,T>::is_dense_arbitrary(const Rect<N,T> &bounds) const
  {
    size_t exp_offset = sizeof(FT);
    int used_mask = 0; // keep track of which dimensions we've already matched
    for (int i = 0; i < N; i++) {
      bool found = false;
      for (int j = 0; j < N; j++) {
        if ((used_mask >> j) & 1) continue;
        if (strides[j] != exp_offset) continue;
        found = true;
        used_mask |= (1 << j);
        exp_offset *= (bounds.hi[j] - bounds.lo[j] + 1);
        break;
      }
      if (!found)
        return false;
    }
    return true;
  }

  template <typename FT, int N, typename T>
  
  inline bool AffineAccessor<FT,N,T>::is_dense_col_major(const Rect<N,T> &bounds) const
  {
    size_t exp_offset = sizeof(FT);
    for (int i = 0; i < N; i++) {
      if (strides[i] != exp_offset) return false;
      exp_offset *= (bounds.hi[i] - bounds.lo[i] + 1);
    }
    return true;
  }

  template <typename FT, int N, typename T>
  
  inline bool AffineAccessor<FT,N,T>::is_dense_row_major(const Rect<N,T> &bounds) const
  {
    size_t exp_offset = sizeof(FT);
    for (int i = N-1; i >= 0; i--) {
      if (strides[i] != exp_offset) return false;
      exp_offset *= (bounds.hi[i] - bounds.lo[i] + 1);
    }
    return true;
  }

  template <typename FT, int N, typename T>
  
  inline FT *AffineAccessor<FT,N,T>::get_ptr(const Point<N,T>& p) const
  {
    uintptr_t rawptr = base;
    for(int i = 0; i < N; i++) rawptr += p[i] * strides[i];
    return reinterpret_cast<FT *>(rawptr);
  }

#ifdef REALM_PROVIDE_ACCESSOR_TO_KOKKOS_VIEW_CONVERSION
  // some compilers like to try to reason about concrete types in template
  //  before it's instantiated, so here's a little wrapper that forces a
  //  dependence on a second type T2 (e.g. a parameter to the calling
  //  template) to defer the analysis (hopefully after T has been properly
  //  defined)
  template <typename T, typename T2>
  struct DeferType {
    typedef T type;
  };

  // conversion to Kokkos unmanaged views
  template <typename FT, int N, typename T>
  template <typename ... Args>
  inline AffineAccessor<FT,N,T>::operator Kokkos::View<Args...>() const
  {
    typename DeferType<Kokkos::LayoutStride, FT>::type kls;
    uintptr_t base_shifted = base;
    for(int i = 0; i < N; i++) {
      // a Kokkos::View uses relative indexing, so subtract out the base
      //  of the subrectangle with which we must have been constructed
      REALM_ASSERT(bounds_specified,
		   ""FATAL: construction of a (relative-indexed) Kokkos::View""
		   "" is only possible if the AffineAccessor was constructed""
		   "" with explicitly-specified bounds!"");

      base_shifted += (bounds.lo[i] * strides[i]);
      kls.dimension[i] = ((bounds.hi[i] >= bounds.lo[i]) ?
			    (bounds.hi[i] - bounds.lo[i] + 1) :
			    0);
      kls.stride[i] = strides[i] / sizeof(FT);
      assert((size_t(kls.stride[i]) * sizeof(FT)) == size_t(strides[i]));
    }

    typedef Kokkos::View<typename Kokkos::View<Args...>::data_type,
			 Kokkos::LayoutStride,
			 typename Kokkos::View<Args...>::memory_space,
			 Kokkos::MemoryTraits<Kokkos_Unmanaged> > unmanaged_view;
    // verify our Kokkos_Unmanaged enum was right
    static_assert(unmanaged_view::traits::is_managed == 0,
		  ""incorrect value for Kokkos_Unmanaged!"");

    // verify the type and rank of the view match us - technically the type
    //  part would be caught by Kokkos if we passed an FT *, but the error
    //  messages that result are not easily understood
    static_assert(std::is_same<typename unmanaged_view::value_type, FT>::value ||
                  std::is_same<typename unmanaged_view::non_const_value_type, FT>::value,
                  ""base type mismatch between Kokkos view and accessor!"");
    static_assert(unmanaged_view::Rank == N,
		  ""rank mismatch between Kokkos view and accessor!"");

    // we're relying on the check above for type safety, so hand the
    //  view whatever kind of pointer it wants here (eliminating the
    //  horrible template-y error messages that come if FT * is not
    //  compatible)
    typedef typename unmanaged_view::pointer_type ptrtype;
    ptrtype baseptr = reinterpret_cast<ptrtype>(base_shifted);

    unmanaged_view v(baseptr, kls);
    return v;
  }

  template <typename FT, int N, typename T>
  template <typename ... Args>
  inline AffineAccessor<FT,N,T>::operator Kokkos::Experimental::OffsetView<Args...>() const
  {
    typename DeferType<Kokkos::LayoutStride, FT>::type kls;
    Kokkos::Array<int64_t, N, void> begins;
    uintptr_t base_shifted = base;
    for(int i = 0; i < N; i++) {
      // a Kokkos::Experimental::OffsetView uses absolute indexing, but it's
      //  a wrapper around a relatively-indexed Kokkos::View, so we need to
      //  determine extents and shifted base addresses that make sense to
      //  the inner view, and then we'll re-apply the absolute offset below
      //
      // compare to the direct Kokkos::View construction above though, we're
      //  tolerant of the bounds being inferred from the layout rather than
      //  being explicitly specified at accessor creation time

      begins[i] = bounds.lo[i];
      base_shifted += (bounds.lo[i] * strides[i]);
      kls.dimension[i] = ((bounds.hi[i] >= bounds.lo[i]) ?
			    (bounds.hi[i] - bounds.lo[i] + 1) :
			    0);
      kls.stride[i] = strides[i] / sizeof(FT);
      assert((size_t(kls.stride[i]) * sizeof(FT)) == size_t(strides[i]));
    }

    typedef Kokkos::View<typename Kokkos::View<Args...>::data_type,
			 Kokkos::LayoutStride,
			 typename Kokkos::View<Args...>::memory_space,
			 Kokkos::MemoryTraits<Kokkos_Unmanaged> > unmanaged_view;
    // verify our Kokkos_Unmanaged enum was right
    static_assert(unmanaged_view::traits::is_managed == 0,
		  ""incorrect value for Kokkos_Unmanaged!"");

    // verify the type and rank of the view match us - technically the type
    //  part would be caught by Kokkos if we passed an FT *, but the error
    //  messages that result are not easily understood
    static_assert(std::is_same<typename unmanaged_view::value_type, FT>::value ||
                  std::is_same<typename unmanaged_view::non_const_value_type, FT>::value,
                  ""base type mismatch between Kokkos view and accessor!"");
    static_assert(unmanaged_view::Rank == N,
		  ""rank mismatch between Kokkos view and accessor!"");

    // we're relying on the check above for type safety, so hand the
    //  view whatever kind of pointer it wants here (eliminating the
    //  horrible template-y error messages that come if FT * is not
    //  compatible)
    typedef typename unmanaged_view::pointer_type ptrtype;
    ptrtype baseptr = reinterpret_cast<ptrtype>(base_shifted);

    unmanaged_view v(baseptr, kls);

    typedef Kokkos::Experimental::OffsetView<typename Kokkos::View<Args...>::data_type,
					     Kokkos::LayoutStride,
					     typename Kokkos::View<Args...>::memory_space,
					     Kokkos::MemoryTraits<Kokkos_Unmanaged> > offset_view;

    offset_view v_ofs(v, begins);

    return v_ofs;
  }
#endif

  template <typename FT, int N, typename T>
  inline std::ostream& operator<<(std::ostream& os, const AffineAccessor<FT,N,T>& a)
  {
    os << ""AffineAccessor{ base="" << std::hex << a.base << std::dec << "" strides="" << a.strides;
#ifdef REALM_ACCESSOR_DEBUG
    os << "" inst="" << a.dbg_inst;
#endif
#if defined(REALM_ACCESSOR_DEBUG) || defined(REALM_USE_KOKKOS)
    os << "" bounds="" << a.bounds;
    os << ""->["" << std::hex << a.ptr(a.bounds.lo) << "","" << a.ptr(a.bounds.hi)+1 << std::dec << ""]"";
#endif
    os << "" }"";
    return os;
  }


  ////////////////////////////////////////////////////////////////////////
  //
  // class MultiAffineAccessor<FT,N,T>

  template <typename FT, int N, typename T>
  
  MultiAffineAccessor<FT,N,T>::MultiAffineAccessor(void)
  {
    reset();
  }

  template <typename FT, int N, typename T>
  MultiAffineAccessor<FT,N,T>::MultiAffineAccessor(RegionInstance inst,
						   FieldID field_id,
						   size_t subfield_offset /*= 0*/)
  {
    reset(inst, field_id, subfield_offset);
  }

  template <typename FT, int N, typename T>
  MultiAffineAccessor<FT,N,T>::MultiAffineAccessor(RegionInstance inst,
						   FieldID field_id,
						   const Rect<N,T>& subrect,
						   size_t subfield_offset /*= 0*/)
  {
    reset(inst, field_id, subrect, subfield_offset);
  }

  template <typename FT, int N, typename T>
  
  MultiAffineAccessor<FT,N,T>::~MultiAffineAccessor(void)
  {}

  template <typename FT, int N, typename T>
  /*static*/ bool MultiAffineAccessor<FT,N,T>::is_compatible(RegionInstance inst,
							     FieldID field_id)
  {
    size_t field_offset = 0;
    unsigned allowed_mask = (PieceLookup::ALLOW_AFFINE_PIECE |
			     PieceLookup::ALLOW_SPLIT1);
    const PieceLookup::Instruction *start_inst =
      inst.get_lookup_program<N,T>(field_id, allowed_mask, field_offset);
    return (start_inst != 0);
  }

  template <typename FT, int N, typename T>
  /*static*/ bool MultiAffineAccessor<FT,N,T>::is_compatible(RegionInstance inst,
							     FieldID field_id,
							     const Rect<N,T>& subrect)
  {
    size_t field_offset = 0;
    unsigned allowed_mask = (PieceLookup::ALLOW_AFFINE_PIECE |
			     PieceLookup::ALLOW_SPLIT1);
    const PieceLookup::Instruction *start_inst =
      inst.get_lookup_program<N,T>(field_id, subrect, allowed_mask,
				   field_offset);
    return (start_inst != 0);
  }

  // used by constructors or can be called directly
  template <typename FT, int N, typename T>
  
  void MultiAffineAccessor<FT,N,T>::reset()
  {
    start_inst = 0;
    piece_bounds = Rect<N,T>::make_empty();
  }

  template <typename FT, int N, typename T>
  void MultiAffineAccessor<FT,N,T>::reset(RegionInstance inst,
					  FieldID field_id,
					  size_t subfield_offset /*= 0*/)
  {
    unsigned allowed_mask = (PieceLookup::ALLOW_AFFINE_PIECE |
			     PieceLookup::ALLOW_SPLIT1);
    start_inst = inst.get_lookup_program<N,T>(field_id, allowed_mask,
					      field_offset);
    assert(start_inst != 0);

    // special case: if the first instruction is an AffinePiece and there's
    //  no next instruction, we cache the answer and forget the program
    if(start_inst->opcode() == PieceLookup::Opcodes::OP_AFFINE_PIECE) {
      const PieceLookup::AffinePiece<N,T> *ap_inst =
	static_cast<const PieceLookup::AffinePiece<N,T> *>(start_inst);
      if(ap_inst->delta() == 0) {
	piece_valid = true;
	piece_bounds = ap_inst->bounds;
	piece_base = ap_inst->base + field_offset + subfield_offset;
	piece_strides = ap_inst->strides;
	start_inst = 0;
	return;
      }
    }

    // otherwise make sure we incorporate the subfield offset and make the
    //  initial cache invalid
    field_offset += subfield_offset;
    piece_valid = false;
  }

  template <typename FT, int N, typename T>
  void MultiAffineAccessor<FT,N,T>::reset(RegionInstance inst,
					  FieldID field_id,
					  const Rect<N,T>& subrect,
					  size_t subfield_offset /*= 0*/)
  {
    unsigned allowed_mask = (PieceLookup::ALLOW_AFFINE_PIECE |
			     PieceLookup::ALLOW_SPLIT1);
    start_inst = inst.get_lookup_program<N,T>(field_id, subrect, allowed_mask,
					      field_offset);
    assert(start_inst != 0);

    // special case: if the first instruction is an AffinePiece and there's
    //  no next instruction, we cache the answer and forget the program
    if(start_inst->opcode() == PieceLookup::Opcodes::OP_AFFINE_PIECE) {
      const PieceLookup::AffinePiece<N,T> *ap_inst =
	static_cast<const PieceLookup::AffinePiece<N,T> *>(start_inst);
      if(ap_inst->delta() == 0) {
	piece_valid = true;
	piece_bounds = ap_inst->bounds;
	piece_base = ap_inst->base + field_offset + subfield_offset;
	piece_strides = ap_inst->strides;
	start_inst = 0;
	return;
      }
    }

    // otherwise make sure we incorporate the subfield offset and make the
    //  initial cache invalid
    field_offset += subfield_offset;
    piece_valid = false;
  }

  template <typename FT, int N, typename T>
  
  FT *MultiAffineAccessor<FT,N,T>::ptr(const Point<N,T>& p) const
  {
    // have we cached the right piece?
    if(piece_valid && piece_bounds.contains(p)) {
      uintptr_t rawptr = piece_base;
      for(int i = 0; i < N; i++) rawptr += p[i] * piece_strides[i];
      return reinterpret_cast<FT *>(rawptr);
    } else {
      const PieceLookup::Instruction *i = start_inst;
      while(true) {
#ifdef DEBUG_REALM
	assert(i != 0);
#endif
	if(i->opcode() == PieceLookup::Opcodes::OP_AFFINE_PIECE) {
	  const PieceLookup::AffinePiece<N,T> *ap =
	    static_cast<const PieceLookup::AffinePiece<N,T> *>(i);
	  if(ap->bounds.contains(p)) {
	    // hit, but we can't cache it
	    uintptr_t rawptr = ap->base + field_offset;
	    for(int i = 0; i < N; i++) rawptr += p[i] * ap->strides[i];
	    return reinterpret_cast<FT *>(rawptr);
	  } else
	    i = ap->next();
	} else {
	  assert(i->opcode() == PieceLookup::Opcodes::OP_SPLIT1);
	  i = static_cast<const PieceLookup::SplitPlane<N,T> *>(i)->next(p);
	}
      }
    }
  }

  template <typename FT, int N, typename T>
  
  FT *MultiAffineAccessor<FT,N,T>::ptr(const Rect<N,T>& r, size_t strides[N]) const
  {
    // have we cached the right piece?
    if(piece_valid && piece_bounds.contains(r)) {
      uintptr_t rawptr = piece_base;
      for(int i = 0; i < N; i++) rawptr += r.lo[i] * piece_strides[i];
      for(int i = 0; i < N; i++) strides[i] = piece_strides[i];
      return reinterpret_cast<FT *>(rawptr);
    } else {
      const PieceLookup::Instruction *i = start_inst;
      while(true) {
#ifdef DEBUG_REALM
	assert(i != 0);
#endif
	if(i->opcode() == PieceLookup::Opcodes::OP_AFFINE_PIECE) {
	  const PieceLookup::AffinePiece<N,T> *ap =
	    static_cast<const PieceLookup::AffinePiece<N,T> *>(i);
	  if(ap->bounds.contains(r)) {
	    // hit, but we can't cache it
	    uintptr_t rawptr = ap->base + field_offset;
	    for(int i = 0; i < N; i++) rawptr += r.lo[i] * ap->strides[i];
	    for(int i = 0; i < N; i++) strides[i] = piece_strides[i];
	    return reinterpret_cast<FT *>(rawptr);
	  } else
	    i = ap->next();
	} else {
	  assert(i->opcode() == PieceLookup::Opcodes::OP_SPLIT1);
	  const PieceLookup::SplitPlane<N,T> *sp =
	    static_cast<const PieceLookup::SplitPlane<N,T> *>(i);
	  if(sp->splits_rect(r))
	    return 0; // failure
	  i = sp->next(r.lo);
	}
      }
    }
  }

  template <typename FT, int N, typename T>
  
  FT MultiAffineAccessor<FT,N,T>::read(const Point<N,T>& p) const
  {
    return *(this->ptr(p));
  }

  template <typename FT, int N, typename T>
  
  void MultiAffineAccessor<FT,N,T>::write(const Point<N,T>& p, FT newval) const
  {
    *(this->ptr(p)) = newval;
  }

  template <typename FT, int N, typename T>
  
  FT& MultiAffineAccessor<FT,N,T>::operator[](const Point<N,T>& p) const
  {
    return *(this->ptr(p));
  }

  template <typename FT, int N, typename T>
  
  FT *MultiAffineAccessor<FT,N,T>::ptr(const Point<N,T>& p)
  {
    // do we need to do (and cache) a lookup?
    if(!piece_valid || !piece_bounds.contains(p)) {
      const PieceLookup::Instruction *i = start_inst;
      while(true) {
#ifdef DEBUG_REALM
	assert(i != 0);
#endif
	if(i->opcode() == PieceLookup::Opcodes::OP_AFFINE_PIECE) {
	  const PieceLookup::AffinePiece<N,T> *ap =
	    static_cast<const PieceLookup::AffinePiece<N,T> *>(i);
	  if(ap->bounds.contains(p)) {
	    // hit - cache the result
	    piece_valid = true;
	    piece_bounds = ap->bounds;
	    piece_base = ap->base + field_offset;
	    piece_strides = ap->strides;
	    break;
	  } else
	    i = ap->next();
	} else {
	  assert(i->opcode() == PieceLookup::Opcodes::OP_SPLIT1);
	  i = static_cast<const PieceLookup::SplitPlane<N,T> *>(i)->next(p);
	}
      }
    }

    uintptr_t rawptr = piece_base;
    for(int i = 0; i < N; i++) rawptr += p[i] * piece_strides[i];
    return reinterpret_cast<FT *>(rawptr);
  }

  template <typename FT, int N, typename T>
  
  FT *MultiAffineAccessor<FT,N,T>::ptr(const Rect<N,T>& r, size_t strides[N])
  {
    // do we need to do (and cache) a lookup?
    if(!piece_valid || !piece_bounds.contains(r)) {
      const PieceLookup::Instruction *i = start_inst;
      while(true) {
#ifdef DEBUG_REALM
	assert(i != 0);
#endif
	if(i->opcode() == PieceLookup::Opcodes::OP_AFFINE_PIECE) {
	  const PieceLookup::AffinePiece<N,T> *ap =
	    static_cast<const PieceLookup::AffinePiece<N,T> *>(i);
	  if(ap->bounds.contains(r)) {
	    // hit - cache the result
	    piece_valid = true;
	    piece_bounds = ap->bounds;
	    piece_base = ap->base + field_offset;
	    piece_strides = ap->strides;
	    break;
	  } else
	    i = ap->next();
	} else {
	  assert(i->opcode() == PieceLookup::Opcodes::OP_SPLIT1);
	  const PieceLookup::SplitPlane<N,T> *sp =
	    static_cast<const PieceLookup::SplitPlane<N,T> *>(i);
	  if(sp->splits_rect(r))
	    return 0; // failure
	  i = sp->next(r.lo);
	}
      }
    }

    uintptr_t rawptr = piece_base;
    for(int i = 0; i < N; i++) rawptr += r.lo[i] * piece_strides[i];
    for(int i = 0; i < N; i++) strides[i] = piece_strides[i];
    return reinterpret_cast<FT *>(rawptr);
  }

  template <typename FT, int N, typename T>
  
  FT MultiAffineAccessor<FT,N,T>::read(const Point<N,T>& p)
  {
    return *(this->ptr(p));
  }

  template <typename FT, int N, typename T>
  
  void MultiAffineAccessor<FT,N,T>::write(const Point<N,T>& p, FT newval)
  {
    *(this->ptr(p)) = newval;
  }

  template <typename FT, int N, typename T>
  
  FT& MultiAffineAccessor<FT,N,T>::operator[](const Point<N,T>& p)
  {
    return *(this->ptr(p));
  }

  template <typename FT, int N, typename T>
  std::ostream& operator<<(std::ostream& os, const MultiAffineAccessor<FT,N,T>& a)
  {
    os << ""MultiAffineAccessor{ start="" << std::hex << a.start_inst
       << "" offset="" << a.field_offset << std::dec;
    if(a.piece_valid)
      os << "" cache={ bounds="" << a.piece_bounds
	 << "" base="" << std::hex << a.piece_base << std::dec
	 << "" strides="" << a.piece_strides << "" }"";
    os << "" }"";
    return os;
  }


}; // namespace Realm
",16170,True,3205.544776373279,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/server.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 Verium 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 Verium 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 verium 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 Verium 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 veriumd)""},
                },
                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 Verium %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 veriumd 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;
}
",16150,True,3085.57059117098,median
"CLASS zcl_excel_ole DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.
    TYPES ty_doc_url TYPE c LENGTH 255.

    CLASS-METHODS bind_alv_ole2
      IMPORTING
        !i_document_url      TYPE ty_doc_url DEFAULT space
        !i_xls               TYPE c DEFAULT space
        !i_save_path         TYPE string
        !io_alv              TYPE REF TO cl_gui_alv_grid
        !it_listheader       TYPE slis_t_listheader OPTIONAL
        !i_top               TYPE i DEFAULT 1
        !i_left              TYPE i DEFAULT 1
        !i_columns_header    TYPE c DEFAULT 'X'
        !i_columns_autofit   TYPE c DEFAULT 'X'
        !i_format_col_header TYPE soi_format_item OPTIONAL
        !i_format_subtotal   TYPE soi_format_item OPTIONAL
        !i_format_total      TYPE soi_format_item OPTIONAL
      EXCEPTIONS
        miss_guide
        ex_transfer_kkblo_error
        fatal_error
        inv_data_range
        dim_mismatch_vkey
        dim_mismatch_sema
        error_in_sema .

  PROTECTED SECTION.
  PRIVATE SECTION.

    CLASS-METHODS close_document.
    CLASS-METHODS error_doi.

    CLASS-DATA: lo_spreadsheet TYPE REF TO i_oi_spreadsheet,
                lo_control     TYPE REF TO i_oi_container_control,
                lo_proxy       TYPE REF TO i_oi_document_proxy,
                lo_error       TYPE REF TO i_oi_error,
                lc_retcode     TYPE        soi_ret_string.

ENDCLASS.



CLASS zcl_excel_ole IMPLEMENTATION.

  METHOD bind_alv_ole2.
*--------------------------------------------------------------------*
* Method description:
*   Method use to export a CL_GUI_ALV_GRID object to xlsx/xls file
*   with list header and  characteristics of ALV field catalog such as:
*     + Total, group's subtotal
*     + Quantity fields, amount fields (dependent fields)
*     + No_out, no_zero, ...
* Technique use in method:
*   SAP Desktop Office Integration (DOI)
*--------------------------------------------------------------------*

* Data for session 0: DOI constructor
* ------------------------------------------

    DATA: li_has      TYPE i. ""Proxy has spreadsheet interface?

* Data for session 1: Get LVC data from ALV object
* ------------------------------------------

    DATA: l_has_activex,
          l_doctype_excel_sheet(11) TYPE c.

* LVC
    DATA: lt_fieldcat_lvc       TYPE lvc_t_fcat.
    DATA: wa_fieldcat_lvc       TYPE lvc_s_fcat.
    DATA: lt_sort_lvc           TYPE lvc_t_sort.
    DATA: lt_filter_idx_lvc     TYPE lvc_t_fidx.
    DATA: lt_grouplevels_lvc    TYPE lvc_t_grpl.

* KKBLO
    DATA: lt_fieldcat_kkblo     TYPE  kkblo_t_fieldcat.
    DATA: lt_sort_kkblo         TYPE  kkblo_t_sortinfo.
    DATA: lt_grouplevels_kkblo  TYPE  kkblo_t_grouplevels.
    DATA: lt_filter_idx_kkblo   TYPE  kkblo_t_sfinfo.
    DATA: wa_listheader         LIKE LINE OF it_listheader.

* Subtotal
    DATA: lt_collect00          TYPE REF TO data.
    DATA: lt_collect01          TYPE REF TO data.
    DATA: lt_collect02          TYPE REF TO data.
    DATA: lt_collect03          TYPE REF TO data.
    DATA: lt_collect04          TYPE REF TO data.
    DATA: lt_collect05          TYPE REF TO data.
    DATA: lt_collect06          TYPE REF TO data.
    DATA: lt_collect07          TYPE REF TO data.
    DATA: lt_collect08          TYPE REF TO data.
    DATA: lt_collect09          TYPE REF TO data.

* data table name
    DATA: l_tabname             TYPE  kkblo_tabname.

* local object
    DATA: lo_grid               TYPE REF TO lcl_gui_alv_grid.

* data table get from ALV
    DATA: lt_alv                  TYPE REF TO data.

* total / subtotal data
    FIELD-SYMBOLS: <f_collect00>  TYPE STANDARD TABLE.
    FIELD-SYMBOLS: <f_collect01>  TYPE STANDARD TABLE.
    FIELD-SYMBOLS: <f_collect02>  TYPE STANDARD TABLE.
    FIELD-SYMBOLS: <f_collect03>  TYPE STANDARD TABLE.
    FIELD-SYMBOLS: <f_collect04>  TYPE STANDARD TABLE.
    FIELD-SYMBOLS: <f_collect05>  TYPE STANDARD TABLE.
    FIELD-SYMBOLS: <f_collect06>  TYPE STANDARD TABLE.
    FIELD-SYMBOLS: <f_collect07>  TYPE STANDARD TABLE.
    FIELD-SYMBOLS: <f_collect08>  TYPE STANDARD TABLE.
    FIELD-SYMBOLS: <f_collect09>  TYPE STANDARD TABLE.

* table before append subtotal lines
    FIELD-SYMBOLS: <f_alv_tab>    TYPE STANDARD TABLE.

* data for session 2: sort, filter and calculate total/subtotal
* ------------------------------------------

* table to save index of subotal / total line in excel tanle
* this ideal to control index of subtotal / total line later
* for ex, when get subtotal / total line to format
    TYPES: BEGIN OF st_subtot_indexs,
             index TYPE i,
           END OF st_subtot_indexs.
    DATA: lt_subtot_indexs TYPE TABLE OF st_subtot_indexs.
    DATA: wa_subtot_indexs LIKE LINE OF lt_subtot_indexs.

* data table after append subtotal
    DATA: lt_excel                TYPE REF TO data.

    DATA: l_tabix                 TYPE i.
    DATA: l_save_index            TYPE i.

* dyn subtotal table name
    DATA: l_collect               TYPE string.

* subtotal range, to format subtotal (and total)
    DATA: subranges               TYPE soi_range_list.
    DATA: subrangeitem            TYPE soi_range_item.
    DATA: l_sub_index             TYPE i.


* table after append subtotal lines
    FIELD-SYMBOLS: <f_excel_tab>  TYPE STANDARD TABLE.
    FIELD-SYMBOLS: <f_excel_line> TYPE any.

* dyn subtotal tables
    FIELD-SYMBOLS: <f_collect_tab>      TYPE STANDARD TABLE.
    FIELD-SYMBOLS: <f_collect_line>     TYPE any.

    FIELD-SYMBOLS: <f_filter_idx_line>  LIKE LINE OF lt_filter_idx_kkblo.
    FIELD-SYMBOLS: <f_fieldcat_line>    LIKE LINE OF lt_fieldcat_kkblo.
    FIELD-SYMBOLS: <f_grouplevels_line> LIKE LINE OF lt_grouplevels_kkblo.
    FIELD-SYMBOLS: <f_line>             TYPE any.

* Data for session 3: map data to semantic table
* ------------------------------------------

    TYPES: BEGIN OF st_column_index,
             fieldname TYPE kkblo_fieldname,
             tabname   TYPE kkblo_tabname,
             col       LIKE sy-index,
           END OF st_column_index.

* columns index
    DATA: lt_column_index   TYPE TABLE OF st_column_index.
    DATA: wa_column_index   LIKE LINE OF lt_column_index.

* table of dependent field ( currency and quantity unit field)
    DATA: lt_fieldcat_depf  TYPE kkblo_t_fieldcat.
    DATA: wa_fieldcat_depf  TYPE kkblo_fieldcat.

* XXL interface:
* -XXL: contain exporting columns characteristic
    DATA: lt_sema TYPE TABLE OF gxxlt_s INITIAL SIZE 0.
    DATA: wa_sema LIKE LINE OF lt_sema.

* -XXL interface: header
    DATA: lt_hkey TYPE TABLE OF gxxlt_h INITIAL SIZE 0.
    DATA: wa_hkey LIKE LINE OF lt_hkey.

* -XXL interface: header keys
    DATA: lt_vkey TYPE TABLE OF gxxlt_v INITIAL SIZE 0.
    DATA: wa_vkey LIKE LINE OF lt_vkey.

* Number of H Keys: number of key columns
    DATA: l_n_hrz_keys      TYPE  i.
* Number of data columns in the list object: non-key columns no
    DATA: l_n_att_cols      TYPE  i.
* Number of V Keys: number of header row
    DATA: l_n_vrt_keys      TYPE  i.

* curency to format amount
    DATA: lt_tcurx          TYPE TABLE OF tcurx.
    DATA: wa_tcurx          LIKE LINE OF lt_tcurx.
    DATA: l_def             TYPE flag. "" currency / quantity flag
    DATA: wa_t006           TYPE t006. "" decimal place of unit

    DATA: l_num             TYPE i. "" table columns number
    DATA: l_typ             TYPE c. "" table type
    DATA: wa                TYPE REF TO data.
    DATA: l_int             TYPE i.
    DATA: l_counter         TYPE i.

    FIELD-SYMBOLS: <f_excel_column>     TYPE any.
    FIELD-SYMBOLS: <f_fcat_column>      TYPE any.

* Data for session 4: write to excel
* ------------------------------------------

    DATA: sema_type         TYPE  c.

    DATA l_error           TYPE REF TO c_oi_proxy_error.
    DATA count              TYPE i.
    DATA datac              TYPE i.
    DATA datareal TYPE i. "" exporting column number
    DATA vkeycount          TYPE i.
    DATA all TYPE i.
    DATA mit TYPE i         VALUE 1.  "" index of recent row?
    DATA li_col_pos TYPE i  VALUE 1.  "" column position
    DATA li_col_num TYPE i.           "" table columns number
    FIELD-SYMBOLS: <line>   TYPE any.
    FIELD-SYMBOLS: <item>   TYPE any.

    DATA td                 TYPE sydes_desc.

    DATA: typ.
    DATA: ranges             TYPE soi_range_list.
    DATA: rangeitem          TYPE soi_range_item.
    DATA: contents           TYPE soi_generic_table.
    DATA: contentsitem       TYPE soi_generic_item.
    DATA: semaitem           TYPE gxxlt_s.
    DATA: hkeyitem           TYPE gxxlt_h.
    DATA: vkeyitem           TYPE gxxlt_v.
    DATA: li_commentary_rows TYPE i.  ""row number of title lines + 1
    DATA: lo_error_w         TYPE REF TO  i_oi_error.
    DATA: l_retcode          TYPE soi_ret_string.
    DATA: no_flush           TYPE c VALUE 'X'.
    DATA: li_head_top        TYPE i. ""header rows position

* Data for session 5: Save and clode document
* ------------------------------------------

    DATA: li_document_size   TYPE i.
    DATA: ls_path            TYPE rlgrap-filename.

*--------------------------------------------------------------------*
* SESSION 0: DOI CONSTRUCTOR
*--------------------------------------------------------------------*

* check active windown

    CALL FUNCTION 'GUI_HAS_ACTIVEX'
      IMPORTING
        return = l_has_activex.

    IF l_has_activex IS INITIAL.
      RAISE miss_guide.
    ENDIF.

*   Get Container Object of Screen

    CALL METHOD c_oi_container_control_creator=>get_container_control
      IMPORTING
        control = lo_control
        retcode = lc_retcode.

    error_doi( ).

* Initialize Container control

    CALL METHOD lo_control->init_control
      EXPORTING
        parent                   = cl_gui_container=>default_screen
        r3_application_name      = ''
        inplace_enabled          = 'X'
        no_flush                 = 'X'
        register_on_close_event  = 'X'
        register_on_custom_event = 'X'
      IMPORTING
        error                    = lo_error
        retcode                  = lc_retcode.

    error_doi( ).

* Get Proxy Document:
* check exist of document proxy, if exist -> close first

    IF NOT lo_proxy IS INITIAL.
      close_document( ).
    ENDIF.

    IF i_xls IS NOT INITIAL.
* xls format, doctype = soi_doctype_excel97_sheet
      l_doctype_excel_sheet = 'Excel.Sheet.8'.
    ELSE.
* xlsx format, doctype = soi_doctype_excel_sheet
      l_doctype_excel_sheet = 'Excel.Sheet'.
    ENDIF.

    CALL METHOD lo_control->get_document_proxy
      EXPORTING
        document_type      = l_doctype_excel_sheet
        register_container = 'X'
      IMPORTING
        document_proxy     = lo_proxy
        error              = lo_error
        retcode            = lc_retcode.

    error_doi( ).

    IF i_document_url IS INITIAL.

* create new excel document

      CALL METHOD lo_proxy->create_document
        EXPORTING
          create_view_data = 'X'
          open_inplace     = 'X'
          no_flush         = 'X'
        IMPORTING
          error            = lo_error
          retcode          = lc_retcode.

      error_doi( ).

    ELSE.

* Read excel template for i_DOCUMENT_URL
* this excel template can be store in local or server

      CALL METHOD lo_proxy->open_document
        EXPORTING
          document_url = i_document_url
          open_inplace = 'X'
          no_flush     = 'X'
        IMPORTING
          error        = lo_error
          retcode      = lc_retcode.

      error_doi( ).

    ENDIF.

* Check Spreadsheet Interface of Document Proxy

    CALL METHOD lo_proxy->has_spreadsheet_interface
      IMPORTING
        is_available = li_has
        error        = lo_error
        retcode      = lc_retcode.

    error_doi( ).

* create Spreadsheet object

    CHECK li_has IS NOT INITIAL.

    CALL METHOD lo_proxy->get_spreadsheet_interface
      IMPORTING
        sheet_interface = lo_spreadsheet
        error           = lo_error
        retcode         = lc_retcode.

    error_doi( ).

*--------------------------------------------------------------------*
* SESSION 1: GET LVC DATA FROM ALV OBJECT
*--------------------------------------------------------------------*

* data table

    CREATE OBJECT lo_grid
      EXPORTING
        i_parent = cl_gui_container=>screen0.

    CALL METHOD lo_grid->get_alv_attributes
      EXPORTING
        io_grid  = io_alv
      IMPORTING
        et_table = lt_alv.

    ASSIGN lt_alv->* TO <f_alv_tab>.

* fieldcat

    CALL METHOD io_alv->get_frontend_fieldcatalog
      IMPORTING
        et_fieldcatalog = lt_fieldcat_lvc.

* table name

    LOOP AT lt_fieldcat_lvc INTO wa_fieldcat_lvc
    WHERE NOT tabname IS INITIAL.
      l_tabname = wa_fieldcat_lvc-tabname.
      EXIT.
    ENDLOOP.

    IF sy-subrc NE 0.
      l_tabname = '1'.
    ENDIF.
    CLEAR: wa_fieldcat_lvc.

* sort table

    CALL METHOD io_alv->get_sort_criteria
      IMPORTING
        et_sort = lt_sort_lvc.


* filter index

    CALL METHOD io_alv->get_filtered_entries
      IMPORTING
        et_filtered_entries = lt_filter_idx_lvc.

* group level + subtotal

    CALL METHOD io_alv->get_subtotals
      IMPORTING
        ep_collect00   = lt_collect00
        ep_collect01   = lt_collect01
        ep_collect02   = lt_collect02
        ep_collect03   = lt_collect03
        ep_collect04   = lt_collect04
        ep_collect05   = lt_collect05
        ep_collect06   = lt_collect06
        ep_collect07   = lt_collect07
        ep_collect08   = lt_collect08
        ep_collect09   = lt_collect09
        et_grouplevels = lt_grouplevels_lvc.

    ASSIGN lt_collect00->* TO <f_collect00>.
    ASSIGN lt_collect01->* TO <f_collect01>.
    ASSIGN lt_collect02->* TO <f_collect02>.
    ASSIGN lt_collect03->* TO <f_collect03>.
    ASSIGN lt_collect04->* TO <f_collect04>.
    ASSIGN lt_collect05->* TO <f_collect05>.
    ASSIGN lt_collect06->* TO <f_collect06>.
    ASSIGN lt_collect07->* TO <f_collect07>.
    ASSIGN lt_collect08->* TO <f_collect08>.
    ASSIGN lt_collect09->* TO <f_collect09>.

* transfer to KKBLO struct

    CALL FUNCTION 'LVC_TRANSFER_TO_KKBLO'
      EXPORTING
        it_fieldcat_lvc           = lt_fieldcat_lvc
        it_sort_lvc               = lt_sort_lvc
        it_filter_index_lvc       = lt_filter_idx_lvc
        it_grouplevels_lvc        = lt_grouplevels_lvc
      IMPORTING
        et_fieldcat_kkblo         = lt_fieldcat_kkblo
        et_sort_kkblo             = lt_sort_kkblo
        et_filtered_entries_kkblo = lt_filter_idx_kkblo
        et_grouplevels_kkblo      = lt_grouplevels_kkblo
      TABLES
        it_data                   = <f_alv_tab>
      EXCEPTIONS
        it_data_missing           = 1
        it_fieldcat_lvc_missing   = 2
        OTHERS                    = 3.
    IF sy-subrc <> 0.
      RAISE ex_transfer_kkblo_error.
    ENDIF.

    CLEAR:
      wa_fieldcat_lvc,
      lt_fieldcat_lvc,
      lt_sort_lvc,
      lt_filter_idx_lvc,
      lt_grouplevels_lvc.

    CLEAR:
      lo_grid.


*--------------------------------------------------------------------*
* SESSION 2: SORT, FILTER AND CALCULATE TOTAL / SUBTOTAL
*--------------------------------------------------------------------*

* append subtotal & total line

    CREATE DATA lt_excel LIKE <f_alv_tab>.
    ASSIGN lt_excel->* TO <f_excel_tab>.

    LOOP AT <f_alv_tab> ASSIGNING <f_line>.
      l_save_index = sy-tabix.

* filter base on filter index table

      READ TABLE lt_filter_idx_kkblo ASSIGNING <f_filter_idx_line>
      WITH KEY index = l_save_index
      BINARY SEARCH.
      IF sy-subrc NE 0.
        APPEND <f_line> TO <f_excel_tab>.
      ENDIF.

* append subtotal lines

      READ TABLE lt_grouplevels_kkblo ASSIGNING <f_grouplevels_line>
      WITH KEY index_to = l_save_index
      BINARY SEARCH.
      IF sy-subrc = 0.
        l_tabix = sy-tabix.
        DO.
          IF <f_grouplevels_line>-subtot EQ 'X' AND
             <f_grouplevels_line>-hide_level IS INITIAL AND
             <f_grouplevels_line>-cindex_from NE 0.

* dynamic append subtotal line to excel table base on grouplevel table
* ex <f_GROUPLEVELS_line>-level = 1
* then <f_collect_tab> = '<F_COLLECT01>'

            l_collect = <f_grouplevels_line>-level.
            CONDENSE l_collect.
            CONCATENATE '<F_COLLECT0'
                        l_collect '>'
*                      '->*'
                        INTO l_collect.

            ASSIGN (l_collect) TO <f_collect_tab>.

* incase there're more than 1 total line of group, at the same level
* for example: subtotal of multi currency

            LOOP AT <f_collect_tab> ASSIGNING <f_collect_line>.
              IF  sy-tabix BETWEEN <f_grouplevels_line>-cindex_from
                              AND  <f_grouplevels_line>-cindex_to.


                APPEND <f_collect_line> TO <f_excel_tab>.

* save subtotal lines index

                wa_subtot_indexs-index = sy-tabix.
                APPEND wa_subtot_indexs TO lt_subtot_indexs.

* append sub total ranges table for format later

                ADD 1 TO l_sub_index.
                subrangeitem-name     =  l_sub_index.
                CONDENSE subrangeitem-name.
                CONCATENATE 'SUBTOT'
                            subrangeitem-name
                            INTO subrangeitem-name.

                subrangeitem-rows     = wa_subtot_indexs-index.
                subrangeitem-columns  = 1.            "" start col
                APPEND subrangeitem TO subranges.
                CLEAR: subrangeitem.

              ENDIF.
            ENDLOOP.
            UNASSIGN: <f_collect_tab>.
            UNASSIGN: <f_collect_line>.
            CLEAR: l_collect.
          ENDIF.

* check next subtotal level of group

          UNASSIGN: <f_grouplevels_line>.
          ADD 1 TO l_tabix.

          READ TABLE lt_grouplevels_kkblo ASSIGNING <f_grouplevels_line>
          INDEX l_tabix.
          IF sy-subrc NE 0
          OR <f_grouplevels_line>-index_to NE l_save_index.
            EXIT.
          ENDIF.

          UNASSIGN:
            <f_collect_tab>,
            <f_collect_line>.

        ENDDO.
      ENDIF.

      CLEAR:
        l_tabix,
        l_save_index.

      UNASSIGN:
        <f_filter_idx_line>,
        <f_grouplevels_line>.

    ENDLOOP.

* free local data

    UNASSIGN:
      <f_line>,
      <f_collect_tab>,
      <f_collect_line>,
      <f_fieldcat_line>.

* append grand total line

    IF <f_collect00> IS ASSIGNED.
      ASSIGN <f_collect00> TO <f_collect_tab>.
      IF <f_collect_tab> IS NOT INITIAL.
        LOOP AT <f_collect_tab> ASSIGNING <f_collect_line>.

          APPEND <f_collect_line> TO <f_excel_tab>.

* save total line index

          wa_subtot_indexs-index = sy-tabix.
          APPEND wa_subtot_indexs TO lt_subtot_indexs.

* append grand total range (to format)

          ADD 1 TO l_sub_index.
          subrangeitem-name     =  l_sub_index.
          CONDENSE subrangeitem-name.
          CONCATENATE 'TOTAL'
                      subrangeitem-name
                      INTO subrangeitem-name.

          subrangeitem-rows     = wa_subtot_indexs-index.
          subrangeitem-columns  = 1.            "" start col
          APPEND subrangeitem TO subranges.
        ENDLOOP.
      ENDIF.
    ENDIF.

    CLEAR:
      subrangeitem,
      lt_sort_kkblo,
      <f_collect00>,
      <f_collect01>,
      <f_collect02>,
      <f_collect03>,
      <f_collect04>,
      <f_collect05>,
      <f_collect06>,
      <f_collect07>,
      <f_collect08>,
      <f_collect09>.

    UNASSIGN:
      <f_collect00>,
      <f_collect01>,
      <f_collect02>,
      <f_collect03>,
      <f_collect04>,
      <f_collect05>,
      <f_collect06>,
      <f_collect07>,
      <f_collect08>,
      <f_collect09>,
      <f_collect_tab>,
      <f_collect_line>.

*--------------------------------------------------------------------*
* SESSION 3: MAP DATA TO SEMANTIC TABLE
*--------------------------------------------------------------------*

* get dependent field field: currency and quantity

    CREATE DATA wa LIKE LINE OF <f_excel_tab>.
    ASSIGN wa->* TO <f_excel_line>.

    DESCRIBE FIELD <f_excel_line> TYPE l_typ COMPONENTS l_num.

    DO l_num TIMES.
      l_save_index = sy-index.
      ASSIGN COMPONENT l_save_index OF STRUCTURE <f_excel_line>
      TO <f_excel_column>.
      IF sy-subrc NE 0.
        MESSAGE e801(zabap2xlsx) WITH 'FATAL ERROR' RAISING fatal_error.
      ENDIF.

      LOOP AT lt_fieldcat_kkblo ASSIGNING <f_fieldcat_line>
      WHERE tabname = l_tabname.
        ASSIGN COMPONENT <f_fieldcat_line>-fieldname
        OF STRUCTURE <f_excel_line> TO <f_fcat_column>.

        DESCRIBE DISTANCE BETWEEN <f_excel_column> AND <f_fcat_column>
        INTO l_int IN BYTE MODE.

* append column index
* this columns index is of table, not fieldcat

        IF l_int = 0.
          wa_column_index-fieldname = <f_fieldcat_line>-fieldname.
          wa_column_index-tabname   = <f_fieldcat_line>-tabname.
          wa_column_index-col       = l_save_index.
          APPEND wa_column_index TO lt_column_index.
        ENDIF.

* append dependent fields (currency and quantity unit)

        IF <f_fieldcat_line>-cfieldname IS NOT INITIAL.
          CLEAR wa_fieldcat_depf.
          wa_fieldcat_depf-fieldname = <f_fieldcat_line>-cfieldname.
          wa_fieldcat_depf-tabname   = <f_fieldcat_line>-ctabname.
          COLLECT wa_fieldcat_depf INTO lt_fieldcat_depf.
        ENDIF.

        IF <f_fieldcat_line>-qfieldname IS NOT INITIAL.
          CLEAR wa_fieldcat_depf.
          wa_fieldcat_depf-fieldname = <f_fieldcat_line>-qfieldname.
          wa_fieldcat_depf-tabname   = <f_fieldcat_line>-qtabname.
          COLLECT wa_fieldcat_depf INTO lt_fieldcat_depf.
        ENDIF.

* rewrite field data type

        IF <f_fieldcat_line>-inttype = 'X'
        AND <f_fieldcat_line>-datatype(3) = 'INT'.
          <f_fieldcat_line>-inttype = 'I'.
        ENDIF.

      ENDLOOP.

      CLEAR: l_save_index.
      UNASSIGN: <f_fieldcat_line>.

    ENDDO.

* build semantic tables

    l_n_hrz_keys = 1.

*   Get keyfigures

    LOOP AT lt_fieldcat_kkblo ASSIGNING <f_fieldcat_line>
    WHERE tabname = l_tabname
    AND tech NE 'X'
    AND no_out NE 'X'.

      CLEAR wa_sema.
      CLEAR wa_hkey.

*   Units belong to keyfigures -> display as str

      READ TABLE lt_fieldcat_depf INTO wa_fieldcat_depf WITH KEY
      fieldname = <f_fieldcat_line>-fieldname
      tabname   = <f_fieldcat_line>-tabname.

      IF sy-subrc = 0.
        wa_sema-col_typ = 'STR'.
        wa_sema-col_ops = 'DFT'.

*   Keyfigures

      ELSE.
        CASE <f_fieldcat_line>-datatype.
          WHEN 'QUAN'.
            wa_sema-col_typ = 'N03'.

            IF <f_fieldcat_line>-no_sum NE 'X'.
              wa_sema-col_ops = 'ADD'.
            ELSE.
              wa_sema-col_ops = 'NOP'. "" no dependent field
            ENDIF.

          WHEN 'DATS'.
            wa_sema-col_typ = 'DAT'.
            wa_sema-col_ops = 'NOP'.

          WHEN 'CHAR' OR 'UNIT' OR 'CUKY'. "" Added fieldformats UNIT and CUKY - dd. 26-10-2012 Wouter Heuvelmans
            wa_sema-col_typ = 'STR'.
            wa_sema-col_ops = 'DFT'.   "" dependent field

*   incase numeric, ex '00120' -> display as '12'

          WHEN 'NUMC'.
            wa_sema-col_typ = 'STR'.
            wa_sema-col_ops = 'DFT'.

          WHEN OTHERS.
            wa_sema-col_typ = 'NUM'.

            IF <f_fieldcat_line>-no_sum NE 'X'.
              wa_sema-col_ops = 'ADD'.
            ELSE.
              wa_sema-col_ops = 'NOP'.
            ENDIF.
        ENDCASE.
      ENDIF.

      l_counter = l_counter + 1.
      l_n_att_cols = l_n_att_cols + 1.

      wa_sema-col_no = l_counter.

      READ TABLE lt_column_index INTO wa_column_index WITH KEY
      fieldname = <f_fieldcat_line>-fieldname
      tabname   = <f_fieldcat_line>-tabname.

      IF sy-subrc = 0.
        wa_sema-col_src = wa_column_index-col.
      ELSE.
        RAISE fatal_error.
      ENDIF.

* columns index of ref currency field in table

      IF NOT <f_fieldcat_line>-cfieldname IS INITIAL.
        READ TABLE lt_column_index INTO wa_column_index WITH KEY
        fieldname = <f_fieldcat_line>-cfieldname
        tabname   = <f_fieldcat_line>-ctabname.

        IF sy-subrc = 0.
          wa_sema-col_cur = wa_column_index-col.
        ENDIF.

* quantities fields
* treat as currency when display on excel

      ELSEIF NOT <f_fieldcat_line>-qfieldname IS INITIAL.
        READ TABLE lt_column_index INTO wa_column_index WITH KEY
        fieldname = <f_fieldcat_line>-qfieldname
        tabname   = <f_fieldcat_line>-qtabname.
        IF sy-subrc = 0.
          wa_sema-col_cur = wa_column_index-col.
        ENDIF.

      ENDIF.

*   Treat of fixed currency in the fieldcatalog for column

      DATA: l_num_help(2) TYPE n.

      IF NOT <f_fieldcat_line>-currency IS INITIAL.

        SELECT * FROM tcurx INTO TABLE lt_tcurx.
        SORT lt_tcurx.
        READ TABLE lt_tcurx INTO wa_tcurx
                   WITH KEY currkey = <f_fieldcat_line>-currency.
        IF sy-subrc = 0.
          l_num_help = wa_tcurx-currdec.
          CONCATENATE 'N' l_num_help INTO wa_sema-col_typ.
          wa_sema-col_cur = sy-tabix * ( -1 ).
        ENDIF.

      ENDIF.

      wa_hkey-col_no    = l_n_att_cols.
      wa_hkey-row_no    = l_n_hrz_keys.
      wa_hkey-col_name  = <f_fieldcat_line>-reptext.
      APPEND wa_hkey TO lt_hkey.
      APPEND wa_sema TO lt_sema.

    ENDLOOP.

* free local data

    CLEAR:
      lt_column_index,
      wa_column_index,
      lt_fieldcat_depf,
      wa_fieldcat_depf,
      lt_tcurx,
      wa_tcurx,
      l_num,
      l_typ,
      wa,
      l_int,
      l_counter.

    UNASSIGN:
      <f_fieldcat_line>,
      <f_excel_line>,
      <f_excel_column>,
      <f_fcat_column>.

*--------------------------------------------------------------------*
* SESSION 4: WRITE TO EXCEL
*--------------------------------------------------------------------*

    CLEAR wa_tcurx.
    CLEAR lt_tcurx.

*   if spreadsheet dun have proxy yet

    IF li_has IS INITIAL.
      l_retcode = c_oi_errors=>ret_interface_not_supported.
      CALL METHOD c_oi_errors=>create_error_for_retcode
        EXPORTING
          retcode  = l_retcode
          no_flush = no_flush
        IMPORTING
          error    = lo_error_w.
      RETURN.
    ENDIF.

    CREATE OBJECT l_error
      EXPORTING
        object_name = 'OLE_DOCUMENT_PROXY'
        method_name = 'get_ranges_names'.

    CALL METHOD c_oi_errors=>add_error
      EXPORTING
        error = l_error.


    DESCRIBE TABLE lt_sema LINES datareal.
    DESCRIBE TABLE <f_excel_tab> LINES datac.
    DESCRIBE TABLE lt_vkey LINES vkeycount.

    IF datac = 0.
      RAISE inv_data_range.
    ENDIF.


    IF vkeycount NE l_n_vrt_keys.
      RAISE dim_mismatch_vkey.
    ENDIF.

    all = l_n_vrt_keys + l_n_att_cols.

    IF datareal NE all.
      RAISE dim_mismatch_sema.
    ENDIF.

    DATA: decimal TYPE c.

* get decimal separator format ('.', ',', ...) in Office config

    CALL METHOD lo_proxy->get_application_property
      EXPORTING
        property_name    = 'INTERNATIONAL'
        subproperty_name = 'DECIMAL_SEPARATOR'
      CHANGING
        retvalue         = decimal.

    DATA date_format TYPE usr01-datfm.
    SELECT SINGLE datfm FROM usr01 INTO date_format WHERE bname = sy-uname.

    DATA: comma_elim(4) TYPE c.
    FIELD-SYMBOLS <g> TYPE any.
    DATA search_item(4) VALUE '   #'.

    CONCATENATE ',' decimal '.' decimal INTO comma_elim.

    DATA help TYPE i. "" table (with subtotal) line number

    help = datac.

    DATA: rowmax TYPE i VALUE 1.    "" header row number
    DATA: columnmax TYPE i VALUE 0. "" header columns number

    LOOP AT lt_hkey INTO hkeyitem.
      IF hkeyitem-col_no > columnmax.
        columnmax = hkeyitem-col_no.
      ENDIF.

      IF hkeyitem-row_no > rowmax.
        rowmax = hkeyitem-row_no.
      ENDIF.
    ENDLOOP.

    DATA: hkeycolumns TYPE i. "" header columns no

    hkeycolumns = columnmax.

    IF hkeycolumns <   l_n_att_cols.
      hkeycolumns = l_n_att_cols.
    ENDIF.

    columnmax = 0.

    LOOP AT lt_vkey INTO vkeyitem.
      IF vkeyitem-col_no > columnmax.
        columnmax = vkeyitem-col_no.
      ENDIF.
    ENDLOOP.

    DATA overflow TYPE i VALUE 1.
    DATA testname(10) TYPE c.
    DATA temp2 TYPE i.                "" 1st item row position in excel
    DATA realmit TYPE i VALUE 1.
    DATA realoverflow TYPE i VALUE 1. "" row index in content

    CALL METHOD lo_spreadsheet->screen_update
      EXPORTING
        updating = ''.

    CALL METHOD lo_spreadsheet->load_lib.

    DATA: str(40) TYPE c. "" range names of columns range (w/o col header)
    DATA: rows TYPE i.    "" row postion of 1st item line in ecxel

* calculate row position of data table

    DESCRIBE TABLE it_listheader LINES li_commentary_rows.

* if grid had title, add 1 empy line between title and table

    IF li_commentary_rows NE 0.
      ADD 1 TO li_commentary_rows.
    ENDIF.

* add top position of block data

    li_commentary_rows = li_commentary_rows + i_top - 1.

* write header (commentary rows)

    DATA: li_commentary_row_index TYPE i VALUE 1.
    DATA: li_content_index TYPE i VALUE 1.
    DATA: ls_index(10) TYPE c.
    DATA  ls_commentary_range(40) TYPE c VALUE 'TITLE'.
    DATA: li_font_bold    TYPE i.
    DATA: li_font_italic  TYPE i.
    DATA: li_font_size    TYPE i.

    LOOP AT it_listheader INTO wa_listheader.
      li_commentary_row_index = i_top + li_content_index - 1.
      ls_index = li_content_index.
      CONDENSE ls_index.
      CONCATENATE ls_commentary_range(5) ls_index
                  INTO ls_commentary_range.
      CONDENSE ls_commentary_range.

* insert title range

      CALL METHOD lo_spreadsheet->insert_range_dim
        EXPORTING
          name     = ls_commentary_range
          top      = li_commentary_row_index
          left     = i_left
          rows     = 1
          columns  = 1
          no_flush = no_flush.

* format range

      CASE wa_listheader-typ.
        WHEN 'H'. ""title
          li_font_size    = 16.
          li_font_bold    = 1.
          li_font_italic  = -1.
        WHEN 'S'. ""subtile
          li_font_size = -1.
          li_font_bold    = 1.
          li_font_italic  = -1.
        WHEN OTHERS. ""'A' comment
          li_font_size = -1.
          li_font_bold    = -1.
          li_font_italic  = 1.
      ENDCASE.

      CALL METHOD lo_spreadsheet->set_font
        EXPORTING
          rangename = ls_commentary_range
          family    = ''
          size      = li_font_size
          bold      = li_font_bold
          italic    = li_font_italic
          align     = 0
          no_flush  = no_flush.

* title: range content

      rangeitem-name = ls_commentary_range.
      rangeitem-columns = 1.
      rangeitem-rows = 1.
      APPEND rangeitem TO ranges.

      contentsitem-row    = li_content_index.
      contentsitem-column = 1.
      CONCATENATE wa_listheader-key
                  wa_listheader-info
                  INTO contentsitem-value
                  SEPARATED BY space.
      CONDENSE contentsitem-value.
      APPEND contentsitem TO contents.

      ADD 1 TO li_content_index.

      CLEAR:
        rangeitem,
        contentsitem,
        ls_index.

    ENDLOOP.

* set range data title

    CALL METHOD lo_spreadsheet->set_ranges_data
      EXPORTING
        ranges   = ranges
        contents = contents
        no_flush = no_flush.

    CLEAR: ranges, contents.

    rows = rowmax + li_commentary_rows + 1.

    all = date_format.
    all = all + 3.

    LOOP AT lt_sema INTO semaitem.
      IF semaitem-col_typ = 'DAT' OR semaitem-col_typ = 'MON' OR
         semaitem-col_typ = 'N00' OR semaitem-col_typ = 'N01' OR
         semaitem-col_typ = 'N02' OR
         semaitem-col_typ = 'N03' OR semaitem-col_typ = 'PCT' OR
         semaitem-col_typ = 'STR' OR semaitem-col_typ = 'NUM'.
        CLEAR str.
        str = semaitem-col_no.
        CONDENSE str.
        CONCATENATE 'DATA' str INTO str.
        mit = semaitem-col_no.
        li_col_pos = semaitem-col_no + i_left - 1.

* range from data1 to data(n), for each columns of table

        CALL METHOD lo_spreadsheet->insert_range_dim
          EXPORTING
            name     = str
            top      = rows
            left     = li_col_pos
            rows     = help
            columns  = 1
            no_flush = no_flush.

        DATA dec TYPE i VALUE -1.
        DATA typeinfo TYPE sydes_typeinfo.
        LOOP AT <f_excel_tab> ASSIGNING <line>.
          ASSIGN COMPONENT semaitem-col_no OF STRUCTURE <line> TO <item>.
          DESCRIBE FIELD <item> INTO td.
          READ TABLE td-types INDEX 1 INTO typeinfo.
          IF typeinfo-type = 'P'.
            dec = typeinfo-decimals.
          ELSEIF typeinfo-type = 'I'.
            dec = 0.
          ENDIF.

          DESCRIBE FIELD <line> TYPE typ COMPONENTS count.
          mit = 1.
          DO count TIMES.
            IF mit = semaitem-col_src.
              ASSIGN COMPONENT sy-index OF STRUCTURE <line> TO <item>.
              DESCRIBE FIELD <item> INTO td.
              READ TABLE td-types INDEX 1 INTO typeinfo.
              IF typeinfo-type = 'P'.
                dec = typeinfo-decimals.
              ENDIF.
              EXIT.
            ENDIF.
            mit = mit + 1.
          ENDDO.
          EXIT.
        ENDLOOP.

* format for each columns of table (w/o columns headers)

        IF semaitem-col_typ = 'DAT'.
          IF semaitem-col_no > vkeycount.
            CALL METHOD lo_spreadsheet->set_format
              EXPORTING
                rangename = str
                currency  = ''
                typ       = all
                no_flush  = no_flush.
          ELSE.
            CALL METHOD lo_spreadsheet->set_format
              EXPORTING
                rangename = str
                currency  = ''
                typ       = 0
                no_flush  = no_flush.
          ENDIF.
        ELSEIF semaitem-col_typ = 'STR'.
          CALL METHOD lo_spreadsheet->set_format
            EXPORTING
              rangename = str
              currency  = ''
              typ       = 0
              no_flush  = no_flush.
        ELSEIF semaitem-col_typ = 'MON'.
          CALL METHOD lo_spreadsheet->set_format
            EXPORTING
              rangename = str
              currency  = ''
              typ       = 10
              no_flush  = no_flush.
        ELSEIF semaitem-col_typ = 'N00'.
          CALL METHOD lo_spreadsheet->set_format
            EXPORTING
              rangename = str
              currency  = ''
              typ       = 1
              decimals  = 0
              no_flush  = no_flush.
        ELSEIF semaitem-col_typ = 'N01'.
          CALL METHOD lo_spreadsheet->set_format
            EXPORTING
              rangename = str
              currency  = ''
              typ       = 1
              decimals  = 1
              no_flush  = no_flush.
        ELSEIF semaitem-col_typ = 'N02'.
          CALL METHOD lo_spreadsheet->set_format
            EXPORTING
              rangename = str
              currency  = ''
              typ       = 1
              decimals  = 2
              no_flush  = no_flush.
        ELSEIF semaitem-col_typ = 'N03'.
          CALL METHOD lo_spreadsheet->set_format
            EXPORTING
              rangename = str
              currency  = ''
              typ       = 1
              decimals  = 3
              no_flush  = no_flush.
        ELSEIF semaitem-col_typ = 'N04'.
          CALL METHOD lo_spreadsheet->set_format
            EXPORTING
              rangename = str
              currency  = ''
              typ       = 1
              decimals  = 4
              no_flush  = no_flush.
        ELSEIF semaitem-col_typ = 'NUM'.
          IF dec EQ -1.
            CALL METHOD lo_spreadsheet->set_format
              EXPORTING
                rangename = str
                currency  = ''
                typ       = 1
                decimals  = 2
                no_flush  = no_flush.
          ELSE.
            CALL METHOD lo_spreadsheet->set_format
              EXPORTING
                rangename = str
                currency  = ''
                typ       = 1
                decimals  = dec
                no_flush  = no_flush.
          ENDIF.
        ELSEIF semaitem-col_typ = 'PCT'.
          CALL METHOD lo_spreadsheet->set_format
            EXPORTING
              rangename = str
              currency  = ''
              typ       = 3
              decimals  = 0
              no_flush  = no_flush.
        ENDIF.

      ENDIF.
    ENDLOOP.

* get item contents for set_range_data method
* get currency cell also

    mit = 1.

    DATA: currcells TYPE soi_cell_table.
    DATA: curritem  TYPE soi_cell_item.

    curritem-rows = 1.
    curritem-columns = 1.
    curritem-front = -1.
    curritem-back = -1.
    curritem-font = ''.
    curritem-size = -1.
    curritem-bold = -1.
    curritem-italic = -1.
    curritem-align = -1.
    curritem-frametyp = -1.
    curritem-framecolor = -1.
    curritem-currency = ''.
    curritem-number = 1.
    curritem-input = -1.

    DATA: const TYPE i.

*   Change for Correction request
*    Initial 10000 lines are missing in Excel Export
*    if there are only 2 columns in exported List object.

    IF datareal GT 2.
      const = 20000 / datareal.
    ELSE.
      const = 20000 / ( datareal + 2 ).
    ENDIF.

    DATA: lines TYPE i.
    DATA: innerlines TYPE i.
    DATA: counter TYPE i.
    DATA: curritem2 LIKE curritem.
    DATA: curritem3 LIKE curritem.
    DATA: length TYPE i.
    DATA: found.

* append content table (for method set_range_content)

    LOOP AT <f_excel_tab> ASSIGNING <line>.

* save line index to compare with lt_subtot_indexs,
* to discover line is a subtotal / totale line or not
* ex use to set 'dun display zero in subtotal / total line'

      l_save_index = sy-tabix.

      DO datareal TIMES.
        READ TABLE lt_sema INTO semaitem WITH KEY col_no = sy-index.
        IF semaitem-col_src NE 0.
          ASSIGN COMPONENT semaitem-col_src
                 OF STRUCTURE <line> TO <item>.
        ELSE.
          ASSIGN COMPONENT sy-index
                 OF STRUCTURE <line> TO <item>.
        ENDIF.

        contentsitem-row = realoverflow.

        IF sy-subrc = 0.
          search_item(3) = semaitem-col_ops.
          SEARCH 'ADD#CNT#MIN#MAX#AVG#NOP#DFT#'
                            FOR search_item.
          IF sy-subrc NE 0.
            RAISE error_in_sema.
          ENDIF.
          search_item(3) = semaitem-col_typ.
          SEARCH 'NUM#N00#N01#N02#N03#N04#PCT#DAT#MON#STR#'
                            FOR search_item.
          IF sy-subrc NE 0.
            RAISE error_in_sema.
          ENDIF.
          contentsitem-column = sy-index.
          IF semaitem-col_typ EQ 'DAT' OR semaitem-col_typ EQ 'MON'.
            IF semaitem-col_no > vkeycount.

              "" Hinweis 512418
              "" EXCEL bezieht Datumsangaben
              "" auf den 31.12.1899, behandelt
              "" aber 1900 als ein Schaltjahr
              "" d.h. ab 1.3.1900 korrekt
              "" 1.3.1900 als Zahl = 61

              DATA: genesis TYPE d VALUE '18991230'.
              DATA: number_of_days TYPE p.
* change for date in char format & sema_type = X
              DATA: temp_date TYPE d.

              IF NOT <item> IS INITIAL AND NOT <item> CO ' ' AND NOT
              <item> CO '0'.
* change for date in char format & sema_type = X starts
                IF sema_type = 'X'.
                  DESCRIBE FIELD <item> TYPE typ.
                  IF typ = 'C'.
                    temp_date = <item>.
                    number_of_days = temp_date - genesis.
                  ELSE.
                    number_of_days = <item> - genesis.
                  ENDIF.
                ELSE.
                  number_of_days = <item> - genesis.
                ENDIF.
* change for date in char format & sema_type = X ends
                IF number_of_days < 61.
                  number_of_days = number_of_days - 1.
                ENDIF.

                SET COUNTRY 'DE'.
                WRITE number_of_days TO contentsitem-value
                NO-GROUPING
                                          LEFT-JUSTIFIED.
                SET COUNTRY space.
                TRANSLATE contentsitem-value USING comma_elim.
              ELSE.
                CLEAR contentsitem-value.
              ENDIF.
            ELSE.
              contentsitem-value = <item>.
            ENDIF.
          ELSEIF semaitem-col_typ EQ 'NUM' OR
                 semaitem-col_typ EQ 'N00' OR
                 semaitem-col_typ EQ 'N01' OR
                 semaitem-col_typ EQ 'N02' OR
                 semaitem-col_typ EQ 'N03' OR
                 semaitem-col_typ EQ 'N04' OR
                 semaitem-col_typ EQ 'PCT'.
            SET COUNTRY 'DE'.
            DESCRIBE FIELD <item> TYPE typ.

            IF semaitem-col_cur IS INITIAL.
              IF typ NE 'F'.
                WRITE <item> TO contentsitem-value NO-GROUPING
                                                   NO-SIGN DECIMALS 14.
              ELSE.
                WRITE <item> TO contentsitem-value NO-GROUPING
                                                   NO-SIGN.
              ENDIF.
            ELSE.
* Treat of fixed curreny for column >>Y9CK007319
              IF semaitem-col_cur < 0.
                semaitem-col_cur = semaitem-col_cur * ( -1 ).
                SELECT * FROM tcurx INTO TABLE lt_tcurx.
                SORT lt_tcurx.
                READ TABLE lt_tcurx INTO
                                    wa_tcurx INDEX semaitem-col_cur.
                IF sy-subrc = 0.
                  IF typ NE 'F'.
                    WRITE <item> TO contentsitem-value NO-GROUPING
                     CURRENCY wa_tcurx-currkey NO-SIGN DECIMALS 14.
                  ELSE.
                    WRITE <item> TO contentsitem-value NO-GROUPING
                     CURRENCY wa_tcurx-currkey NO-SIGN.
                  ENDIF.
                ENDIF.
              ELSE.
                ASSIGN COMPONENT semaitem-col_cur
                     OF STRUCTURE <line> TO <g>.
* mit = index of recent row
                curritem-top  = rowmax + mit + li_commentary_rows.

                li_col_pos =  sy-index + i_left - 1.
                curritem-left = li_col_pos.

* if filed is quantity field (qfieldname ne space)
* or amount field (cfieldname ne space), then format decimal place
* corresponding with config

                CLEAR: l_def.
                READ TABLE lt_fieldcat_kkblo ASSIGNING <f_fieldcat_line>
                WITH KEY  tabname = l_tabname
                          tech    = space
                          no_out  = space
                          col_pos = semaitem-col_no.
                IF sy-subrc = 0.
                  IF <f_fieldcat_line>-cfieldname IS NOT INITIAL.
                    l_def = 'C'.
                  ELSE.""if <f_fieldcat_line>-qfieldname is not initial.
                    l_def = 'Q'.
                  ENDIF.
                ENDIF.

* if field is amount field
* exporting of amount field base on currency decimal table: TCURX
                IF l_def = 'C'. ""field is amount field
                  SELECT SINGLE * FROM tcurx INTO wa_tcurx
                    WHERE currkey = <g>.
* if amount ref to un-know currency -> default decimal  = 2
                  IF sy-subrc EQ 0.
                    curritem-decimals = wa_tcurx-currdec.
                  ELSE.
                    curritem-decimals = 2.
                  ENDIF.

                  APPEND curritem TO currcells.
                  IF typ NE 'F'.
                    WRITE <item> TO contentsitem-value
                                        CURRENCY <g>
                       NO-SIGN NO-GROUPING.
                  ELSE.
                    WRITE <item> TO contentsitem-value
                       DECIMALS 14      CURRENCY <g>
                       NO-SIGN NO-GROUPING.
                  ENDIF.

* if field is quantity field
* exporting of quantity field base on quantity decimal table: T006

                ELSE.""if l_def = 'Q'. "" field is quantity field
                  CLEAR: wa_t006.
                  SELECT SINGLE * FROM t006 INTO wa_t006
                    WHERE msehi = <g>.
* if quantity ref to un-know unit-> default decimal  = 2
                  IF sy-subrc EQ 0.
                    curritem-decimals = wa_t006-decan.
                  ELSE.
                    curritem-decimals = 2.
                  ENDIF.
                  APPEND curritem TO currcells.

                  WRITE <item> TO contentsitem-value
                                      UNIT <g>
                     NO-SIGN NO-GROUPING.
                  CONDENSE contentsitem-value.

                ENDIF.

              ENDIF.                                        ""Y9CK007319
            ENDIF.
            CONDENSE contentsitem-value.

* add function fieldcat-no zero display

            LOOP AT lt_fieldcat_kkblo ASSIGNING <f_fieldcat_line>
            WHERE tabname = l_tabname
            AND   tech NE 'X'
            AND   no_out NE 'X'.
              IF <f_fieldcat_line>-col_pos = semaitem-col_no.
                IF <f_fieldcat_line>-no_zero = 'X'.
                  IF <item> = '0'.
                    CLEAR: contentsitem-value.
                  ENDIF.

* dun display zero in total/subtotal line too

                ELSE.
                  CLEAR: wa_subtot_indexs.
                  READ TABLE lt_subtot_indexs INTO wa_subtot_indexs
                  WITH KEY index = l_save_index.
                  IF sy-subrc = 0 AND <item> = '0'.
                    CLEAR: contentsitem-value.
                  ENDIF.
                ENDIF.
              ENDIF.
            ENDLOOP.
            UNASSIGN: <f_fieldcat_line>.

            IF <item> LT 0.
              SEARCH contentsitem-value FOR 'E'.
              IF sy-fdpos EQ 0.

* use prefix notation for signed numbers

                TRANSLATE contentsitem-value USING '- '.
                CONDENSE contentsitem-value NO-GAPS.
                CONCATENATE '-' contentsitem-value
                           INTO contentsitem-value.
              ELSE.
                CONCATENATE '-' contentsitem-value
                           INTO contentsitem-value.
              ENDIF.
            ENDIF.
            SET COUNTRY space.
* Hier wird nur die korrekte Kommaseparatierung gemacht, wenn die
* Zeichen einer
* Zahl enthalten sind. Das ist für Timestamps, die auch "":"" enthalten.
* Für die
* darf keine Kommaseparierung stattfinden.
* Changing for correction request - Y6BK041073
            IF contentsitem-value CO '0123456789.,-+E '.
              TRANSLATE contentsitem-value USING comma_elim.
            ENDIF.
          ELSE.
            CLEAR contentsitem-value.

* if type is not numeric -> dun display with zero

            WRITE <item> TO contentsitem-value NO-ZERO.

            SHIFT contentsitem-value LEFT DELETING LEADING space.

          ENDIF.
          APPEND contentsitem TO contents.
        ENDIF.
      ENDDO.

      realmit = realmit + 1.
      realoverflow = realoverflow + 1.

      mit = mit + 1.
*   overflow = current row index in content table
      overflow = overflow + 1.
    ENDLOOP.

    UNASSIGN: <f_fieldcat_line>.

* set item range for set_range_data method

    testname = mit / const.
    CONDENSE testname.

    CONCATENATE 'TEST' testname INTO testname.

    realoverflow = realoverflow - 1.
    realmit = realmit - 1.
    help = realoverflow.

    rangeitem-name = testname.
    rangeitem-columns = datareal.
    rangeitem-rows = help.
    APPEND rangeitem TO ranges.

* insert item range dim

    temp2 = rowmax + 1 + li_commentary_rows + realmit - realoverflow.

* items data

    CALL METHOD lo_spreadsheet->insert_range_dim
      EXPORTING
        name     = testname
        top      = temp2
        left     = i_left
        rows     = help
        columns  = datareal
        no_flush = no_flush.

* get columns header contents for set_range_data method
* export columns header only if no columns header option = space

    DATA: rowcount TYPE i.
    DATA: columncount TYPE i.

    IF i_columns_header = 'X'.

* append columns header to contents: hkey

      rowcount = 1.
      DO rowmax TIMES.
        columncount = 1.
        DO hkeycolumns TIMES.
          LOOP AT lt_hkey INTO hkeyitem WHERE col_no = columncount
                                           AND row_no   = rowcount.
          ENDLOOP.
          IF sy-subrc = 0.
            str = hkeyitem-col_name.
            contentsitem-value = hkeyitem-col_name.
          ELSE.
            contentsitem-value = str.
          ENDIF.
          contentsitem-column = columncount.
          contentsitem-row = rowcount.
          APPEND contentsitem TO contents.
          columncount = columncount + 1.
        ENDDO.
        rowcount = rowcount + 1.
      ENDDO.

* incase columns header in multiline

      DATA: rowmaxtemp TYPE i.
      IF rowmax > 1.
        rowmaxtemp = rowmax - 1.
        rowcount = 1.
        DO rowmaxtemp TIMES.
          columncount = 1.
          DO columnmax TIMES.
            contentsitem-column = columncount.
            contentsitem-row    = rowcount.
            contentsitem-value  = ''.
            APPEND contentsitem TO contents.
            columncount = columncount + 1.
          ENDDO.
          rowcount = rowcount + 1.
        ENDDO.
      ENDIF.

* append columns header to contents: vkey

      columncount = 1.
      DO columnmax TIMES.
        LOOP AT lt_vkey INTO vkeyitem WHERE col_no = columncount.
        ENDLOOP.
        contentsitem-value = vkeyitem-col_name.
        contentsitem-row = rowmax.
        contentsitem-column = columncount.
        APPEND contentsitem TO contents.
        columncount = columncount + 1.
      ENDDO.
*--------------------------------------------------------------------*
* set header range for method set_range_data
* insert header keys range dim

      li_head_top = li_commentary_rows + 1.
      li_col_pos = i_left.

* insert range headers

      IF hkeycolumns NE 0.
        rangeitem-name = 'TESTHKEY'.
        rangeitem-rows = rowmax.
        rangeitem-columns = hkeycolumns.
        APPEND rangeitem TO ranges.
        CLEAR: rangeitem.

        CALL METHOD lo_spreadsheet->insert_range_dim
          EXPORTING
            name     = 'TESTHKEY'
            top      = li_head_top
            left     = li_col_pos
            rows     = rowmax
            columns  = hkeycolumns
            no_flush = no_flush.
      ENDIF.
    ENDIF.

* format for columns header + total + subtotal
* ------------------------------------------

    help = rowmax + realmit. "" table + header lines

    DATA: lt_format     TYPE soi_format_table.
    DATA: wa_format     LIKE LINE OF lt_format.
    DATA: wa_format_temp LIKE LINE OF lt_format.

    FIELD-SYMBOLS: <f_source> TYPE any.
    FIELD-SYMBOLS: <f_des>    TYPE any.

* columns header format

    wa_format-front       = -1.
    wa_format-back        = 15. ""grey
    wa_format-font        = space.
    wa_format-size        = -1.
    wa_format-bold        = 1.
    wa_format-align       = 0.
    wa_format-frametyp    = -1.
    wa_format-framecolor  = -1.

* get column header format from input record
* -> map input format

    IF i_columns_header = 'X'.
      wa_format-name        = 'TESTHKEY'.
      IF i_format_col_header IS NOT INITIAL.
        DESCRIBE FIELD i_format_col_header TYPE l_typ COMPONENTS
        li_col_num.
        DO li_col_num TIMES.
          IF sy-index NE 1. "" dun map range name
            ASSIGN COMPONENT sy-index OF STRUCTURE i_format_col_header
            TO <f_source>.
            IF <f_source> IS NOT INITIAL.
              ASSIGN COMPONENT sy-index OF STRUCTURE wa_format TO <f_des>.
              <f_des> = <f_source>.
              UNASSIGN: <f_des>.
            ENDIF.
            UNASSIGN: <f_source>.
          ENDIF.
        ENDDO.

        CLEAR: li_col_num.
      ENDIF.

      APPEND wa_format TO lt_format.
    ENDIF.

* Zusammenfassen der Spalten mit gleicher Nachkommastellenzahl
* collect vertical cells (col)  with the same number of decimal places
* to increase perfomance in currency cell format

    DESCRIBE TABLE currcells LINES lines.
    lines = lines - 1.
    DO lines TIMES.
      DESCRIBE TABLE currcells LINES innerlines.
      innerlines = innerlines - 1.
      SORT currcells BY left top.
      CLEAR found.
      DO innerlines TIMES.
        READ TABLE currcells INDEX sy-index INTO curritem.
        counter = sy-index + 1.
        READ TABLE currcells INDEX counter INTO curritem2.
        IF curritem-left EQ curritem2-left.
          length = curritem-top + curritem-rows.
          IF length EQ curritem2-top AND curritem-decimals EQ curritem2-decimals.
            curritem3 = curritem.
            curritem3-rows = curritem3-rows + curritem2-rows.
            curritem-left = -1.
            MODIFY currcells INDEX sy-index FROM curritem.
            curritem2-left = -1.
            MODIFY currcells INDEX counter FROM curritem2.
            APPEND curritem3 TO currcells.
            found = 'X'.
          ENDIF.
        ENDIF.
      ENDDO.
      IF found IS INITIAL.
        EXIT.
      ENDIF.
      DELETE currcells WHERE left = -1.
    ENDDO.

* Zusammenfassen der Zeilen mit gleicher Nachkommastellenzahl
* collect horizontal cells (row) with the same number of decimal places
* to increase perfomance in currency cell format

    DESCRIBE TABLE currcells LINES lines.
    lines = lines - 1.
    DO lines TIMES.
      DESCRIBE TABLE currcells LINES innerlines.
      innerlines = innerlines - 1.
      SORT currcells BY top left.
      CLEAR found.
      DO innerlines TIMES.
        READ TABLE currcells INDEX sy-index INTO curritem.
        counter = sy-index + 1.
        READ TABLE currcells INDEX counter INTO curritem2.
        IF curritem-top EQ curritem2-top AND curritem-rows EQ
        curritem2-rows.
          length = curritem-left + curritem-columns.
          IF length EQ curritem2-left AND curritem-decimals EQ curritem2-decimals.
            curritem3 = curritem.
            curritem3-columns = curritem3-columns + curritem2-columns.
            curritem-left = -1.
            MODIFY currcells INDEX sy-index FROM curritem.
            curritem2-left = -1.
            MODIFY currcells INDEX counter FROM curritem2.
            APPEND curritem3 TO currcells.
            found = 'X'.
          ENDIF.
        ENDIF.
      ENDDO.
      IF found IS INITIAL.
        EXIT.
      ENDIF.
      DELETE currcells WHERE left = -1.
    ENDDO.
* Ende der Zusammenfassung


* item data: format for currency cell, corresponding with currency

    CALL METHOD lo_spreadsheet->cell_format
      EXPORTING
        cells    = currcells
        no_flush = no_flush.

* item data: write item table content

    CALL METHOD lo_spreadsheet->set_ranges_data
      EXPORTING
        ranges   = ranges
        contents = contents
        no_flush = no_flush.

* whole table range to format all table

    IF i_columns_header = 'X'.
      li_head_top = li_commentary_rows + 1.
    ELSE.
      li_head_top = li_commentary_rows + 2.
      help = help - 1.
    ENDIF.

    CALL METHOD lo_spreadsheet->insert_range_dim
      EXPORTING
        name     = 'WHOLE_TABLE'
        top      = li_head_top
        left     = i_left
        rows     = help
        columns  = datareal
        no_flush = no_flush.

* columns width auto fix
* this parameter = space in case use with exist template

    IF i_columns_autofit = 'X'.
      CALL METHOD lo_spreadsheet->fit_widest
        EXPORTING
          name     = 'WHOLE_TABLE'
          no_flush = no_flush.
    ENDIF.

* frame
* The parameter has 8 bits
*0 Left margin
*1 Top marginT
*2 Bottom margin
*3 Right margin
*4 Horizontal line
*5 Vertical line
*6 Thinness
*7 Thickness
* here 127 = 1111111 6-5-4-3-2-1 mean Thin-ver-hor-right-bot-top-left

* ( final DOI method call, set no_flush = space
* equal to call method CL_GUI_CFW=>FLUSH )

    CALL METHOD lo_spreadsheet->set_frame
      EXPORTING
        rangename = 'WHOLE_TABLE'
        typ       = 127
        color     = 1
        no_flush  = space
      IMPORTING
        error     = lo_error
        retcode   = lc_retcode.

    error_doi( ).

* reformat subtotal / total line after format wholw table

    LOOP AT subranges INTO subrangeitem.
      l_sub_index = subrangeitem-rows + li_commentary_rows + rowmax.

      CALL METHOD lo_spreadsheet->insert_range_dim
        EXPORTING
          name     = subrangeitem-name
          left     = i_left
          top      = l_sub_index
          rows     = 1
          columns  = datareal
          no_flush = no_flush.

      wa_format-name    = subrangeitem-name.

*   default format:
*     - clolor: subtotal = light yellow, subtotal = yellow
*     - frame: box

      IF  subrangeitem-name(3) = 'SUB'.
        wa_format-back = 36. ""subtotal line
        wa_format_temp = i_format_subtotal.
      ELSE.
        wa_format-back = 27. ""total line
        wa_format_temp = i_format_total.
      ENDIF.
      wa_format-frametyp = 79.
      wa_format-framecolor = 1.
      wa_format-number  = -1.
      wa_format-align   = -1.

*   get subtoal + total format from intput parameter
*   overwrite default format

      IF wa_format_temp IS NOT INITIAL.
        DESCRIBE FIELD wa_format_temp TYPE l_typ COMPONENTS li_col_num.
        DO li_col_num TIMES.
          IF sy-index NE 1. "" dun map range name
            ASSIGN COMPONENT sy-index OF STRUCTURE wa_format_temp
            TO <f_source>.
            IF <f_source> IS NOT INITIAL.
              ASSIGN COMPONENT sy-index OF STRUCTURE wa_format TO <f_des>.
              <f_des> = <f_source>.
              UNASSIGN: <f_des>.
            ENDIF.
            UNASSIGN: <f_source>.
          ENDIF.
        ENDDO.

        CLEAR: li_col_num.
      ENDIF.

      APPEND wa_format TO lt_format.
      CLEAR: wa_format-name.
      CLEAR: l_sub_index.
      CLEAR: wa_format_temp.

    ENDLOOP.

    IF lt_format[] IS NOT INITIAL.
      CALL METHOD lo_spreadsheet->set_ranges_format
        EXPORTING
          formattable = lt_format
          no_flush    = no_flush.
      CLEAR lt_format.
    ENDIF.
*--------------------------------------------------------------------*
    CALL METHOD lo_spreadsheet->screen_update
      EXPORTING
        updating = 'X'.

    CALL METHOD c_oi_errors=>flush_errors.

    lo_error_w = l_error.
    lc_retcode = lo_error_w->error_code.

    CLEAR:
      lt_sema,
      wa_sema,
      lt_hkey,
      wa_hkey,
      lt_vkey,
      wa_vkey,
      l_n_hrz_keys,
      l_n_att_cols,
      l_n_vrt_keys,
      count,
      datac,
      datareal,
      vkeycount,
      all,
      mit,
      li_col_pos,
      li_col_num,
      ranges,
      rangeitem,
      contents,
      contentsitem,
      semaitem,
      hkeyitem,
      vkeyitem,
      li_commentary_rows,
      l_retcode,
      li_head_top,
      <f_excel_tab>.

    CLEAR:
       lo_error_w.

    UNASSIGN:
    <line>,
    <item>,
    <f_excel_tab>.

*--------------------------------------------------------------------*
* SESSION 5: SAVE AND CLOSE FILE
*--------------------------------------------------------------------*

* ex of save path: 'FILE://C:\\temp\\test.xlsx'
    CONCATENATE 'FILE://' i_save_path
                INTO ls_path.

    CALL METHOD lo_proxy->save_document_to_url
      EXPORTING
        no_flush      = 'X'
        url           = ls_path
      IMPORTING
        error         = lo_error
        retcode       = lc_retcode
      CHANGING
        document_size = li_document_size.

    error_doi( ).

* if save successfully -> raise successful message
    MESSAGE i400(zabap2xlsx).

    CLEAR:
      ls_path,
      li_document_size.

    close_document( ).
  ENDMETHOD.                    ""BIND_ALV_OLE2


  METHOD close_document.

    DATA: l_is_closed TYPE i.

    CLEAR: l_is_closed.
    IF lo_proxy IS NOT INITIAL.

* check proxy detroyed adi

      CALL METHOD lo_proxy->is_destroyed
        IMPORTING
          ret_value = l_is_closed.

* if dun detroyed yet: close -> release proxy

      IF l_is_closed IS INITIAL.
        CALL METHOD lo_proxy->close_document
          IMPORTING
            error   = lo_error
            retcode = lc_retcode.
      ENDIF.

      CALL METHOD lo_proxy->release_document
        IMPORTING
          error   = lo_error
          retcode = lc_retcode.

    ELSE.
      lc_retcode = c_oi_errors=>ret_document_not_open.
    ENDIF.

* Detroy control container

    IF lo_control IS NOT INITIAL.
      CALL METHOD lo_control->destroy_control.
    ENDIF.

    CLEAR:
      lo_spreadsheet,
      lo_proxy,
      lo_control.

  ENDMETHOD.


  METHOD error_doi.

    IF lc_retcode NE c_oi_errors=>ret_ok.
      close_document( ).
      CALL METHOD lo_error->raise_message
        EXPORTING
          type = 'E'.
      CLEAR: lo_error.
    ENDIF.

  ENDMETHOD.


ENDCLASS.
",15453,True,2924.7738832379773,median
"[[main-component]]
= Main Component
:docTitle: Main
:artifactId: camel-main
:description: Camel Main support
:since: 3.0
:supportLevel: Stable
//Manually maintained attributes
:group: Core

*Since Camel {since}*

This module is used for running Camel standalone via a main class extended from `camel-main`.

== Configuration options

When running Camel via `camel-main` you can configure Camel in the `application.properties` file.

The following table lists all the options:

// main options: START
[width=""100%"",cols=""2,5,^1,2"",options=""header""]
|===
| Name | Description | Default | Type
| *camel.main.allowUseOriginal{zwsp}Message* | Sets whether to allow access to the original message from Camel's error handler, or from org.apache.camel.spi.UnitOfWork.getOriginalInMessage(). Turning this off can optimize performance, as defensive copy of the original message is not needed. Default is false. |  | boolean
| *camel.main.autoConfiguration{zwsp}Enabled* | Whether auto configuration of components, dataformats, languages is enabled or not. When enabled the configuration parameters are loaded from the properties component and optionally from the classpath file META-INF/services/org/apache/camel/autowire.properties. You can prefix the parameters in the properties file with: - camel.component.name.option1=value1 - camel.component.name.option2=value2 - camel.dataformat.name.option1=value1 - camel.dataformat.name.option2=value2 - camel.language.name.option1=value1 - camel.language.name.option2=value2 Where name is the name of the component, dataformat or language such as seda,direct,jaxb. The auto configuration also works for any options on components that is a complex type (not standard Java type) and there has been an explicit single bean instance registered to the Camel registry via the org.apache.camel.spi.Registry#bind(String,Object) method or by using the org.apache.camel.BindToRegistry annotation style. This option is default enabled. | true | boolean
| *camel.main.autoConfiguration{zwsp}EnvironmentVariablesEnabled* | Whether auto configuration should include OS environment variables as well. When enabled this allows to overrule any configuration using an OS environment variable. For example to set a shutdown timeout of 5 seconds: CAMEL_MAIN_SHUTDOWNTIMEOUT=5. This option is default enabled. | true | boolean
| *camel.main.autoConfiguration{zwsp}FailFast* | Whether auto configuration should fail fast when configuring one ore more properties fails for whatever reason such as a invalid property name, etc. This option is default enabled. | true | boolean
| *camel.main.autoConfiguration{zwsp}LogSummary* | Whether auto configuration should log a summary with the configured properties. This option is default enabled. | true | boolean
| *camel.main.autoStartup* | Sets whether the object should automatically start when Camel starts. Important: Currently only routes can be disabled, as CamelContext's are always started. Note: When setting auto startup false on CamelContext then that takes precedence and no routes are started. You would need to start CamelContext explicit using the org.apache.camel.CamelContext.start() method, to start the context, and then you would need to start the routes manually using CamelContext.getRouteController().startRoute(String). Default is true to always start up. | true | boolean
| *camel.main.autowiredEnabled* | Whether autowiring is enabled. This is used for automatic autowiring options (the option must be marked as autowired) by looking up in the registry to find if there is a single instance of matching type, which then gets configured on the component. This can be used for automatic configuring JDBC data sources, JMS connection factories, AWS Clients, etc. Default is true. | true | boolean
| *camel.main.backlogTracing* | Sets whether backlog tracing is enabled or not. Default is false. |  | boolean
| *camel.main.beanIntrospection{zwsp}ExtendedStatistics* | Sets whether bean introspection uses extended statistics. The default is false. |  | boolean
| *camel.main.beanIntrospection{zwsp}LoggingLevel* | Sets the logging level used by bean introspection, logging activity of its usage. The default is TRACE. |  | LoggingLevel
| *camel.main.beanPostProcessor{zwsp}Enabled* | Can be used to turn off bean post processing. Be careful to turn this off, as this means that beans that use Camel annotations such as org.apache.camel.EndpointInject , org.apache.camel.ProducerTemplate , org.apache.camel.Produce , org.apache.camel.Consume etc will not be injected and in use. Turning this off should only be done if you are sure you do not use any of these Camel features. Not all runtimes allow turning this off (such as camel-blueprint or camel-cdi with XML). The default value is true (enabled). | true | boolean
| *camel.main.caseInsensitive{zwsp}Headers* | Whether to use case sensitive or insensitive headers. Important: When using case sensitive (this is set to false). Then the map is case sensitive which means headers such as content-type and Content-Type are two different keys which can be a problem for some protocols such as HTTP based, which rely on case insensitive headers. However case sensitive implementations can yield faster performance. Therefore use case sensitive implementation with care. Default is true. | true | boolean
| *camel.main.configuration{zwsp}Classes* | Sets classes names that will be used to configure the camel context as example by providing custom beans through org.apache.camel.BindToRegistry annotation. |  | String
| *camel.main.configurations* | Sets the configuration objects used to configure the camel context. |  | List
| *camel.main.consumerTemplate{zwsp}CacheSize* | Consumer template endpoints cache size. | 1000 | int
| *camel.main.durationHitExitCode* | Sets the exit code for the application if duration was hit |  | int
| *camel.main.durationMaxIdle{zwsp}Seconds* | To specify for how long time in seconds Camel can be idle before automatic terminating the JVM. You can use this to run Camel for a short while. |  | int
| *camel.main.durationMaxMessages* | To specify how many messages to process by Camel before automatic terminating the JVM. You can use this to run Camel for a short while. |  | int
| *camel.main.durationMaxSeconds* | To specify for how long time in seconds to keep running the JVM before automatic terminating the JVM. You can use this to run Camel for a short while. |  | int
| *camel.main.endpointBasic{zwsp}PropertyBinding* | Whether the endpoint should use basic property binding (Camel 2.x) or the newer property binding with additional capabilities. The default value is false. |  | boolean
| *camel.main.endpointBridgeError{zwsp}Handler* | Allows for bridging the consumer to the Camel routing Error Handler, which mean any exceptions occurred while the consumer is trying to pickup incoming messages, or the likes, will now be processed as a message and handled by the routing Error Handler. By default the consumer will use the org.apache.camel.spi.ExceptionHandler to deal with exceptions, that will be logged at WARN/ERROR level and ignored. The default value is false. |  | boolean
| *camel.main.endpointLazyStart{zwsp}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. The default value is false. |  | boolean
| *camel.main.endpointRuntime{zwsp}StatisticsEnabled* | Sets whether endpoint runtime statistics is enabled (gathers runtime usage of each incoming and outgoing endpoints). The default value is false. |  | boolean
| *camel.main.fileConfigurations* | Directory to load additional configuration files that contains configuration values that takes precedence over any other configuration. This can be used to refer to files that may have secret configuration that has been mounted on the file system for containers. You can specify a pattern to load from sub directories and a name pattern such as /var/app/secret/.properties, multiple directories can be separated by comma. |  | String
| *camel.main.inflightRepository{zwsp}BrowseEnabled* | Sets whether the inflight repository should allow browsing each inflight exchange. This is by default disabled as there is a very slight performance overhead when enabled. |  | boolean
| *camel.main.javaRoutesExclude{zwsp}Pattern* | Used for exclusive filtering component scanning of RouteBuilder classes with Component annotation. The exclusive filtering takes precedence over inclusive filtering. The pattern is using Ant-path style pattern. Multiple patterns can be specified separated by comma. For example to exclude all classes starting with Bar use: &#42;&#42;/Bar&#42; To exclude all routes form a specific package use: com/mycompany/bar/&#42; To exclude all routes form a specific package and its sub-packages use double wildcards: com/mycompany/bar/&#42;&#42; And to exclude all routes from two specific packages use: com/mycompany/bar/&#42;,com/mycompany/stuff/&#42; |  | String
| *camel.main.javaRoutesInclude{zwsp}Pattern* | Used for inclusive filtering component scanning of RouteBuilder classes with Component annotation. The exclusive filtering takes precedence over inclusive filtering. The pattern is using Ant-path style pattern. Multiple patterns can be specified separated by comma. For example to include all classes starting with Foo use: &#42;&#42;/Foo To include all routes form a specific package use: com/mycompany/foo/&#42; To include all routes form a specific package and its sub-packages use double wildcards: com/mycompany/foo/&#42;&#42; And to include all routes from two specific packages use: com/mycompany/foo/&#42;,com/mycompany/stuff/&#42; |  | String
| *camel.main.jmxEnabled* | Enable JMX in your Camel application. | true | boolean
| *camel.main.jmxManagementName{zwsp}Pattern* | The naming pattern for creating the CamelContext JMX management name. The default pattern is #name# | #name# | String
| *camel.main.jmxManagement{zwsp}StatisticsLevel* | Sets the JMX statistics level, the level can be set to Extended to gather additional information The default value is Default. | Default | ManagementStatisticsLevel
| *camel.main.lightweight* | Experimental: Configure the context to be lightweight. This will trigger some optimizations and memory reduction options. Lightweight context have some limitations. At this moment, dynamic endpoint destinations are not supported. |  | boolean
| *camel.main.loadTypeConverters* | Whether to load custom type converters by scanning classpath. This is used for backwards compatibility with Camel 2.x. Its recommended to migrate to use fast type converter loading by setting Converter(loader = true) on your custom type converter classes. |  | boolean
| *camel.main.logDebugMaxChars* | Is used to limit the maximum length of the logging Camel message bodies. If the message body is longer than the limit, the log message is clipped. Use -1 to have unlimited length. Use for example 1000 to log at most 1000 characters. |  | int
| *camel.main.logExhaustedMessage{zwsp}Body* | Sets whether to log exhausted message body with message history. Default is false. |  | boolean
| *camel.main.logMask* | Sets whether log mask is enabled or not. Default is false. |  | boolean
| *camel.main.mdcLoggingKeys{zwsp}Pattern* | Sets the pattern used for determine which custom MDC keys to propagate during message routing when the routing engine continues routing asynchronously for the given message. Setting this pattern to will propagate all custom keys. Or setting the pattern to foo,bar will propagate any keys starting with either foo or bar. Notice that a set of standard Camel MDC keys are always propagated which starts with camel. as key name. The match rules are applied in this order (case insensitive): 1. exact match, returns true 2. wildcard match (pattern ends with a and the name starts with the pattern), returns true 3. regular expression match, returns true 4. otherwise returns false |  | String
| *camel.main.messageHistory* | Sets whether message history is enabled or not. Default is false. |  | boolean
| *camel.main.name* | Sets the name of the CamelContext. |  | String
| *camel.main.packageScanRoute{zwsp}Builders* | Sets package names for scanning for org.apache.camel.builder.RouteBuilder classes as candidates to be included. If you are using Spring Boot then its instead recommended to use Spring Boots component scanning and annotate your route builder classes with Component. In other words only use this for Camel Main in standalone mode. |  | String
| *camel.main.producerTemplate{zwsp}CacheSize* | Producer template endpoints cache size. | 1000 | int
| *camel.main.routeControllerBack{zwsp}OffDelay* | Backoff delay in millis when restarting a route that failed to startup. |  | long
| *camel.main.routeControllerBack{zwsp}OffMaxAttempts* | Backoff maximum number of attempts to restart a route that failed to startup. When this threshold has been exceeded then the controller will give up attempting to restart the route, and the route will remain as stopped. |  | long
| *camel.main.routeControllerBack{zwsp}OffMaxDelay* | Backoff maximum delay in millis when restarting a route that failed to startup. |  | long
| *camel.main.routeControllerBack{zwsp}OffMaxElapsedTime* | Backoff maximum elapsed time in millis, after which the backoff should be considered exhausted and no more attempts should be made. |  | long
| *camel.main.routeControllerBack{zwsp}OffMultiplier* | Backoff multiplier to use for exponential backoff. This is used to extend the delay between restart attempts. |  | double
| *camel.main.routeController{zwsp}ExcludeRoutes* | Pattern for filtering routes to be excluded as supervised. The pattern is matching on route id, and endpoint uri for the route. Multiple patterns can be separated by comma. For example to exclude all JMS routes, you can say jms:. And to exclude routes with specific route ids mySpecialRoute,myOtherSpecialRoute. The pattern supports wildcards and uses the matcher from org.apache.camel.support.PatternHelper#matchPattern. |  | String
| *camel.main.routeController{zwsp}IncludeRoutes* | Pattern for filtering routes to be included as supervised. The pattern is matching on route id, and endpoint uri for the route. Multiple patterns can be separated by comma. For example to include all kafka routes, you can say kafka:. And to include routes with specific route ids myRoute,myOtherRoute. The pattern supports wildcards and uses the matcher from org.apache.camel.support.PatternHelper#matchPattern. |  | String
| *camel.main.routeController{zwsp}InitialDelay* | Initial delay in milli seconds before the route controller starts, after CamelContext has been started. |  | long
| *camel.main.routeController{zwsp}RouteStartupLoggingLevel* | Sets the logging level used for logging route startup activity. By default INFO level is used. You can use this to change the level for example to OFF if this kind of logging is not wanted. | INFO | LoggingLevel
| *camel.main.routeController{zwsp}SuperviseEnabled* | To enable using supervising route controller which allows Camel to startup and then the controller takes care of starting the routes in a safe manner. This can be used when you want to startup Camel despite a route may otherwise fail fast during startup and cause Camel to fail to startup as well. By delegating the route startup to the supervising route controller then its manages the startup using a background thread. The controller allows to be configured with various settings to attempt to restart failing routes. |  | boolean
| *camel.main.routeController{zwsp}ThreadPoolSize* | The number of threads used by the route controller scheduled thread pool that are used for restarting routes. The pool uses 1 thread by default, but you can increase this to allow the controller to concurrently attempt to restart multiple routes in case more than one route has problems starting. |  | int
| *camel.main.routeController{zwsp}UnhealthyOnExhausted* | Whether to mark the route as unhealthy (down) when all restarting attempts (backoff) have failed and the route is not successfully started and the route manager is giving up. Setting this to true allows health checks to know about this and can report the Camel application as DOWN. The default is false. |  | boolean
| *camel.main.routeFilterExclude{zwsp}Pattern* | Used for filtering routes routes matching the given pattern, which follows the following rules: - Match by route id - Match by route input endpoint uri The matching is using exact match, by wildcard and regular expression as documented by PatternHelper#matchPattern(String,String) . For example to only include routes which starts with foo in their route id's, use: include=foo&#42; And to exclude routes which starts from JMS endpoints, use: exclude=jms:&#42; Multiple patterns can be separated by comma, for example to exclude both foo and bar routes, use: exclude=foo&#42;,bar&#42; Exclude takes precedence over include. |  | String
| *camel.main.routeFilterInclude{zwsp}Pattern* | Used for filtering routes matching the given pattern, which follows the following rules: - Match by route id - Match by route input endpoint uri The matching is using exact match, by wildcard and regular expression as documented by PatternHelper#matchPattern(String,String) . For example to only include routes which starts with foo in their route id's, use: include=foo&#42; And to exclude routes which starts from JMS endpoints, use: exclude=jms:&#42; Multiple patterns can be separated by comma, for example to exclude both foo and bar routes, use: exclude=foo&#42;,bar&#42; Exclude takes precedence over include. |  | String
| *camel.main.routesBuilder{zwsp}Classes* | Sets classes names that implement RoutesBuilder . |  | String
| *camel.main.routesBuilders* | Sets the RoutesBuilder instances. |  | List
| *camel.main.routesCollector{zwsp}Enabled* | Whether the routes collector is enabled or not. When enabled Camel will auto-discover routes (RouteBuilder instances from the registry and also load additional XML routes from the file system. The routes collector is default enabled. | true | boolean
| *camel.main.shutdownLogInflight{zwsp}ExchangesOnTimeout* | Sets whether to log information about the inflight Exchanges which are still running during a shutdown which didn't complete without the given timeout. This requires to enable the option inflightRepositoryBrowseEnabled. | true | boolean
| *camel.main.shutdownNowOn{zwsp}Timeout* | Sets whether to force shutdown of all consumers when a timeout occurred and thus not all consumers was shutdown within that period. You should have good reasons to set this option to false as it means that the routes keep running and is halted abruptly when CamelContext has been shutdown. | true | boolean
| *camel.main.shutdownRoutesIn{zwsp}ReverseOrder* | Sets whether routes should be shutdown in reverse or the same order as they were started. | true | boolean
| *camel.main.shutdownSuppress{zwsp}LoggingOnTimeout* | Whether Camel should try to suppress logging during shutdown and timeout was triggered, meaning forced shutdown is happening. And during forced shutdown we want to avoid logging errors/warnings et all in the logs as a side-effect of the forced timeout. Notice the suppress is a best effort as there may still be some logs coming from 3rd party libraries and whatnot, which Camel cannot control. This option is default false. |  | boolean
| *camel.main.shutdownTimeout* | Timeout in seconds to graceful shutdown Camel. | 45 | int
| *camel.main.streamCachingAny{zwsp}SpoolRules* | Sets whether if just any of the org.apache.camel.spi.StreamCachingStrategy.SpoolRule rules returns true then shouldSpoolCache(long) returns true, to allow spooling to disk. If this option is false, then all the org.apache.camel.spi.StreamCachingStrategy.SpoolRule must return true. The default value is false which means that all the rules must return true. |  | boolean
| *camel.main.streamCachingBuffer{zwsp}Size* | Sets the stream caching buffer size to use when allocating in-memory buffers used for in-memory stream caches. The default size is 4096. |  | int
| *camel.main.streamCaching{zwsp}Enabled* | Sets whether stream caching is enabled or not. Default is false. |  | boolean
| *camel.main.streamCachingRemove{zwsp}SpoolDirectoryWhenStopping* | Whether to remove stream caching temporary directory when stopping. This option is default true. | true | boolean
| *camel.main.streamCachingSpool{zwsp}Cipher* | Sets a stream caching cipher name to use when spooling to disk to write with encryption. By default the data is not encrypted. |  | String
| *camel.main.streamCachingSpool{zwsp}Directory* | Sets the stream caching spool (temporary) directory to use for overflow and spooling to disk. If no spool directory has been explicit configured, then a temporary directory is created in the java.io.tmpdir directory. |  | String
| *camel.main.streamCachingSpool{zwsp}Threshold* | Stream caching threshold in bytes when overflow to disk is activated. The default threshold is 128kb. Use -1 to disable overflow to disk. |  | long
| *camel.main.streamCachingSpool{zwsp}UsedHeapMemoryLimit* | Sets what the upper bounds should be when streamCachingSpoolUsedHeapMemoryThreshold is in use. |  | String
| *camel.main.streamCachingSpool{zwsp}UsedHeapMemoryThreshold* | Sets a percentage (1-99) of used heap memory threshold to activate stream caching spooling to disk. |  | int
| *camel.main.streamCaching{zwsp}StatisticsEnabled* | Sets whether stream caching statistics is enabled. |  | boolean
| *camel.main.threadNamePattern* | Sets the thread name pattern used for creating the full thread name. The default pattern is: Camel (#camelId#) thread ##counter# - #name# Where #camelId# is the name of the CamelContext. and #counter# is a unique incrementing counter. and #name# is the regular thread name. You can also use #longName# which is the long thread name which can includes endpoint parameters etc. |  | String
| *camel.main.tracing* | Sets whether tracing is enabled or not. Default is false. |  | boolean
| *camel.main.tracingPattern* | Tracing pattern to match which node EIPs to trace. For example to match all To EIP nodes, use to. The pattern matches by node and route id's Multiple patterns can be separated by comma. |  | String
| *camel.main.useBreadcrumb* | Set whether breadcrumb is enabled. The default value is false. |  | boolean
| *camel.main.useDataType* | Whether to enable using data type on Camel messages. Data type are automatic turned on if one ore more routes has been explicit configured with input and output types. Otherwise data type is default off. |  | boolean
| *camel.main.useMdcLogging* | To turn on MDC logging |  | boolean
| *camel.main.xmlRests* | Directory to scan for adding additional XML rests. You can turn this off by setting the value to false. Files can be loaded from either classpath or file by prefixing with classpath: or file: Wildcards is supported using a ANT pattern style paths, such as classpath:&#42;&#42;/&#42;camel&#42;.xml Notice when using wildcards, then there is additional overhead as the classpath is scanned, where as if you specific the exact name for each XML file is faster as no classpath scanning is needed. Multiple directories can be specified and separated by comma, such as: file:/myapp/mycamel/&#42;.xml,file:/myapp/myothercamel/&#42;.xml | classpath:camel-rest/*.xml | String
| *camel.main.xmlRoutes* | Directory to scan for adding additional XML routes. You can turn this off by setting the value to false. Files can be loaded from either classpath or file by prefixing with classpath: or file: Wildcards is supported using a ANT pattern style paths, such as classpath:&#42;&#42;/&#42;camel&#42;.xml Notice when using wildcards, then there is additional overhead as the classpath is scanned, where as if you specific the exact name for each XML file is faster as no classpath scanning is needed. Multiple directories can be specified and separated by comma, such as: file:/myapp/mycamel/&#42;.xml,file:/myapp/myothercamel/&#42;.xml | classpath:camel/*.xml | String
| *camel.main.xmlRouteTemplates* | Directory to scan for adding additional XML route templates. You can turn this off by setting the value to false. Files can be loaded from either classpath or file by prefixing with classpath: or file: Wildcards is supported using a ANT pattern style paths, such as classpath:&#42;&#42;/&#42;template-&#42;.xml Notice when using wildcards, then there is additional overhead as the classpath is scanned, where as if you specific the exact name for each XML file is faster as no classpath scanning is needed. Multiple directories can be specified and separated by comma, such as: file:/myapp/mycamel/&#42;.xml,file:/myapp/myothercamel/&#42;.xml | classpath:camel-template/*.xml | String
| *camel.faulttolerance.bulkhead{zwsp}Enabled* | Whether bulkhead is enabled or not on the circuit breaker. Default is false. | false | Boolean
| *camel.faulttolerance.bulkhead{zwsp}ExecutorServiceRef* | References to a custom thread pool to use when bulkhead is enabled. |  | String
| *camel.faulttolerance.bulkhead{zwsp}MaxConcurrentCalls* | Configures the max amount of concurrent calls the bulkhead will support. Default value is 10. | 10 | Integer
| *camel.faulttolerance.bulkhead{zwsp}WaitingTaskQueue* | Configures the task queue size for holding waiting tasks to be processed by the bulkhead. Default value is 10. | 10 | Integer
| *camel.faulttolerance.circuit{zwsp}BreakerRef* | Refers to an existing io.smallrye.faulttolerance.core.circuit.breaker.CircuitBreaker instance to lookup and use from the registry. When using this, then any other circuit breaker options are not in use. |  | String
| *camel.faulttolerance.delay* | Control how long the circuit breaker stays open. The value are in seconds and the default is 5 seconds. | 5 | Long
| *camel.faulttolerance.failure{zwsp}Ratio* | Configures the failure rate threshold in percentage. If the failure rate is equal or greater than the threshold the CircuitBreaker transitions to open and starts short-circuiting calls. The threshold must be greater than 0 and not greater than 100. Default value is 50 percentage. | 50 | Integer
| *camel.faulttolerance.request{zwsp}VolumeThreshold* | Controls the size of the rolling window used when the circuit breaker is closed Default value is 20. | 20 | Integer
| *camel.faulttolerance.success{zwsp}Threshold* | Controls the number of trial calls which are allowed when the circuit breaker is half-open Default value is 1. | 1 | Integer
| *camel.faulttolerance.timeout{zwsp}Duration* | Configures the thread execution timeout. Default value is 1000 milliseconds. | 1000 | Long
| *camel.faulttolerance.timeout{zwsp}Enabled* | Whether timeout is enabled or not on the circuit breaker. Default is false. | false | Boolean
| *camel.faulttolerance.timeout{zwsp}PoolSize* | Configures the pool size of the thread pool when timeout is enabled. Default value is 10. | 10 | Integer
| *camel.faulttolerance.timeout{zwsp}ScheduledExecutorServiceRef* | References to a custom thread pool to use when timeout is enabled |  | String
| *camel.health.config* | Set additional HealthConfigurationProperties for fine grained configuration of health checks. |  | Map
| *camel.health.contextEnabled* | Whether context health check is enabled | true | Boolean
| *camel.health.enabled* | Whether health check is enabled globally | true | Boolean
| *camel.health.registryEnabled* | Whether registry health check is enabled | true | Boolean
| *camel.health.routesEnabled* | Whether routes health check is enabled | true | Boolean
| *camel.hystrix.allowMaximumSize{zwsp}ToDivergeFromCoreSize* | Allows the configuration for maximumSize to take effect. That value can then be equal to, or higher, than coreSize |  | Boolean
| *camel.hystrix.circuitBreaker{zwsp}Enabled* | Whether to use a HystrixCircuitBreaker or not. If false no circuit-breaker logic will be used and all requests permitted. This is similar in effect to circuitBreakerForceClosed() except that continues tracking metrics and knowing whether it should be open/closed, this property results in not even instantiating a circuit-breaker. |  | Boolean
| *camel.hystrix.circuitBreaker{zwsp}ErrorThresholdPercentage* | Error percentage threshold (as whole number such as 50) at which point the circuit breaker will trip open and reject requests. It will stay tripped for the duration defined in circuitBreakerSleepWindowInMilliseconds; The error percentage this is compared against comes from HystrixCommandMetrics.getHealthCounts(). |  | Integer
| *camel.hystrix.circuitBreaker{zwsp}ForceClosed* | If true the HystrixCircuitBreaker#allowRequest() will always return true to allow requests regardless of the error percentage from HystrixCommandMetrics.getHealthCounts(). The circuitBreakerForceOpen() property takes precedence so if it set to true this property does nothing. |  | Boolean
| *camel.hystrix.circuitBreaker{zwsp}ForceOpen* | If true the HystrixCircuitBreaker.allowRequest() will always return false, causing the circuit to be open (tripped) and reject all requests. This property takes precedence over circuitBreakerForceClosed(); |  | Boolean
| *camel.hystrix.circuitBreaker{zwsp}RequestVolumeThreshold* | Minimum number of requests in the metricsRollingStatisticalWindowInMilliseconds() that must exist before the HystrixCircuitBreaker will trip. If below this number the circuit will not trip regardless of error percentage. |  | Integer
| *camel.hystrix.circuitBreaker{zwsp}SleepWindowInMilliseconds* | The time in milliseconds after a HystrixCircuitBreaker trips open that it should wait before trying requests again. |  | Integer
| *camel.hystrix.corePoolSize* | Core thread-pool size that gets passed to java.util.concurrent.ThreadPoolExecutor#setCorePoolSize(int) |  | Integer
| *camel.hystrix.execution{zwsp}IsolationSemaphoreMax{zwsp}ConcurrentRequests* | Number of concurrent requests permitted to HystrixCommand.run(). Requests beyond the concurrent limit will be rejected. Applicable only when executionIsolationStrategy == SEMAPHORE. |  | Integer
| *camel.hystrix.execution{zwsp}IsolationStrategy* | What isolation strategy HystrixCommand.run() will be executed with. If THREAD then it will be executed on a separate thread and concurrent requests limited by the number of threads in the thread-pool. If SEMAPHORE then it will be executed on the calling thread and concurrent requests limited by the semaphore count. |  | String
| *camel.hystrix.execution{zwsp}IsolationThreadInterruptOn{zwsp}Timeout* | Whether the execution thread should attempt an interrupt (using Future#cancel ) when a thread times out. Applicable only when executionIsolationStrategy() == THREAD. |  | Boolean
| *camel.hystrix.executionTimeout{zwsp}Enabled* | Whether the timeout mechanism is enabled for this command |  | Boolean
| *camel.hystrix.executionTimeout{zwsp}InMilliseconds* | Time in milliseconds at which point the command will timeout and halt execution. If executionIsolationThreadInterruptOnTimeout == true and the command is thread-isolated, the executing thread will be interrupted. If the command is semaphore-isolated and a HystrixObservableCommand, that command will get unsubscribed. |  | Integer
| *camel.hystrix.fallbackEnabled* | Whether HystrixCommand.getFallback() should be attempted when failure occurs. |  | Boolean
| *camel.hystrix.fallback{zwsp}IsolationSemaphoreMax{zwsp}ConcurrentRequests* | Number of concurrent requests permitted to HystrixCommand.getFallback(). Requests beyond the concurrent limit will fail-fast and not attempt retrieving a fallback. |  | Integer
| *camel.hystrix.groupKey* | Sets the group key to use. The default value is CamelHystrix. |  | String
| *camel.hystrix.keepAliveTime* | Keep-alive time in minutes that gets passed to ThreadPoolExecutor#setKeepAliveTime(long,TimeUnit) |  | Integer
| *camel.hystrix.maximumSize* | Maximum thread-pool size that gets passed to ThreadPoolExecutor#setMaximumPoolSize(int) . This is the maximum amount of concurrency that can be supported without starting to reject HystrixCommands. Please note that this setting only takes effect if you also set allowMaximumSizeToDivergeFromCoreSize |  | Integer
| *camel.hystrix.maxQueueSize* | Max queue size that gets passed to BlockingQueue in HystrixConcurrencyStrategy.getBlockingQueue(int) This should only affect the instantiation of a threadpool - it is not eliglible to change a queue size on the fly. For that, use queueSizeRejectionThreshold(). |  | Integer
| *camel.hystrix.metricsHealth{zwsp}SnapshotIntervalInMilliseconds* | Time in milliseconds to wait between allowing health snapshots to be taken that calculate success and error percentages and affect HystrixCircuitBreaker.isOpen() status. On high-volume circuits the continual calculation of error percentage can become CPU intensive thus this controls how often it is calculated. |  | Integer
| *camel.hystrix.metricsRolling{zwsp}PercentileBucketSize* | Maximum number of values stored in each bucket of the rolling percentile. This is passed into HystrixRollingPercentile inside HystrixCommandMetrics. |  | Integer
| *camel.hystrix.metricsRolling{zwsp}PercentileEnabled* | Whether percentile metrics should be captured using HystrixRollingPercentile inside HystrixCommandMetrics. |  | Boolean
| *camel.hystrix.metricsRolling{zwsp}PercentileWindowBuckets* | Number of buckets the rolling percentile window is broken into. This is passed into HystrixRollingPercentile inside HystrixCommandMetrics. |  | Integer
| *camel.hystrix.metricsRolling{zwsp}PercentileWindowInMilliseconds* | Duration of percentile rolling window in milliseconds. This is passed into HystrixRollingPercentile inside HystrixCommandMetrics. |  | Integer
| *camel.hystrix.metricsRolling{zwsp}StatisticalWindowBuckets* | Number of buckets the rolling statistical window is broken into. This is passed into HystrixRollingNumber inside HystrixCommandMetrics. |  | Integer
| *camel.hystrix.metricsRolling{zwsp}StatisticalWindowIn{zwsp}Milliseconds* | This property sets the duration of the statistical rolling window, in milliseconds. This is how long metrics are kept for the thread pool. The window is divided into buckets and rolls by those increments. |  | Integer
| *camel.hystrix.queueSize{zwsp}RejectionThreshold* | Queue size rejection threshold is an artificial max size at which rejections will occur even if maxQueueSize has not been reached. This is done because the maxQueueSize of a BlockingQueue can not be dynamically changed and we want to support dynamically changing the queue size that affects rejections. This is used by HystrixCommand when queuing a thread for execution. |  | Integer
| *camel.hystrix.requestLog{zwsp}Enabled* | Whether HystrixCommand execution and events should be logged to HystrixRequestLog. |  | Boolean
| *camel.hystrix.threadPoolKey* | Sets the thread pool key to use. Will by default use the same value as groupKey has been configured to use. |  | String
| *camel.hystrix.threadPool{zwsp}RollingNumberStatisticalWindow{zwsp}Buckets* | Number of buckets the rolling statistical window is broken into. This is passed into HystrixRollingNumber inside each HystrixThreadPoolMetrics instance. |  | Integer
| *camel.hystrix.threadPool{zwsp}RollingNumberStatisticalWindow{zwsp}InMilliseconds* | Duration of statistical rolling window in milliseconds. This is passed into HystrixRollingNumber inside each HystrixThreadPoolMetrics instance. |  | Integer
| *camel.lra.coordinatorContext{zwsp}Path* | The context-path for the LRA coordinator. Is default /lra-coordinator | /lra-coordinator | String
| *camel.lra.coordinatorUrl* | The URL for the LRA coordinator service that orchestrates the transactions |  | String
| *camel.lra.localParticipant{zwsp}ContextPath* | The context-path for the local participant. Is default /lra-participant | /lra-participant | String
| *camel.lra.localParticipantUrl* | The URL for the local participant |  | String
| *camel.resilience4j.automatic{zwsp}TransitionFromOpenToHalfOpen{zwsp}Enabled* | Enables automatic transition from OPEN to HALF_OPEN state once the waitDurationInOpenState has passed. |  | Boolean
| *camel.resilience4j.bulkhead{zwsp}Enabled* | Whether bulkhead is enabled or not on the circuit breaker. | false | Boolean
| *camel.resilience4j.bulkheadMax{zwsp}ConcurrentCalls* | Configures the max amount of concurrent calls the bulkhead will support. |  | Integer
| *camel.resilience4j.bulkheadMax{zwsp}WaitDuration* | Configures a maximum amount of time which the calling thread will wait to enter the bulkhead. If bulkhead has space available, entry is guaranteed and immediate. If bulkhead is full, calling threads will contest for space, if it becomes available. maxWaitDuration can be set to 0. Note: for threads running on an event-loop or equivalent (rx computation pool, etc), setting maxWaitDuration to 0 is highly recommended. Blocking an event-loop thread will most likely have a negative effect on application throughput. |  | Integer
| *camel.resilience4j.circuit{zwsp}BreakerRef* | Refers to an existing io.github.resilience4j.circuitbreaker.CircuitBreaker instance to lookup and use from the registry. When using this, then any other circuit breaker options are not in use. |  | String
| *camel.resilience4j.configRef* | Refers to an existing io.github.resilience4j.circuitbreaker.CircuitBreakerConfig instance to lookup and use from the registry. |  | String
| *camel.resilience4j.failureRate{zwsp}Threshold* | Configures the failure rate threshold in percentage. If the failure rate is equal or greater than the threshold the CircuitBreaker transitions to open and starts short-circuiting calls. The threshold must be greater than 0 and not greater than 100. Default value is 50 percentage. | 50 | Float
| *camel.resilience4j.minimum{zwsp}NumberOfCalls* | Configures configures the minimum number of calls which are required (per sliding window period) before the CircuitBreaker can calculate the error rate. For example, if minimumNumberOfCalls is 10, then at least 10 calls must be recorded, before the failure rate can be calculated. If only 9 calls have been recorded the CircuitBreaker will not transition to open even if all 9 calls have failed. Default minimumNumberOfCalls is 100 | 100 | Integer
| *camel.resilience4j.permitted{zwsp}NumberOfCallsInHalfOpenState* | Configures the number of permitted calls when the CircuitBreaker is half open. The size must be greater than 0. Default size is 10. | 10 | Integer
| *camel.resilience4j.sliding{zwsp}WindowSize* | Configures the size of the sliding window which is used to record the outcome of calls when the CircuitBreaker is closed. slidingWindowSize configures the size of the sliding window. Sliding window can either be count-based or time-based. If slidingWindowType is COUNT_BASED, the last slidingWindowSize calls are recorded and aggregated. If slidingWindowType is TIME_BASED, the calls of the last slidingWindowSize seconds are recorded and aggregated. The slidingWindowSize must be greater than 0. The minimumNumberOfCalls must be greater than 0. If the slidingWindowType is COUNT_BASED, the minimumNumberOfCalls cannot be greater than slidingWindowSize . If the slidingWindowType is TIME_BASED, you can pick whatever you want. Default slidingWindowSize is 100. | 100 | Integer
| *camel.resilience4j.sliding{zwsp}WindowType* | Configures the type of the sliding window which is used to record the outcome of calls when the CircuitBreaker is closed. Sliding window can either be count-based or time-based. If slidingWindowType is COUNT_BASED, the last slidingWindowSize calls are recorded and aggregated. If slidingWindowType is TIME_BASED, the calls of the last slidingWindowSize seconds are recorded and aggregated. Default slidingWindowType is COUNT_BASED. | COUNT_BASED | String
| *camel.resilience4j.slowCall{zwsp}DurationThreshold* | Configures the duration threshold (seconds) above which calls are considered as slow and increase the slow calls percentage. Default value is 60 seconds. | 60 | Integer
| *camel.resilience4j.slowCall{zwsp}RateThreshold* | Configures a threshold in percentage. The CircuitBreaker considers a call as slow when the call duration is greater than slowCallDurationThreshold(Duration. When the percentage of slow calls is equal or greater the threshold, the CircuitBreaker transitions to open and starts short-circuiting calls. The threshold must be greater than 0 and not greater than 100. Default value is 100 percentage which means that all recorded calls must be slower than slowCallDurationThreshold. | 100 | Float
| *camel.resilience4j.timeout{zwsp}CancelRunningFuture* | Configures whether cancel is called on the running future. Defaults to true. | true | Boolean
| *camel.resilience4j.timeout{zwsp}Duration* | Configures the thread execution timeout (millis). Default value is 1000 millis (1 second). | 1000 | Integer
| *camel.resilience4j.timeout{zwsp}Enabled* | Whether timeout is enabled or not on the circuit breaker. Default is false. | false | Boolean
| *camel.resilience4j.timeout{zwsp}ExecutorServiceRef* | References to a custom thread pool to use when timeout is enabled (uses ForkJoinPool#commonPool() by default) |  | String
| *camel.resilience4j.wait{zwsp}DurationInOpenState* | Configures the wait duration (in seconds) which specifies how long the CircuitBreaker should stay open, before it switches to half open. Default value is 60 seconds. | 60 | Integer
| *camel.resilience4j.writable{zwsp}StackTraceEnabled* | Enables writable stack traces. When set to false, Exception.getStackTrace returns a zero length array. This may be used to reduce log spam when the circuit breaker is open as the cause of the exceptions is already known (the circuit breaker is short-circuiting calls). |  | Boolean
| *camel.rest.apiComponent* | Sets the name of the Camel component to use as the REST API (such as swagger or openapi) |  | String
| *camel.rest.apiContextIdPattern* | Optional CamelContext id pattern to only allow Rest APIs from rest services within CamelContext's which name matches the pattern. The pattern #name# refers to the CamelContext name, to match on the current CamelContext only. For any other value, the pattern uses the rules from org.apache.camel.support.EndpointHelper#matchPattern(String,String) |  | String
| *camel.rest.apiContextListing* | Sets whether listing of all available CamelContext's with REST services in the JVM is enabled. If enabled it allows to discover these contexts, if false then only the current CamelContext is in use. |  | boolean
| *camel.rest.apiContextPath* | Sets a leading API context-path the REST API services will be using. This can be used when using components such as camel-servlet where the deployed web application is deployed using a context-path. |  | String
| *camel.rest.apiContextRouteId* | Sets the route id to use for the route that services the REST API. The route will by default use an auto assigned route id. |  | String
| *camel.rest.apiHost* | To use an specific hostname for the API documentation (eg swagger) This can be used to override the generated host with this configured hostname |  | String
| *camel.rest.apiProperties* | Sets additional options on api level |  | Map
| *camel.rest.apiVendorExtension* | Whether vendor extension is enabled in the Rest APIs. If enabled then Camel will include additional information as vendor extension (eg keys starting with x-) such as route ids, class names etc. Not all 3rd party API gateways and tools supports vendor-extensions when importing your API docs. |  | boolean
| *camel.rest.bindingMode* | Sets the binding mode to be used by the REST consumer | RestBindingMode.off | RestBindingMode
| *camel.rest.clientRequest{zwsp}Validation* | Whether to enable validation of the client request to check whether the Content-Type and Accept headers from the client is supported by the Rest-DSL configuration of its consumes/produces settings. This can be turned on, to enable this check. In case of validation error, then HTTP Status codes 415 or 406 is returned. The default value is false. |  | boolean
| *camel.rest.component* | Sets the name of the Camel component to use as the REST consumer |  | String
| *camel.rest.componentProperties* | Sets additional options on component level |  | Map
| *camel.rest.consumerProperties* | Sets additional options on consumer level |  | Map
| *camel.rest.contextPath* | Sets a leading context-path the REST services will be using. This can be used when using components such as camel-servlet where the deployed web application is deployed using a context-path. Or for components such as camel-jetty or camel-netty-http that includes a HTTP server. |  | String
| *camel.rest.corsHeaders* | Sets the CORS headers to use if CORS has been enabled. |  | Map
| *camel.rest.dataFormat{zwsp}Properties* | Sets additional options on data format level |  | Map
| *camel.rest.enableCORS* | To specify whether to enable CORS which means Camel will automatic include CORS in the HTTP headers in the response. This option is default false |  | boolean
| *camel.rest.endpointProperties* | Sets additional options on endpoint level |  | Map
| *camel.rest.host* | Sets the hostname to use by the REST consumer |  | String
| *camel.rest.hostNameResolver* | Sets the resolver to use for resolving hostname | RestHostNameResolver.allLocalIp | RestHostNameResolver
| *camel.rest.jsonDataFormat* | Sets a custom json data format to be used Important: This option is only for setting a custom name of the data format, not to refer to an existing data format instance. |  | String
| *camel.rest.port* | Sets the port to use by the REST consumer |  | int
| *camel.rest.producerApiDoc* | Sets the location of the api document (swagger api) the REST producer will use to validate the REST uri and query parameters are valid accordingly to the api document. This requires adding camel-swagger-java to the classpath, and any miss configuration will let Camel fail on startup and report the error(s). The location of the api document is loaded from classpath by default, but you can use file: or http: to refer to resources to load from file or http url. |  | String
| *camel.rest.producerComponent* | Sets the name of the Camel component to use as the REST producer |  | String
| *camel.rest.scheme* | Sets the scheme to use by the REST consumer |  | String
| *camel.rest.skipBindingOnError{zwsp}Code* | Whether to skip binding output if there is a custom HTTP error code, and instead use the response body as-is. This option is default true. | true | boolean
| *camel.rest.useXForwardHeaders* | WWhether to use X-Forward headers to set host etc. for Swagger. This option is default true. | true | boolean
| *camel.rest.xmlDataFormat* | Sets a custom xml data format to be used. Important: This option is only for setting a custom name of the data format, not to refer to an existing data format instance. |  | String
| *camel.threadpool.allowCore{zwsp}ThreadTimeOut* | Sets default whether to allow core threads to timeout |  | Boolean
| *camel.threadpool.config* | Adds a configuration for a specific thread pool profile (inherits default values) |  | Map
| *camel.threadpool.keepAliveTime* | Sets the default keep alive time for inactive threads |  | Long
| *camel.threadpool.maxPoolSize* | Sets the default maximum pool size |  | Integer
| *camel.threadpool.maxQueueSize* | Sets the default maximum number of tasks in the work queue. Use -1 or an unbounded queue |  | Integer
| *camel.threadpool.poolSize* | Sets the default core pool size (threads to keep minimum in pool) |  | Integer
| *camel.threadpool.rejected{zwsp}Policy* | Sets the default handler for tasks which cannot be executed by the thread pool. |  | ThreadPoolRejectedPolicy
| *camel.threadpool.timeUnit* | Sets the default time unit used for keep alive time |  | TimeUnit
|===
// main options: END

== Specifying custom beans

Custom beans can be configured in `camel-main` via properties (such as in the `application.properties` file).

For example to create a `DataSource` for a Postgress database, you can create a new bean instance via `#class:` with the class name (fully qualified).
Properties on the data source can then additional configured such as the server and database name, etc.

[source,properties]
----
camel.beans.myDS = #class:org.postgresql.jdbc3.Jdbc3PoolingDataSource
camel.beans.myDS.dataSourceName = myDS
camel.beans.myDS.serverName = mypostrgress
camel.beans.myDS.databaseName = test
camel.beans.myDS.user = testuser
camel.beans.myDS.password = testpassword
camel.beans.myDS.maxConnections = 10
----

The bean is registered in the Camel Registry with the name `myDS`.

If you use the SQL component then the datasource can be configured on the SQL component:

[source,properties]
----
camel.component.sql.dataSource = #myDS
----

To refer to a custom bean you may want to favour using `#bean:` style, as this states the intention more clearly that its referring to a bean,
and not just a text value that happens to start with a `#` sign:

[source,properties]
----
camel.component.sql.dataSource = #bean:myDS
----

=== Creating a custom bean with constructor parameters

When creating a bean then parameters to the constructor can be provided.
Suppose we have a class `MyFoo` with a constructor:

[source,java]
----
public class MyFoo {
    private String name;
    private boolean important;
    private int id;

    public MyFoo(String name, boolean important, int id) {
        this.name = name;
        this.important = important;
        this.id = id;
    }
}
----

Then we can create a bean instance with name `foo` and provide parameters to the constructor as shown:

[source,properties]
----
camel.beans.foo = #class:com.foo.MyBean(""Hello World"", true, 123)
----

=== Optional parameters on beans

If a parameter on a bean is not mandatory then the parameter can be marked as optional using `?` syntax, as shown:

[source,properties]
----
camel.beans.foo = #class:com.foo.MyBean(""Hello World"", true, 123)
camel.beans.foo.?company = Acme
----

Then the company parameter is only set if `MyBean` has this option (silent ignore if no option present).
Otherwise if a parameter is set and the bean does not have such a parameter, then an exception is thrown by Camel.

=== Nested parameters on beans

You can configure nested parameters separating them via `.` (dot).

For example given this `Country` class:

[source,java]
----
public class Country {
    private String iso;
    private String name;

    public void setIso(String iso) {
        this.iso = iso;
    }

    public void setName(String name) {
        this.name = name;
    }
}
----

Which is an option on the `MyBean` class.
Then we can then configure its iso and name parameter as shown below:

[source,properties]
----
camel.beans.foo = #class:com.foo.MyBean(""Hello World"", true, 123)
camel.beans.foo.country.iso = USA
camel.beans.foo.country.name = United States of America
----

Camel will automatic create an instance of `Country` if `MyBean` has a getter/setter for this option, and that the `Country` bean
has a default no-arg constructor.

=== Configuring singleton beans by their type

In the example above the SQL component was configured with the name of the `DataSource`. There can be situations where you know there is only
a single instance of a data source in the Camel registry. In such a situation you can instead refer to the class
or interface type via the `#type:` prefix as shown below:

[source,properties]
----
camel.component.sql.dataSource = #type:javax.sql.DataSource
----

If there is no bean in the registry with the type `javax.sql.DataSource` then the option isn't configured.

=== Autowiring beans

The example above can be taken one step further by letting `camel-main` try to autowire the beans.

[source,properties]
----
camel.component.sql.dataSource = #autowired
----

In this situation then `#autowrired` will make Camel detect the type of the `dataSource` option on the `SQL` component.
As the type is a `javax.sql.DataSource` instance, then Camel will lookup in the registry if there is a single instance of the same type.
If there is no such bean then the option isn't configured.

== Defining a Map bean

You can specify `java.util.Map` beans in `camel-main` via properties (such as in the `application.properties` file).

Maps have a special syntax with brackets as shown below:

[source,properties]
----
camel.beans.mymap[table] = 12
camel.beans.mymap[food] = Big Burger
camel.beans.mymap[cheese] = yes
camel.beans.mymap[quantity] = 1
----

The Map is registered in the Camel Registry with the name `mymap`.

== Defining a List bean

This is similar to Map bean where the key is the index, eg 0, 1, 2, etc:

[source,properties]
----
camel.beans.myprojects[0] = Camel
camel.beans.myprojects[1] = Kafka
camel.beans.myprojects[2] = Quarkus
----

The List is registered in the Camel Registry with the name `myprojects`.

== Examples

You can find a set of examples using `camel-main` in https://github.com/apache/camel-examples[Camel Examples]
which demonstrate running Camel in standalone with `camel-main`.
",12366,False,2203.202627200548,median
"CLASS zcl_abapgit_gui_page_repo_over DEFINITION
  PUBLIC
  INHERITING FROM zcl_abapgit_gui_component
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.

    INTERFACES zif_abapgit_gui_renderable .

    DATA mv_order_by TYPE string READ-ONLY .
    DATA mv_only_favorites   TYPE abap_bool READ-ONLY.

    METHODS constructor
      IMPORTING iv_only_favorites TYPE abap_bool
      RAISING
                zcx_abapgit_exception .
    METHODS set_order_by
      IMPORTING
        !iv_order_by TYPE string .
    METHODS set_order_direction
      IMPORTING
        !iv_order_descending TYPE abap_bool .
    METHODS set_filter
      IMPORTING
        it_postdata TYPE zif_abapgit_html_viewer=>ty_post_data .
    METHODS set_only_favorites
      IMPORTING
        iv_only_favorites TYPE abap_bool.
    METHODS
      get_only_favorites RETURNING VALUE(rv_result) TYPE abap_bool.
  PROTECTED SECTION.


  PRIVATE SECTION.
    TYPES:
      BEGIN OF ty_overview,
        favorite        TYPE string,
        ""! True for offline, false for online repo
        type            TYPE string,
        key             TYPE zif_abapgit_persistence=>ty_value,
        name            TYPE string,
        url             TYPE string,
        package         TYPE devclass,
        branch          TYPE string,
        created_by      TYPE syuname,
        created_at      TYPE string,
        deserialized_by TYPE syuname,
        deserialized_at TYPE string,
        write_protected TYPE abap_bool,
      END OF ty_overview,
      ty_overviews TYPE STANDARD TABLE OF ty_overview
                   WITH NON-UNIQUE DEFAULT KEY.
    CONSTANTS:
      BEGIN OF c_action,
        select       TYPE string VALUE 'select',
        apply_filter TYPE string VALUE 'apply_filter',
      END OF c_action .

    DATA: mv_order_descending TYPE abap_bool,
          mv_filter           TYPE string,
          mv_time_zone        TYPE timezone,
          mt_col_spec         TYPE zif_abapgit_definitions=>ty_col_spec_tt,
          mt_overview         TYPE ty_overviews.

    METHODS: render_text_input
      IMPORTING iv_name        TYPE string
                iv_label       TYPE string
                iv_value       TYPE string OPTIONAL
                iv_max_length  TYPE string OPTIONAL
                !iv_autofocus  TYPE abap_bool DEFAULT abap_false
      RETURNING VALUE(ri_html) TYPE REF TO zif_abapgit_html,

      apply_filter
        CHANGING
          ct_overview TYPE ty_overviews,

      map_repo_list_to_overview
        RETURNING
          VALUE(rt_overview) TYPE ty_overviews
        RAISING
          zcx_abapgit_exception,

      render_table_header
        IMPORTING
          ii_html TYPE REF TO zif_abapgit_html,

      render_table
        IMPORTING
          ii_html     TYPE REF TO zif_abapgit_html
          it_overview TYPE ty_overviews
        RAISING
          zcx_abapgit_exception,

      render_table_body
        IMPORTING
          ii_html      TYPE REF TO zif_abapgit_html
          it_repo_list TYPE ty_overviews
        RAISING
          zcx_abapgit_exception,

      render_header_bar
        IMPORTING
          ii_html TYPE REF TO zif_abapgit_html,

      apply_order_by
        CHANGING ct_overview TYPE ty_overviews,

      _add_column
        IMPORTING
          iv_tech_name      TYPE string OPTIONAL
          iv_display_name   TYPE string OPTIONAL
          iv_css_class      TYPE string OPTIONAL
          iv_add_tz         TYPE abap_bool OPTIONAL
          iv_title          TYPE string OPTIONAL
          iv_allow_order_by TYPE any OPTIONAL.

    METHODS render_scripts
      RETURNING
        VALUE(ri_html) TYPE REF TO zif_abapgit_html
      RAISING
        zcx_abapgit_exception.

    METHODS shorten_repo_url
      IMPORTING iv_full_url         TYPE string
                iv_max_length       TYPE i DEFAULT 60
      RETURNING VALUE(rv_shortened) TYPE string.

    METHODS render_actions
      IMPORTING ii_html TYPE REF TO zif_abapgit_html.

    METHODS column
      IMPORTING iv_content     TYPE string OPTIONAL
                iv_css_class   TYPE string OPTIONAL
      RETURNING VALUE(rv_html) TYPE string.

    METHODS action_link
      IMPORTING iv_content     TYPE string
      RETURNING VALUE(rv_html) TYPE string.
ENDCLASS.



CLASS zcl_abapgit_gui_page_repo_over IMPLEMENTATION.


  METHOD apply_filter.

    IF mv_filter IS NOT INITIAL.

      DELETE ct_overview WHERE key             NS mv_filter
                           AND name            NS mv_filter
                           AND url             NS mv_filter
                           AND package         NS mv_filter
                           AND branch          NS mv_filter
                           AND created_by      NS mv_filter
                           AND created_at      NS mv_filter
                           AND deserialized_by NS mv_filter
                           AND deserialized_at NS mv_filter.

    ENDIF.

  ENDMETHOD.


  METHOD apply_order_by.

    DATA:
      lt_sort TYPE abap_sortorder_tab,
      ls_sort LIKE LINE OF lt_sort.

    ls_sort-name = 'FAVORITE'.
    ls_sort-descending = abap_true.
    ls_sort-astext = abap_true.
    INSERT ls_sort INTO TABLE lt_sort.

    IF mv_order_by IS NOT INITIAL.

      ls_sort-name       = mv_order_by.
      ls_sort-descending = mv_order_descending.
      ls_sort-astext     = abap_true.
      INSERT ls_sort INTO TABLE lt_sort.
    ENDIF.

    SORT ct_overview BY (lt_sort).


  ENDMETHOD.


  METHOD constructor.

    super->constructor( ).
    mv_order_by = |NAME|.
    mv_only_favorites = iv_only_favorites.

    CALL FUNCTION 'GET_SYSTEM_TIMEZONE'
      IMPORTING
        timezone            = mv_time_zone
      EXCEPTIONS
        customizing_missing = 1
        OTHERS              = 2.
    ASSERT sy-subrc = 0.

  ENDMETHOD.


  METHOD map_repo_list_to_overview.

    DATA: ls_overview      LIKE LINE OF rt_overview,
          lv_date          TYPE d,
          lv_time          TYPE t,
          lt_repo_obj_list TYPE zif_abapgit_repo_srv=>ty_repo_list.

    FIELD-SYMBOLS <ls_repo> LIKE LINE OF lt_repo_obj_list.

    IF mv_only_favorites = abap_true.
      lt_repo_obj_list = zcl_abapgit_repo_srv=>get_instance( )->list_favorites( ).
    ELSE.
      lt_repo_obj_list = zcl_abapgit_repo_srv=>get_instance( )->list( ).
    ENDIF.

    LOOP AT lt_repo_obj_list ASSIGNING <ls_repo>.

      CLEAR: ls_overview.

      ls_overview-favorite   = zcl_abapgit_persistence_user=>get_instance(
        )->is_favorite_repo( <ls_repo>->ms_data-key ).
      ls_overview-type       = <ls_repo>->ms_data-offline.
      ls_overview-key        = <ls_repo>->ms_data-key.
      ls_overview-name       = <ls_repo>->get_name( ).
      ls_overview-url        = <ls_repo>->ms_data-url.
      ls_overview-package    = <ls_repo>->ms_data-package.
      ls_overview-branch     = <ls_repo>->ms_data-branch_name.
      ls_overview-created_by = <ls_repo>->ms_data-created_by.
      ls_overview-write_protected = <ls_repo>->ms_data-local_settings-write_protected.

      IF <ls_repo>->ms_data-created_at IS NOT INITIAL.
        CONVERT TIME STAMP <ls_repo>->ms_data-created_at
                TIME ZONE mv_time_zone
                INTO DATE lv_date
                     TIME lv_time.

        ls_overview-created_at = |{ lv_date DATE = USER } { lv_time TIME = USER }|.
      ENDIF.

      ls_overview-deserialized_by = <ls_repo>->ms_data-deserialized_by.

      IF <ls_repo>->ms_data-deserialized_at IS NOT INITIAL.
        CONVERT TIME STAMP <ls_repo>->ms_data-deserialized_at
                TIME ZONE mv_time_zone
                INTO DATE lv_date
                     TIME lv_time.

        ls_overview-deserialized_at = |{ lv_date DATE = USER } { lv_time TIME = USER }|.
      ENDIF.

      INSERT ls_overview INTO TABLE rt_overview.

    ENDLOOP.

  ENDMETHOD.


  METHOD render_header_bar.

    DATA: lv_new_toggle_favorites TYPE abap_bool,
          lv_icon_class           TYPE string.

    ii_html->add( |<div class=""form-container"">| ).

    ii_html->add( |<form class=""inline"" method=""post"" action=""sapevent:{ c_action-apply_filter }"">| ).

    ii_html->add( render_text_input(
      iv_name      = |filter|
      iv_label     = |Filter: |
      iv_value     = mv_filter
      iv_autofocus = abap_true ) ).
    ii_html->add( |<input type=""submit"" class=""hidden-submit"">| ).
    ii_html->add( |</form>| ).

    lv_new_toggle_favorites = boolc( NOT mv_only_favorites = abap_true ).
    "" render icon for current state but filter value for new state
    IF mv_only_favorites = abap_true.
      lv_icon_class = `blue`.
    ELSE.
      lv_icon_class = `grey`.
    ENDIF.

    ii_html->add( ii_html->a(
      iv_txt   = |<i id=""icon-filter-favorite"" class=""icon icon-check { lv_icon_class }""></i> Only Favorites|
      iv_act   = |{ zif_abapgit_definitions=>c_action-toggle_favorites }?favorites={ lv_new_toggle_favorites }| ) ).

    ii_html->add( `<span class=""separator"">|</span>` ).

    ii_html->add( ii_html->a(
      iv_txt = '<i id=""icon-filter-detail"" class=""icon icon-check""></i> Detail'
      iv_act = |gHelper.toggleRepoListDetail()|
      iv_typ = zif_abapgit_html=>c_action_type-onclick ) ).

    render_actions( ii_html = ii_html ).

    ii_html->add( |</div>| ).

  ENDMETHOD.


  METHOD render_scripts.

    CREATE OBJECT ri_html TYPE zcl_abapgit_html.

    ri_html->set_title( cl_abap_typedescr=>describe_by_object_ref( me )->get_relative_name( ) ).
    ri_html->add( 'setInitialFocus(""filter"");' ).
    ri_html->add( 'var gHelper = new RepoOverViewHelper();' ).

  ENDMETHOD.


  METHOD render_table.

    ii_html->add( |<div class=""db_list repo-overview"">| ).
    ii_html->add( |<table class=""db_tab"">| ).

    render_table_header( ii_html ).
    render_table_body( ii_html      = ii_html
                       it_repo_list = it_overview ).

    ii_html->add( |</table>| ).
    ii_html->add( |</div>| ).

  ENDMETHOD.


  METHOD render_table_body.

    DATA:
      lv_type_icon            TYPE string,
      lv_favorite_icon        TYPE string,
      lv_favorite_class       TYPE string,
      lv_text                 TYPE string,
      lv_lock                 TYPE string,
      lv_toggle_favorite_link TYPE string,
      lv_repo_go_link         TYPE string,
      lv_remote_icon_link     TYPE string.

    FIELD-SYMBOLS: <ls_repo>     LIKE LINE OF it_repo_list.

    ii_html->add( '<tbody>' ).

    LOOP AT it_repo_list ASSIGNING <ls_repo>.

      IF <ls_repo>-type = abap_true.
        lv_type_icon = 'plug/darkgrey'.
      ELSE.
        lv_type_icon = 'cloud-upload-alt/darkgrey'.
      ENDIF.

      IF <ls_repo>-favorite = abap_true.
        lv_favorite_icon = 'star/blue'.
        lv_favorite_class = 'favorite'.
      ELSE.
        lv_favorite_icon = 'star/grey'.
        lv_favorite_class = ''.
      ENDIF.

      ii_html->add(
        |<tr class=""repo { lv_favorite_class }"" data-key=""{ <ls_repo>-key }"" data-offline=""{ <ls_repo>-type }"">| ).

      lv_toggle_favorite_link = ii_html->a(
        iv_act = |{ zif_abapgit_definitions=>c_action-repo_toggle_fav }?key={ <ls_repo>-key }|
        iv_txt = ii_html->icon( iv_name  = lv_favorite_icon
        iv_class = 'pad-sides'
        iv_hint  = 'Click to toggle favorite' ) ).

      ii_html->add(
        column( iv_content = lv_toggle_favorite_link
                iv_css_class = 'wmin' ) ).

      CLEAR lv_lock.
      IF <ls_repo>-write_protected = abap_true.
        lv_lock = ii_html->icon( iv_name  = 'lock/grey70'
                                 iv_class = 'm-em5-sides'
                                 iv_hint  = 'Locked from pulls' ).
      ENDIF.

      ii_html->add(
        column( iv_content = ii_html->icon( lv_type_icon )
                iv_css_class = 'wmin' ) ).

      ii_html->add(
        column( iv_content = ii_html->a( iv_txt = <ls_repo>-name
                                         iv_act = |{ c_action-select }?key={ <ls_repo>-key }| ) && lv_lock ) ).

      ii_html->add(
        column( iv_content = zcl_abapgit_gui_chunk_lib=>render_package_name(
                            iv_package = <ls_repo>-package
                            iv_suppress_title = boolc( NOT mv_only_favorites = abap_true ) )->render( ) ) ).


      IF <ls_repo>-type = abap_false.
        lv_remote_icon_link = ii_html->a(
          iv_txt   = ii_html->icon( iv_name  = 'edit-solid'
                                    iv_class = 'pad-sides'
                                    iv_hint  = 'Change remote' )
          iv_act   = |{ zif_abapgit_definitions=>c_action-repo_remote_settings }?| &&
                     |key={ <ls_repo>-key }|
          iv_class = |remote_repo| ).

        lv_text = shorten_repo_url( <ls_repo>-url ) && lv_remote_icon_link.

        ii_html->add( column( iv_content = |{ ii_html->a(
          iv_txt   = lv_text
          iv_title = <ls_repo>-url
          iv_act   = |{ zif_abapgit_definitions=>c_action-url }?url={ <ls_repo>-url }| ) }| ) ).
      ELSE.
        ii_html->add( column( ) ).
      ENDIF.

      IF <ls_repo>-branch IS INITIAL.
        ii_html->add( column( iv_content = |&nbsp;| ) ).
      ELSE.
        ii_html->add(
          column( iv_content = zcl_abapgit_gui_chunk_lib=>render_branch_name(
                              iv_branch   = <ls_repo>-branch
                              iv_repo_key = <ls_repo>-key )->render( ) ) ).
      ENDIF.

      ii_html->add(
        column( iv_content = zcl_abapgit_gui_chunk_lib=>render_user_name(
                            iv_username = <ls_repo>-deserialized_by
                            iv_suppress_title = boolc( NOT mv_only_favorites = abap_true ) )->render( )
                iv_css_class = 'ro-detail' ) ).

      ii_html->add(
        column( iv_content = <ls_repo>-deserialized_at
                iv_css_class = 'ro-detail' ) ).

      ii_html->add(
        column( iv_content = zcl_abapgit_gui_chunk_lib=>render_user_name(
                    iv_username = <ls_repo>-created_by
                    iv_suppress_title = boolc( NOT mv_only_favorites = abap_true ) )->render( )
                iv_css_class = 'ro-detail' ) ).

      ii_html->add(
        column( iv_content = <ls_repo>-created_at
                iv_css_class = 'ro-detail' ) ).

      ii_html->add(
        column( iv_content = |{ <ls_repo>-key }|
                iv_css_class = 'ro-detail' ) ).

      "" the link is clicked in javascript
      lv_repo_go_link = ii_html->a(
        iv_txt   = ``
        iv_act   = |{ c_action-select }?key={ <ls_repo>-key }|
        iv_class = 'hidden' ).

      ii_html->add( column(
        iv_content = |<span class=""link"" title=""Open"">&rsaquo;{ lv_repo_go_link }</span>|
        iv_css_class = 'ro-go' ) ).
      ii_html->add( `</tr>` ).
    ENDLOOP.

    ii_html->add( |</tbody>| ).

    IF mv_only_favorites = abap_true.
      ii_html->add( `<tfoot><tr><td colspan=""5"">` ).
      ii_html->add( `(Only favorites are shown. ` ).
      ii_html->add( ii_html->a(
        iv_txt   = |Show All|
        iv_act   = |{ zif_abapgit_definitions=>c_action-toggle_favorites }?favorites={ abap_false }| ) ).
      ii_html->add( `)</td></tr></tfoot>` ).
    ENDIF.

  ENDMETHOD.

  METHOD render_actions.

    CONSTANTS:
      lc_separator     TYPE string VALUE `<span class=""separator"">|</span>`,
      lc_dummy_key     TYPE string VALUE `?key=#`,
      lc_offline_class TYPE string VALUE `action_offline_repo`,
      lc_online_class  TYPE string VALUE `action_online_repo`,
      lc_action_class  TYPE string VALUE `action_link`.

    DATA:
      lv_settings_link TYPE string,
      lv_check_link    TYPE string,
      lv_stage_link    TYPE string,
      lv_patch_link    TYPE string,
      lv_diff_link     TYPE string,
      lv_pull_link     TYPE string.

    DATA:
      lv_zip_import_link TYPE string,
      lv_zip_export_link TYPE string.

    ii_html->add( |<div class=""float-right"">| ).

    lv_pull_link = ii_html->a(
      iv_txt   = |Pull|
      iv_act   = |{ zif_abapgit_definitions=>c_action-git_reset }{ lc_dummy_key }|
      iv_class = |{ lc_action_class } { lc_online_class }| ).

    ii_html->add( action_link( lv_pull_link && lc_separator ) ).

    lv_stage_link = ii_html->a(
      iv_txt   = |Stage|
      iv_act   = |{ zif_abapgit_definitions=>c_action-go_stage }{ lc_dummy_key }|
      iv_class = |{ lc_action_class } { lc_online_class } | ).

    ii_html->add( action_link( lv_stage_link && lc_separator ) ).

    lv_patch_link = ii_html->a(
      iv_txt   = |Patch|
      iv_act   = |{ zif_abapgit_definitions=>c_action-go_patch }{ lc_dummy_key }|
      iv_class = |{ lc_action_class } { lc_online_class } | ).

    ii_html->add( action_link( lv_patch_link && lc_separator ) ).

    lv_diff_link = ii_html->a(
      iv_txt   = |Diff|
      iv_act   = |{ zif_abapgit_definitions=>c_action-go_repo_diff }{ lc_dummy_key }|
      iv_class = |{ lc_action_class } { lc_online_class }| ).

    ii_html->add( action_link( lv_diff_link && lc_separator ) ).

    lv_check_link = ii_html->a(
      iv_txt   = |Check|
      iv_act   = |{ zif_abapgit_definitions=>c_action-repo_code_inspector }{ lc_dummy_key }|
      iv_class = |{ lc_action_class }| ).

    ii_html->add( action_link( lv_check_link && lc_separator ) ).

    lv_zip_import_link = ii_html->a(
      iv_txt   = |Import|
      iv_act   = |{ zif_abapgit_definitions=>c_action-zip_import }{ lc_dummy_key }|
      iv_class = |{ lc_action_class } { lc_offline_class }| ).

    ii_html->add( action_link( lv_zip_import_link && lc_separator ) ).

    lv_zip_export_link = ii_html->a(
      iv_txt   = |Export|
      iv_act   = |{ zif_abapgit_definitions=>c_action-zip_export }{ lc_dummy_key }|
      iv_class = |{ lc_action_class } { lc_offline_class }| ).

    ii_html->add( action_link( lv_zip_export_link && lc_separator ) ).

    lv_settings_link = ii_html->a(
      iv_txt   = |Settings|
      iv_act   = |{ zif_abapgit_definitions=>c_action-repo_settings }{ lc_dummy_key }|
      iv_class = |{ lc_action_class }| ).

    ii_html->add( action_link( lv_settings_link ) ).

    ii_html->add( |</div>| ).
  ENDMETHOD.

  METHOD shorten_repo_url.
    DATA lv_new_length TYPE i.
    DATA lv_length_to_truncate_to TYPE i.

    rv_shortened = iv_full_url.

    REPLACE FIRST OCCURRENCE OF 'https://' IN rv_shortened WITH ''.
    REPLACE FIRST OCCURRENCE OF 'http://' IN rv_shortened WITH ''.
    IF rv_shortened CP '*.git'.
      lv_new_length = strlen( rv_shortened ) - 4.
      rv_shortened  = rv_shortened(lv_new_length).
    ENDIF.

    IF strlen( rv_shortened ) > iv_max_length.
      lv_length_to_truncate_to = iv_max_length - 3.
      rv_shortened = rv_shortened(lv_length_to_truncate_to) && `...`.
    ENDIF.
  ENDMETHOD.

  METHOD render_table_header.

    CLEAR mt_col_spec.

    _add_column(
      iv_tech_name      = 'FAVORITE'
      iv_css_class      = 'wmin'
      iv_allow_order_by = abap_false ).

    _add_column(
      iv_tech_name      = 'TYPE'
      iv_css_class      = 'wmin'
      iv_allow_order_by = abap_false ).

    _add_column(
      iv_tech_name      = 'NAME'
      iv_display_name   = 'Name'
      iv_allow_order_by = abap_true ).

    _add_column(
      iv_tech_name      = 'PACKAGE'
      iv_display_name   = 'Package'
      iv_css_class      = 'package'
      iv_allow_order_by = abap_true ).

    _add_column(
      iv_tech_name      = 'URL'
      iv_display_name   = 'Remote'
      iv_allow_order_by = abap_true ).

    _add_column(
      iv_tech_name      = 'BRANCH'
      iv_display_name   = 'Branch'
      iv_allow_order_by = abap_true ).

    _add_column(
      iv_tech_name      = 'DESERIALIZED_BY'
      iv_display_name   = 'Deserialized by'
      iv_css_class      = 'ro-detail'
      iv_allow_order_by = abap_true ).

    _add_column(
      iv_tech_name      = 'DESERIALIZED_AT'
      iv_display_name   = 'Deserialized at'
      iv_css_class      = 'ro-detail'
      iv_allow_order_by = abap_true ).

    _add_column(
      iv_tech_name      = 'CREATED_BY'
      iv_display_name   = 'Created by'
      iv_css_class      = 'ro-detail'
      iv_allow_order_by = abap_true ).

    _add_column(
      iv_tech_name      = 'CREATED_AT'
      iv_display_name   = 'Created at'
      iv_css_class      = 'ro-detail'
      iv_add_tz         = abap_true
      iv_allow_order_by = abap_true ).

    _add_column(
      iv_tech_name      = 'KEY'
      iv_display_name   = 'Key'
      iv_css_class      = 'ro-detail'
      iv_allow_order_by = abap_true ).

    _add_column(
      iv_tech_name      = 'GO'
      iv_css_class      = 'ro-go'
      iv_allow_order_by = abap_false ).

    ii_html->add( |<thead>| ).
    ii_html->add( |<tr>| ).

    ii_html->add( zcl_abapgit_gui_chunk_lib=>render_order_by_header_cells(
                      it_col_spec         = mt_col_spec
                      iv_order_by         = mv_order_by
                      iv_order_descending = mv_order_descending ) ).

    ii_html->add( '</tr>' ).
    ii_html->add( '</thead>' ).

  ENDMETHOD.


  METHOD render_text_input.

    DATA lv_attrs TYPE string.

    CREATE OBJECT ri_html TYPE zcl_abapgit_html.

    IF iv_value IS NOT INITIAL.
      lv_attrs = | value=""{ iv_value }""|.
    ENDIF.

    IF iv_max_length IS NOT INITIAL.
      lv_attrs = lv_attrs && | maxlength=""{ iv_max_length }""|.
    ENDIF.

    IF iv_autofocus = abap_true.
      lv_attrs = lv_attrs && | autofocus|.
    ENDIF.

    ri_html->add( |<label for=""{ iv_name }"">{ iv_label }</label>| ).
    ri_html->add( |<input id=""{ iv_name }"" name=""{ iv_name }"" type=""text""{ lv_attrs }>| ).

  ENDMETHOD.


  METHOD set_filter.

    FIELD-SYMBOLS: <lv_postdata> LIKE LINE OF it_postdata.

    READ TABLE it_postdata ASSIGNING <lv_postdata>
                           INDEX 1.
    IF sy-subrc = 0.
      FIND FIRST OCCURRENCE OF REGEX `filter=(.*)`
           IN <lv_postdata>
           SUBMATCHES mv_filter.
    ENDIF.

    mv_filter = condense( mv_filter ).

  ENDMETHOD.


  METHOD set_order_by.
    mv_order_by = iv_order_by.
  ENDMETHOD.


  METHOD set_order_direction.
    mv_order_descending = iv_order_descending.
  ENDMETHOD.


  METHOD zif_abapgit_gui_renderable~render.

    mt_overview = map_repo_list_to_overview( ).
    apply_order_by( CHANGING ct_overview = mt_overview ).
    apply_filter( CHANGING ct_overview = mt_overview ).

    CREATE OBJECT ri_html TYPE zcl_abapgit_html.

    render_header_bar( ri_html ).

    zcl_abapgit_exit=>get_instance( )->wall_message_list( ri_html ).

    render_table( ii_html     = ri_html
                  it_overview = mt_overview ).

    register_deferred_script( render_scripts( ) ).

  ENDMETHOD.


  METHOD _add_column.

    FIELD-SYMBOLS <ls_col> LIKE LINE OF mt_col_spec.
    APPEND INITIAL LINE TO mt_col_spec ASSIGNING <ls_col>.
    <ls_col>-display_name = iv_display_name.
    <ls_col>-tech_name = iv_tech_name.
    <ls_col>-title = iv_title.
    <ls_col>-css_class = iv_css_class.
    <ls_col>-add_tz = iv_add_tz.
    <ls_col>-allow_order_by = iv_allow_order_by.
  ENDMETHOD.

  METHOD column.
    IF iv_css_class IS NOT INITIAL.
      rv_html = |<td class=""{ iv_css_class }"">| && iv_content && |</td>|.
    ELSE.
      rv_html = |<td>| && iv_content && |</td>|.
    ENDIF.
  ENDMETHOD.

  METHOD action_link.
    rv_html = |<span class=""action_link"">| && iv_content && |</span>|.
  ENDMETHOD.


  METHOD set_only_favorites.
    mv_only_favorites = iv_only_favorites.
  ENDMETHOD.

  METHOD get_only_favorites.
    rv_result = mv_only_favorites.
  ENDMETHOD.

ENDCLASS.
",5991,False,1275.602429299943,median
"CLASS zcl_excel_fill_template DEFINITION
  PUBLIC
  FINAL
  CREATE PUBLIC .

  PUBLIC SECTION.

    TYPES: tv_range_name TYPE c LENGTH 30,
           BEGIN OF ts_range,
             sheet  TYPE zexcel_sheet_title,
             name   TYPE tv_range_name,
             start  TYPE zexcel_cell_row,
             stop   TYPE zexcel_cell_row,
             id     TYPE i,
             parent TYPE i,
             length TYPE i,
           END OF ts_range,
           tt_ranges TYPE STANDARD TABLE OF ts_range WITH DEFAULT KEY,
           BEGIN OF ts_variable,
             sheet  TYPE zexcel_sheet_title,
             parent TYPE i,
             name   TYPE tv_range_name,
           END OF ts_variable,
           BEGIN OF ts_name_style,
             sheet           TYPE zexcel_sheet_title,
             name            TYPE tv_range_name,
             parent          TYPE i,
             numeric_counter TYPE i,
             date_counter    TYPE i,
             time_counter    TYPE i,
             text_counter    TYPE i,
           END OF ts_name_style,
           tt_variables    TYPE STANDARD TABLE OF ts_variable WITH DEFAULT KEY,
           tt_sheet_titles TYPE STANDARD TABLE OF zexcel_sheet_title WITH DEFAULT KEY,
           tt_name_styles  TYPE STANDARD TABLE OF ts_name_style WITH DEFAULT KEY.

    DATA mt_sheet TYPE tt_sheet_titles READ-ONLY.
    DATA mt_range TYPE tt_ranges READ-ONLY.
    DATA mt_var TYPE tt_variables READ-ONLY.
    DATA mo_excel TYPE REF TO zcl_excel READ-ONLY.
    DATA mt_name_styles TYPE tt_name_styles READ-ONLY.

    CLASS-METHODS create
      IMPORTING
        !io_excel                 TYPE REF TO zcl_excel
      RETURNING
        VALUE(eo_template_filler) TYPE REF TO zcl_excel_fill_template
      RAISING
        zcx_excel.

    METHODS fill_sheet
      IMPORTING
        !iv_data TYPE zcl_excel_template_data=>ts_template_data_sheet
      RAISING
        zcx_excel .

  PROTECTED SECTION.
  PRIVATE SECTION.

    TYPES: tt_cell_data_no_key TYPE STANDARD TABLE OF zexcel_s_cell_data WITH DEFAULT KEY.

    METHODS fill_range
      IMPORTING
        !iv_sheet              TYPE zexcel_sheet_title
        !iv_parent             TYPE zexcel_cell_row
        !iv_data               TYPE data
        VALUE(iv_range_length) TYPE zexcel_cell_row
        !io_sheet              TYPE REF TO zcl_excel_worksheet
      CHANGING
        !ct_cells              TYPE tt_cell_data_no_key
        !cv_diff               TYPE zexcel_cell_row
        !ct_merged_cells       TYPE zcl_excel_worksheet=>mty_ts_merge
      RAISING
        zcx_excel .
    METHODS get_range .
    METHODS validate_range
      IMPORTING
        !io_range TYPE REF TO zcl_excel_range .
    METHODS discard_overlapped .
    METHODS sign_range .
    METHODS find_var
      RAISING
        zcx_excel .

ENDCLASS.



CLASS zcl_excel_fill_template IMPLEMENTATION.


  METHOD create.

    CREATE OBJECT eo_template_filler .

    eo_template_filler->mo_excel = io_excel.
    eo_template_filler->get_range( ).
    eo_template_filler->discard_overlapped( ).
    eo_template_filler->sign_range( ).
    eo_template_filler->find_var( ).

  ENDMETHOD.

  METHOD discard_overlapped.
    DATA:
       lt_range TYPE tt_ranges.
    FIELD-SYMBOLS:
      <ls_range>   TYPE ts_range,
      <ls_range_2> TYPE ts_range.

    SORT mt_range BY sheet  start  stop.

    LOOP AT mt_range ASSIGNING <ls_range>.

      LOOP AT mt_range ASSIGNING <ls_range_2> WHERE sheet =  <ls_range>-sheet
                                            AND name  <> <ls_range>-name
                                            AND stop  >= <ls_range>-start
                                            AND start <  <ls_range>-start
                                            AND stop  <  <ls_range>-stop.
        EXIT.
      ENDLOOP.

      IF sy-subrc NE 0.
        APPEND <ls_range> TO lt_range.
      ENDIF.

    ENDLOOP.

    mt_range = lt_range.

    SORT mt_range BY sheet  start  stop DESCENDING.

  ENDMETHOD.


  METHOD fill_range.

    DATA: lt_tmp_cells_template        TYPE tt_cell_data_no_key,
          lt_cells_result              TYPE tt_cell_data_no_key,
          lt_tmp_cells                 TYPE tt_cell_data_no_key,
          ls_cell                      TYPE zexcel_s_cell_data,
          lt_tmp_merged_cells_template TYPE zcl_excel_worksheet=>mty_ts_merge,
          lt_merged_cells_result       TYPE zcl_excel_worksheet=>mty_ts_merge,
          lt_tmp_merged_cells          TYPE zcl_excel_worksheet=>mty_ts_merge,
          ls_merged_cell               LIKE LINE OF lt_tmp_merged_cells,
          lv_start_row                 TYPE i,
          lv_stop_row                  TYPE i,
          lv_cell_row                  TYPE i,
          lv_column_alpha              TYPE string,
          lt_matches                   TYPE match_result_tab,
          lv_search                    TYPE string,
          lv_var_name                  TYPE string,
          lv_cell_value                TYPE string.

    FIELD-SYMBOLS:
      <table>     TYPE ANY TABLE,
      <line>      TYPE any,
      <ls_range>  TYPE ts_range,
      <ls_cell>   TYPE zexcel_s_cell_data,
      <ls_match>  TYPE match_result,
      <var_value> TYPE any.


    cv_diff = cv_diff +  iv_range_length .

    lv_start_row = 1.


* recursive fill nested range

    LOOP AT mt_range ASSIGNING <ls_range> WHERE sheet = iv_sheet
                                            AND parent = iv_parent.


      lv_stop_row = <ls_range>-start - 1.

*      update cells before any range

      LOOP AT ct_cells INTO ls_cell  WHERE cell_row >= lv_start_row AND cell_row <= lv_stop_row .
        ls_cell-cell_row =  ls_cell-cell_row + cv_diff.
        lv_column_alpha = zcl_excel_common=>convert_column2alpha( ls_cell-cell_column ).

        ls_cell-cell_coords = ls_cell-cell_row.
        CONCATENATE lv_column_alpha ls_cell-cell_coords INTO ls_cell-cell_coords.
        CONDENSE ls_cell-cell_coords NO-GAPS.

        APPEND ls_cell TO lt_cells_result.
      ENDLOOP.



*      update merged cells before range

      LOOP AT ct_merged_cells INTO ls_merged_cell WHERE row_from >=  lv_start_row AND row_to <= lv_stop_row.
        ls_merged_cell-row_from = ls_merged_cell-row_from + cv_diff.
        ls_merged_cell-row_to = ls_merged_cell-row_to + cv_diff.

        APPEND ls_merged_cell TO lt_merged_cells_result.

      ENDLOOP.



      lv_start_row = <ls_range>-stop + 1.



      CLEAR:
       lt_tmp_cells_template,
       lt_tmp_merged_cells_template.


*copy cell template
      LOOP AT ct_cells INTO ls_cell WHERE cell_row >= <ls_range>-start AND cell_row <= <ls_range>-stop.
        APPEND ls_cell TO lt_tmp_cells_template.
      ENDLOOP.

      LOOP AT ct_merged_cells INTO ls_merged_cell WHERE row_from >= <ls_range>-start AND row_to <= <ls_range>-stop.
        APPEND ls_merged_cell TO lt_tmp_merged_cells_template.
      ENDLOOP.


      ASSIGN COMPONENT <ls_range>-name OF STRUCTURE iv_data TO <table>.
      CHECK sy-subrc = 0.

      cv_diff = cv_diff - <ls_range>-length.

*merge each line of data table with template
      LOOP AT <table> ASSIGNING <line>.
*        make local copy
        lt_tmp_cells = lt_tmp_cells_template.
        lt_tmp_merged_cells = lt_tmp_merged_cells_template.

*fill data

        fill_range(
          EXPORTING
            io_sheet        = io_sheet
            iv_sheet        = iv_sheet
            iv_parent       = <ls_range>-id
            iv_data         = <line>
            iv_range_length = <ls_range>-length
          CHANGING
            ct_cells        = lt_tmp_cells
            ct_merged_cells = lt_tmp_merged_cells
            cv_diff         = cv_diff ).

*collect data

        APPEND LINES OF lt_tmp_cells TO lt_cells_result.
        APPEND LINES OF lt_tmp_merged_cells TO lt_merged_cells_result.

      ENDLOOP.

    ENDLOOP.


    IF <ls_range> IS ASSIGNED.

      LOOP AT ct_cells INTO ls_cell WHERE cell_row > <ls_range>-stop .
        ls_cell-cell_row =  ls_cell-cell_row + cv_diff.
        lv_column_alpha = zcl_excel_common=>convert_column2alpha( ls_cell-cell_column ).

        ls_cell-cell_coords = ls_cell-cell_row.
        CONCATENATE lv_column_alpha ls_cell-cell_coords INTO ls_cell-cell_coords.
        CONDENSE ls_cell-cell_coords NO-GAPS.

        APPEND ls_cell TO lt_cells_result.
      ENDLOOP.

      ct_cells = lt_cells_result.

      LOOP AT ct_merged_cells INTO ls_merged_cell WHERE row_from > <ls_range>-stop.
        ls_merged_cell-row_from = ls_merged_cell-row_from + cv_diff.
        ls_merged_cell-row_to = ls_merged_cell-row_to + cv_diff.

        APPEND ls_merged_cell TO lt_merged_cells_result.
      ENDLOOP.

      ct_merged_cells = lt_merged_cells_result.

    ELSE.


      LOOP AT ct_cells ASSIGNING <ls_cell>.
        <ls_cell>-cell_row =  <ls_cell>-cell_row + cv_diff.
        lv_column_alpha = zcl_excel_common=>convert_column2alpha( <ls_cell>-cell_column ).

        <ls_cell>-cell_coords = <ls_cell>-cell_row.
        CONCATENATE lv_column_alpha <ls_cell>-cell_coords INTO <ls_cell>-cell_coords.
        CONDENSE <ls_cell>-cell_coords NO-GAPS.
      ENDLOOP.

      LOOP AT ct_merged_cells INTO ls_merged_cell .
        ls_merged_cell-row_from = ls_merged_cell-row_from + cv_diff.
        ls_merged_cell-row_to = ls_merged_cell-row_to + cv_diff.

        APPEND ls_merged_cell TO lt_merged_cells_result.
      ENDLOOP.

      ct_merged_cells = lt_merged_cells_result.

    ENDIF.


*check if variables in this range
    READ TABLE mt_var TRANSPORTING NO FIELDS WITH KEY sheet = iv_sheet parent = iv_parent.

    IF sy-subrc = 0.

*      replace variables of current range with data
      LOOP AT ct_cells ASSIGNING <ls_cell>.


        REFRESH lt_matches.

        lv_cell_value = <ls_cell>-cell_value.

        FIND ALL OCCURRENCES OF REGEX '\\[[^\\]]*\\]' IN <ls_cell>-cell_value  RESULTS lt_matches.

        SORT lt_matches BY offset DESCENDING .

        LOOP AT lt_matches ASSIGNING <ls_match>.
          lv_search = <ls_cell>-cell_value+<ls_match>-offset(<ls_match>-length).
          lv_var_name = lv_search.

          TRANSLATE lv_var_name TO UPPER CASE.
          TRANSLATE lv_var_name USING '[ ] '.
          CONDENSE lv_var_name .

          ASSIGN COMPONENT lv_var_name OF STRUCTURE iv_data TO <var_value>.
          CHECK sy-subrc = 0.

          "" Use SET_CELL to format correctly
          io_sheet->set_cell( ip_column = <ls_cell>-cell_column ip_row = <ls_cell>-cell_row - cv_diff ip_value = <var_value> ).
          lv_cell_row = <ls_cell>-cell_row - cv_diff.
          READ TABLE io_sheet->sheet_content INTO ls_cell
            WITH KEY cell_column = <ls_cell>-cell_column
                     cell_row    = lv_cell_row.
          REPLACE ALL OCCURRENCES OF lv_search IN <ls_cell>-cell_value WITH ls_cell-cell_value.
        ENDLOOP.

        IF lines( lt_matches ) = 1.
          lv_cell_row = <ls_cell>-cell_row - cv_diff.
          READ TABLE io_sheet->sheet_content INTO ls_cell
            WITH KEY cell_column = <ls_cell>-cell_column
                     cell_row    = lv_cell_row.
          <ls_cell>-data_type = ls_cell-data_type.
        ENDIF.

      ENDLOOP.
    ENDIF.

  ENDMETHOD.


  METHOD fill_sheet.

    DATA: lo_worksheet      TYPE REF TO zcl_excel_worksheet,
          lt_sheet_cells    TYPE tt_cell_data_no_key,
          lt_merged_cells   TYPE zcl_excel_worksheet=>mty_ts_merge,
          lt_merged_cells_2 TYPE zcl_excel_worksheet=>mty_ts_merge,
          lv_initial_diff   TYPE i.
    FIELD-SYMBOLS:
      <any_data>       TYPE any,
      <ls_sheet_cell>  TYPE zexcel_s_cell_data,
      <ls_merged_cell> TYPE zcl_excel_worksheet=>mty_merge.


    lo_worksheet = mo_excel->get_worksheet_by_name( iv_data-sheet ).

    lt_sheet_cells = lo_worksheet->sheet_content.
    lt_merged_cells = lo_worksheet->mt_merged_cells.

    ASSIGN iv_data-data->* TO <any_data>.

    fill_range(
      EXPORTING
        io_sheet        = lo_worksheet
        iv_range_length = 0
        iv_sheet        = iv_data-sheet
        iv_parent       = 0
        iv_data         = <any_data>
      CHANGING
        ct_cells        = lt_sheet_cells
        ct_merged_cells = lt_merged_cells
        cv_diff         = lv_initial_diff  ).


    REFRESH  lo_worksheet->sheet_content.

    LOOP AT lt_sheet_cells ASSIGNING <ls_sheet_cell>.
      INSERT <ls_sheet_cell> INTO TABLE lo_worksheet->sheet_content.
    ENDLOOP.

    lt_merged_cells_2 = lo_worksheet->mt_merged_cells.
    LOOP AT lt_merged_cells_2 ASSIGNING <ls_merged_cell>.
      lo_worksheet->delete_merge( ip_cell_column = <ls_merged_cell>-col_from ip_cell_row = <ls_merged_cell>-row_from ).
    ENDLOOP.

    LOOP AT lt_merged_cells ASSIGNING <ls_merged_cell>.
      lo_worksheet->set_merge(
          ip_column_start = <ls_merged_cell>-col_from
          ip_column_end   = <ls_merged_cell>-col_to
          ip_row          = <ls_merged_cell>-row_from
          ip_row_to       = <ls_merged_cell>-row_to ).
    ENDLOOP.

  ENDMETHOD.


  METHOD find_var.

    DATA: lv_row            TYPE i,
          lv_column         TYPE i,
          lv_column_alpha   TYPE string,
          lv_value          TYPE string,
          ls_name_style     TYPE ts_name_style,
          lo_style          TYPE REF TO zcl_excel_style,
          lo_worksheet      TYPE REF TO zcl_excel_worksheet,
          ls_variable       TYPE ts_variable,
          lv_highest_column TYPE zexcel_cell_column,
          lv_highest_row    TYPE int4,
          lt_matches        TYPE match_result_tab,
          lv_search         TYPE string,
          lv_replace        TYPE string.

    FIELD-SYMBOLS:
      <ls_match>      TYPE match_result,
      <ls_range>      TYPE ts_range,
      <lv_sheet>      TYPE zexcel_sheet_title,
      <ls_name_style> TYPE ts_name_style.


    LOOP AT mt_sheet ASSIGNING <lv_sheet>.

      lo_worksheet ?= mo_excel->get_worksheet_by_name(  <lv_sheet> ).
      lv_row = 1.

      lv_highest_column = lo_worksheet->get_highest_column( ).
      lv_highest_row    = lo_worksheet->get_highest_row( ).

      WHILE lv_row <= lv_highest_row.
        lv_column = 1.
        WHILE lv_column <= lv_highest_column.
          lv_column_alpha = zcl_excel_common=>convert_column2alpha( lv_column ).
          CLEAR lo_style.
          lo_worksheet->get_cell(
            EXPORTING
              ip_column = lv_column_alpha
              ip_row    = lv_row
            IMPORTING
              ep_value = lv_value
              ep_style = lo_style ).

          FIND ALL OCCURRENCES OF REGEX '\\[[^\\]]*\\]' IN lv_value RESULTS lt_matches.

          LOOP AT lt_matches ASSIGNING <ls_match>.
            lv_search = lv_value+<ls_match>-offset(<ls_match>-length).
            lv_replace = lv_search.

            TRANSLATE lv_replace TO UPPER CASE.

            CLEAR ls_variable.

            ls_variable-sheet = <lv_sheet>.
            ls_variable-name = lv_replace.
            TRANSLATE ls_variable-name USING '[ ] '.
            CONDENSE ls_variable-name .

            LOOP AT mt_range ASSIGNING <ls_range> WHERE sheet = <lv_sheet>
                                                    AND start <= lv_row
                                                    AND stop >= lv_row.
              ls_variable-parent = <ls_range>-id.
              EXIT.
            ENDLOOP.

            READ TABLE mt_var TRANSPORTING NO FIELDS WITH KEY sheet = ls_variable-sheet name = ls_variable-name parent = ls_variable-parent.
            IF sy-subrc NE 0.
              APPEND ls_variable TO mt_var.
            ENDIF.

            READ TABLE mt_name_styles WITH KEY sheet = ls_variable-sheet name = ls_variable-name parent = ls_variable-parent ASSIGNING <ls_name_style>.
            IF sy-subrc NE 0.
              CLEAR ls_name_style.
              ls_name_style-sheet = <lv_sheet>.
              ls_name_style-name = ls_variable-name.
              ls_name_style-parent = ls_variable-parent.
              APPEND ls_name_style TO mt_name_styles ASSIGNING <ls_name_style>.
            ENDIF.
            IF lo_style IS NOT BOUND.
              <ls_name_style>-text_counter = <ls_name_style>-text_counter + 1.
            ELSE.
              IF lo_style->number_format->format_code CA '0'
                   AND lo_style->number_format->format_code NS '0]'.
                <ls_name_style>-numeric_counter = <ls_name_style>-numeric_counter + 1.
              ELSEIF lo_style->number_format->format_code CA 'm'
                 AND lo_style->number_format->format_code CA 'd'
                 AND lo_style->number_format->format_code NA 'h'.
                <ls_name_style>-date_counter = <ls_name_style>-date_counter + 1.
              ELSEIF ( lo_style->number_format->format_code CA 'h' OR lo_style->number_format->format_code CA 's' )
                 AND lo_style->number_format->format_code NA 'd'.
                <ls_name_style>-time_counter = <ls_name_style>-time_counter + 1.
              ELSE.
                <ls_name_style>-text_counter = <ls_name_style>-text_counter + 1.
              ENDIF.
            ENDIF.

          ENDLOOP.
          lv_column = lv_column + 1.
        ENDWHILE.
        lv_row = lv_row + 1.
      ENDWHILE.
    ENDLOOP.

    SORT mt_range BY id .
  ENDMETHOD.


  METHOD get_range.

    DATA:
      lo_worksheets_iterator TYPE REF TO cl_object_collection_iterator,
      lo_worksheet           TYPE REF TO zcl_excel_worksheet,
      lo_range_iterator      TYPE REF TO cl_object_collection_iterator,
      lo_range               TYPE REF TO zcl_excel_range.


    lo_worksheets_iterator = mo_excel->get_worksheets_iterator( ).


    WHILE lo_worksheets_iterator->has_next( ) = abap_true.
      lo_worksheet ?= lo_worksheets_iterator->get_next( ).
      APPEND lo_worksheet->get_title( ) TO mt_sheet.
    ENDWHILE.

    lo_range_iterator = mo_excel->get_ranges_iterator( ).

    WHILE lo_range_iterator->has_next(  ) = abap_true.
      lo_range ?= lo_range_iterator->get_next( ).
      validate_range( lo_range ).
    ENDWHILE.

  ENDMETHOD.


  METHOD sign_range.

    DATA: lv_tabix TYPE i.
    FIELD-SYMBOLS:
      <ls_range>   TYPE ts_range,
      <ls_range_2> TYPE ts_range.

    LOOP AT mt_range ASSIGNING <ls_range>.
      <ls_range>-id = sy-tabix.
    ENDLOOP.

    LOOP AT mt_range ASSIGNING  <ls_range>.
      lv_tabix = sy-tabix + 1.

      LOOP AT mt_range ASSIGNING  <ls_range_2>
                                  FROM lv_tabix
                                  WHERE sheet = <ls_range>-sheet.

        IF <ls_range_2>-start >= <ls_range>-start AND <ls_range_2>-stop <= <ls_range>-stop.
          <ls_range_2>-parent = <ls_range>-id.
        ENDIF.

      ENDLOOP.

    ENDLOOP.

    SORT mt_range BY id DESCENDING.
  ENDMETHOD.


  METHOD validate_range.

    DATA: lv_range_name       TYPE string,
          lv_range_address    TYPE string,
          lv_range_start      TYPE string,
          lv_range_stop       TYPE string,
          lv_range_sheet      TYPE string,
          lv_tmp_value        TYPE string,
          lt_cell_coord_parts TYPE TABLE OF string,
          lv_cell_coord_start TYPE string,
          lv_cell_coord_stop  TYPE string,
          lv_column_start     TYPE zexcel_cell_column_alpha,
          lv_column_end       TYPE zexcel_cell_column_alpha,
          lv_row_start        TYPE zexcel_cell_row,
          lv_row_end          TYPE zexcel_cell_row.

    FIELD-SYMBOLS: <ls_range> TYPE ts_range.


    lv_range_name = io_range->name.
    TRANSLATE lv_range_name TO UPPER CASE.
    lv_range_address = io_range->get_value( ).

    SPLIT lv_range_address AT '!' INTO lv_range_sheet lv_tmp_value.

    SPLIT lv_tmp_value AT ':' INTO lv_range_start lv_range_stop.

    SPLIT lv_range_start AT '$' INTO TABLE lt_cell_coord_parts.

    IF lines( lt_cell_coord_parts ) > 2.
      TRY.
          zcl_excel_common=>convert_range2column_a_row(
            EXPORTING
              i_range        = lv_range_address
            IMPORTING
              e_column_start = lv_column_start
              e_column_end   = lv_column_end
              e_row_start    = lv_row_start
              e_row_end      = lv_row_end
          ).
        CATCH zcx_excel.    ""
          RETURN.
      ENDTRY.
      IF lv_column_start = 'A' AND lv_column_end = 'XFD'.
        lv_cell_coord_start = |{ lv_row_start }|.
        lv_cell_coord_stop = |{ lv_row_end }|.
        CLEAR lt_cell_coord_parts.
        CLEAR lv_range_stop.
      ELSE.
        RETURN.
      ENDIF.
    ENDIF.

    IF lines( lt_cell_coord_parts ) >= 2.
      READ TABLE lt_cell_coord_parts INTO lv_cell_coord_start INDEX 2.
    ENDIF.

    IF lv_cell_coord_start CO '0123456789'.
      APPEND INITIAL LINE TO mt_range ASSIGNING <ls_range>.
      <ls_range>-sheet = lv_range_sheet.
      <ls_range>-name = lv_range_name.
      <ls_range>-start = lv_cell_coord_start.

      SPLIT lv_range_stop AT '$' INTO TABLE lt_cell_coord_parts.
      READ TABLE lt_cell_coord_parts INTO lv_cell_coord_stop INDEX 2.
      <ls_range>-stop = lv_cell_coord_stop.

      <ls_range>-length = <ls_range>-stop - <ls_range>-start + 1.

    ENDIF.

  ENDMETHOD.
ENDCLASS.
",4897,False,1045.2440316164088,median
"/******************************************************************************
 *
 * Project:  OpenGIS Simple Features Reference Implementation
 * Purpose:  Utility functions for OGR classes, including some related to
 *           parsing well known text format vectors.
 * Author:   Frank Warmerdam, warmerdam@pobox.com
 *
 ******************************************************************************
 * Copyright (c) 1999, Frank Warmerdam
 * Copyright (c) 2008-2014, 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 ""cpl_port.h""
#include ""ogr_p.h""

#include <cassert>
#include <cmath>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <limits>
#include <sstream>
#include <iomanip>

#include ""cpl_conv.h""
#include ""cpl_error.h""
#include ""cpl_string.h""
#include ""cpl_time.h""
#include ""cpl_vsi.h""
#include ""gdal.h""
#include ""ogr_core.h""
#include ""ogr_geometry.h""
#include ""ogrsf_frmts.h""

CPL_CVSID(""$Id: ogrutils.cpp 3b83dfb59dba8a1b3ba3d18b396d6a6582fae8c0 2021-02-03 11:25:41 +0100 Even Rouault $"")

// Returns whether a double fits within an int.
// Unable to put this in cpl_port.h as include limit breaks grib.
inline bool CPLIsDoubleAnInt(double d)
{
    // Write it this way to detect NaN
    if ( !(d >= std::numeric_limits<int>::min() &&
           d <= std::numeric_limits<int>::max()) )
    {
        return false;
    }
    return d == static_cast<double>(static_cast<int>(d));
}

namespace
{

// Remove trailing zeros except the last one.
std::string removeTrailingZeros(std::string s)
{
    auto pos = s.find('.');
    if (pos == std::string::npos)
        return s;

    // Remove zeros at the end.  We know this won't be npos because we
    // have a decimal point.
    auto nzpos = s.find_last_not_of('0');
    s = s.substr(0, nzpos + 1);

    // Make sure there is one 0 after the decimal point.
    if (s.back() == '.')
        s += '0';
    return s;
}

// Round a string representing a number by 1 in the least significant digit.
std::string roundup(std::string s)
{
    // Remove a negative sign if it exists to make processing
    // more straigtforward.
    bool negative(false);
    if (s[0] == '-')
    {
        negative = true;
        s = s.substr(1);
    }

    // Go from the back to the front.  If we increment a digit other than
    // a '9', we're done.  If we increment a '9', set it to a '0' and move
    // to the next (more significant) digit.  If we get to the front of the
    // string, add a '1' to the front of the string.
    for (int pos = static_cast<int>(s.size() - 1); pos >= 0; pos--)
    {
        if (s[pos] == '.')
            continue;
        s[pos]++;

        // Incrementing past 9 gets you a colon in ASCII.
        if (s[pos] != ':')
            break;
        else
            s[pos] = '0';
        if (pos == 0)
            s = '1' + s;
    }
    if (negative)
        s = '-' + s;
    return s;
}


// This attempts to elimiate what is likely binary -> decimal representation
// error or the result of low-order rounding with calculations.  The result
// may be more visually pleasing and takes up fewer places.
std::string intelliround(std::string& s)
{
    // If there is no decimal point, just return.
    auto dotPos = s.find(""."");
    if (dotPos == std::string::npos)
        return s;

    // Don't mess with exponential formatting.
    if (s.find_first_of(""eE"") != std::string::npos)
        return s;
    size_t iDotPos = static_cast<size_t>(dotPos);
    size_t nCountBeforeDot = iDotPos - 1;
    if (s[0] == '-')
        nCountBeforeDot--;
    size_t i = s.size();

    // If we don't have ten characters, don't do anything.
    if (i <= 10)
        return s;

    /* -------------------------------------------------------------------- */
    /*      Trim trailing 00000x's as they are likely roundoff error.       */
    /* -------------------------------------------------------------------- */
    if (s[i-2] == '0' && s[i-3] == '0' && s[i-4] == '0' &&
            s[i-5] == '0' && s[i-6] == '0')
    {
        s.resize(s.size() - 1);
    }
    // I don't understand this case exactly.  It's like saying if the
    // value is large enough and there are sufficient sig digits before
    // a bunch of zeros, remove the zeros and any digits at the end that
    // may be nonzero.  Perhaps if we can't exactly explain in words what
    // we're doing here, we shouldn't do it?  Perhaps it should
    // be generalized?
    // The value ""12345.000000011"" invokes this case, if anyone
    // is interested.
    else if (iDotPos < i - 8 &&
            (nCountBeforeDot >= 4 || s[i-3] == '0') &&
            (nCountBeforeDot >= 5 || s[i-4] == '0') &&
            (nCountBeforeDot >= 6 || s[i-5] == '0') &&
            (nCountBeforeDot >= 7 || s[i-6] == '0') &&
            (nCountBeforeDot >= 8 || s[i-7] == '0') &&
            s[i-8] == '0' && s[i-9] == '0')
    {
        s.resize(s.size() - 8);
    }
    /* -------------------------------------------------------------------- */
    /*      Trim trailing 99999x's as they are likely roundoff error.       */
    /* -------------------------------------------------------------------- */
    else if (s[i-2] == '9' && s[i-3] == '9' && s[i-4] == '9' &&
            s[i-5] == '9' && s[i-6] == '9' )
    {
        s.resize(i - 6);
        s = roundup(s);
    }
    else if (iDotPos < i - 9 &&
            (nCountBeforeDot >= 4 || s[i-3] == '9') &&
            (nCountBeforeDot >= 5 || s[i-4] == '9') &&
            (nCountBeforeDot >= 6 || s[i-5] == '9') &&
            (nCountBeforeDot >= 7 || s[i-6] == '9') &&
            (nCountBeforeDot >= 8 || s[i-7] == '9') &&
            s[i-8] == '9' && s[i-9] == '9')
    {
        s.resize(i - 9);
        s = roundup(s);
    }
    return s;
}

} // unnamed namespace

/************************************************************************/
/*                        OGRFormatDouble()                             */
/************************************************************************/

void OGRFormatDouble( char *pszBuffer, int nBufferLen, double dfVal,
                      char chDecimalSep, int nPrecision,
                      char chConversionSpecifier )
{
    OGRWktOptions opts;

    opts.precision = nPrecision;
    opts.format =
        (chConversionSpecifier == 'g' || chConversionSpecifier == 'G') ?
        OGRWktFormat::G :
        OGRWktFormat::F;

    std::string s = OGRFormatDouble(dfVal, opts);
    if (chDecimalSep != '\\0' && chDecimalSep != '.')
    {
        auto pos = s.find('.');
        if (pos != std::string::npos)
            s.replace(pos, 1, std::string(1, chDecimalSep));
    }
    if (s.size() + 1 > static_cast<size_t>(nBufferLen))
    {
        CPLError(CE_Warning, CPLE_AppDefined, ""Truncated double value %s to ""
            ""%s."", s.data(), s.substr(0, nBufferLen - 1).data());
        s.resize(nBufferLen - 1);
    }
    strcpy(pszBuffer, s.data());
}


/// Simplified OGRFormatDouble that can be made to adhere to provided
/// options.
std::string OGRFormatDouble(double val, const OGRWktOptions& opts)
{
    // So to have identical cross platform representation.
    if( CPLIsInf(val) )
        return (val > 0) ? ""inf"" : ""-inf"";
    if( CPLIsNan(val) )
        return ""nan"";

    std::ostringstream oss;
    oss.imbue(std::locale::classic());  // Make sure we output decimal points.
    bool l_round(opts.round);
    if (opts.format == OGRWktFormat::F ||
        (opts.format == OGRWktFormat::Default && fabs(val) < 1))
        oss << std::fixed;
    else
    {
        // Uppercase because OGC spec says capital 'E'.
        oss << std::uppercase;
        l_round = false;
    }
    oss << std::setprecision(opts.precision);
    oss << val;

    std::string sval = oss.str();

    if (l_round)
        sval = intelliround(sval);
    return removeTrailingZeros(sval);
}

/************************************************************************/
/*                        OGRMakeWktCoordinate()                        */
/*                                                                      */
/*      Format a well known text coordinate, trying to keep the         */
/*      ASCII representation compact, but accurate.  These rules        */
/*      will have to tighten up in the future.                          */
/*                                                                      */
/*      Currently a new point should require no more than 64            */
/*      characters barring the X or Y value being extremely large.      */
/************************************************************************/

void OGRMakeWktCoordinate( char *pszTarget, double x, double y, double z,
                           int nDimension )

{
    std::string wkt = OGRMakeWktCoordinate(x, y, z, nDimension,
        OGRWktOptions());
    memcpy(pszTarget, wkt.data(), wkt.size() + 1);
}

static bool isInteger(const std::string& s)
{
    return s.find_first_not_of(""0123456789"") == std::string::npos;
}

std::string OGRMakeWktCoordinate(double x, double y, double z, int nDimension,
    OGRWktOptions opts)
{
    std::string xval;
    std::string yval;

    // Why do we do this?  Seems especially strange since we're ADDING
    // "".0"" onto values in the case below.  The ""&&"" here also seems strange.
    if( opts.format == OGRWktFormat::Default &&
        CPLIsDoubleAnInt(x) && CPLIsDoubleAnInt(y) )
    {
        xval = std::to_string(static_cast<int>(x));
        yval = std::to_string(static_cast<int>(y));
    }
    else
    {
        xval = OGRFormatDouble(x, opts);
        //ABELL - Why do we do special formatting?
        if (isInteger(xval))
            xval += "".0"";

        yval = OGRFormatDouble(y, opts);
        if (isInteger(yval))
            yval += "".0"";
    }
    std::string wkt = xval + "" "" + yval;

    // Why do we always format Z with type G.
    if( nDimension == 3 )
    {
        if(opts.format == OGRWktFormat::Default && CPLIsDoubleAnInt(z) )
            wkt += "" "" + std::to_string(static_cast<int>(z));
        else
        {
            opts.format = OGRWktFormat::G;
            wkt += "" "" + OGRFormatDouble(z, opts);
        }
    }
    return wkt;
}

/************************************************************************/
/*                        OGRMakeWktCoordinateM()                       */
/*                                                                      */
/*      Format a well known text coordinate, trying to keep the         */
/*      ASCII representation compact, but accurate.  These rules        */
/*      will have to tighten up in the future.                          */
/*                                                                      */
/*      Currently a new point should require no more than 64            */
/*      characters barring the X or Y value being extremely large.      */
/************************************************************************/

void OGRMakeWktCoordinateM( char *pszTarget,
                            double x, double y, double z, double m,
                            OGRBoolean hasZ, OGRBoolean hasM )

{
    std::string wkt = OGRMakeWktCoordinateM(x, y, z, m, hasZ, hasM,
        OGRWktOptions());
    memcpy(pszTarget, wkt.data(), wkt.size() + 1);
}

std::string OGRMakeWktCoordinateM(double x, double y, double z, double m,
                                  OGRBoolean hasZ, OGRBoolean hasM,
                                  OGRWktOptions opts)
{
    std::string xval, yval;
    if( opts.format == OGRWktFormat::Default &&
        CPLIsDoubleAnInt(x) && CPLIsDoubleAnInt(y) )
    {
        xval = std::to_string(static_cast<int>(x));
        yval = std::to_string(static_cast<int>(y));
    }
    else
    {
        xval = OGRFormatDouble(x, opts);
        if (isInteger(xval))
            xval += "".0"";

        yval = OGRFormatDouble(y, opts);
        if (isInteger(yval))
            yval += "".0"";
    }
    std::string wkt = xval + "" "" + yval;

    // For some reason we always format Z and M as G-type
    opts.format = OGRWktFormat::G;
    if( hasZ )
    {
        /*if( opts.format == OGRWktFormat::Default && CPLIsDoubleAnInt(z) )
            wkt += "" "" + std::to_string(static_cast<int>(z));
        else*/
            wkt += "" "" + OGRFormatDouble(z, opts);
    }

    if( hasM )
    {
        /*if( opts.format == OGRWktFormat::Default && CPLIsDoubleAnInt(m) )
            wkt += "" "" + std::to_string(static_cast<int>(m));
        else*/
            wkt += "" "" + OGRFormatDouble(m, opts);
    }
    return wkt;
}

/************************************************************************/
/*                          OGRWktReadToken()                           */
/*                                                                      */
/*      Read one token or delimiter and put into token buffer.  Pre     */
/*      and post white space is swallowed.                              */
/************************************************************************/

const char *OGRWktReadToken( const char * pszInput, char * pszToken )

{
    if( pszInput == nullptr )
        return nullptr;

/* -------------------------------------------------------------------- */
/*      Swallow pre-white space.                                        */
/* -------------------------------------------------------------------- */
    while( *pszInput == ' ' || *pszInput == '\\t' )
        ++pszInput;

/* -------------------------------------------------------------------- */
/*      If this is a delimiter, read just one character.                */
/* -------------------------------------------------------------------- */
    if( *pszInput == '(' || *pszInput == ')' || *pszInput == ',' )
    {
        pszToken[0] = *pszInput;
        pszToken[1] = '\\0';

        ++pszInput;
    }

/* -------------------------------------------------------------------- */
/*      Or if it alpha numeric read till we reach non-alpha numeric     */
/*      text.                                                           */
/* -------------------------------------------------------------------- */
    else
    {
        int iChar = 0;

        while( iChar < OGR_WKT_TOKEN_MAX-1
               && ((*pszInput >= 'a' && *pszInput <= 'z')
                   || (*pszInput >= 'A' && *pszInput <= 'Z')
                   || (*pszInput >= '0' && *pszInput <= '9')
                   || *pszInput == '.'
                   || *pszInput == '+'
                   || *pszInput == '-') )
        {
            pszToken[iChar++] = *(pszInput++);
        }

        pszToken[iChar++] = '\\0';
    }

/* -------------------------------------------------------------------- */
/*      Eat any trailing white space.                                   */
/* -------------------------------------------------------------------- */
    while( *pszInput == ' ' || *pszInput == '\\t' )
        ++pszInput;

    return pszInput;
}

/************************************************************************/
/*                          OGRWktReadPoints()                          */
/*                                                                      */
/*      Read a point string.  The point list must be contained in       */
/*      brackets and each point pair separated by a comma.              */
/************************************************************************/

const char * OGRWktReadPoints( const char * pszInput,
                               OGRRawPoint ** ppaoPoints, double **ppadfZ,
                               int * pnMaxPoints,
                               int * pnPointsRead )

{
    const char *pszOrigInput = pszInput;
    *pnPointsRead = 0;

    if( pszInput == nullptr )
        return nullptr;

/* -------------------------------------------------------------------- */
/*      Eat any leading white space.                                    */
/* -------------------------------------------------------------------- */
    while( *pszInput == ' ' || *pszInput == '\\t' )
        ++pszInput;

/* -------------------------------------------------------------------- */
/*      If this isn't an opening bracket then we have a problem.        */
/* -------------------------------------------------------------------- */
    if( *pszInput != '(' )
    {
        CPLDebug( ""OGR"",
                  ""Expected '(', but got %s in OGRWktReadPoints()."",
                  pszInput );

        return pszInput;
    }

    ++pszInput;

/* ==================================================================== */
/*      This loop reads a single point.  It will continue till we       */
/*      run out of well formed points, or a closing bracket is          */
/*      encountered.                                                    */
/* ==================================================================== */
    char szDelim[OGR_WKT_TOKEN_MAX] = {};

    do {
/* -------------------------------------------------------------------- */
/*      Read the X and Y values, verify they are numeric.               */
/* -------------------------------------------------------------------- */
        char szTokenX[OGR_WKT_TOKEN_MAX] = {};
        char szTokenY[OGR_WKT_TOKEN_MAX] = {};

        pszInput = OGRWktReadToken( pszInput, szTokenX );
        pszInput = OGRWktReadToken( pszInput, szTokenY );

        if( (!isdigit(szTokenX[0]) && szTokenX[0] != '-' && szTokenX[0] != '.' )
            || (!isdigit(szTokenY[0]) && szTokenY[0] != '-' &&
                szTokenY[0] != '.') )
            return nullptr;

/* -------------------------------------------------------------------- */
/*      Do we need to grow the point list to hold this point?           */
/* -------------------------------------------------------------------- */
        if( *pnPointsRead == *pnMaxPoints )
        {
            *pnMaxPoints = *pnMaxPoints * 2 + 10;
            *ppaoPoints = static_cast<OGRRawPoint *>(
                CPLRealloc(*ppaoPoints, sizeof(OGRRawPoint) * *pnMaxPoints) );

            if( *ppadfZ != nullptr )
            {
                *ppadfZ = static_cast<double *>(
                    CPLRealloc(*ppadfZ, sizeof(double) * *pnMaxPoints) );
            }
        }

/* -------------------------------------------------------------------- */
/*      Add point to list.                                              */
/* -------------------------------------------------------------------- */
        (*ppaoPoints)[*pnPointsRead].x = CPLAtof(szTokenX);
        (*ppaoPoints)[*pnPointsRead].y = CPLAtof(szTokenY);

/* -------------------------------------------------------------------- */
/*      Do we have a Z coordinate?                                      */
/* -------------------------------------------------------------------- */
        pszInput = OGRWktReadToken( pszInput, szDelim );

        if( isdigit(szDelim[0]) || szDelim[0] == '-' || szDelim[0] == '.' )
        {
            if( *ppadfZ == nullptr )
            {
                *ppadfZ = static_cast<double *>(
                    CPLCalloc(sizeof(double), *pnMaxPoints) );
            }

            (*ppadfZ)[*pnPointsRead] = CPLAtof(szDelim);

            pszInput = OGRWktReadToken( pszInput, szDelim );
        }
        else if( *ppadfZ != nullptr )
        {
            (*ppadfZ)[*pnPointsRead] = 0.0;
        }

        ++(*pnPointsRead);

/* -------------------------------------------------------------------- */
/*      Do we have a M coordinate?                                      */
/*      If we do, just skip it.                                         */
/* -------------------------------------------------------------------- */
        if( isdigit(szDelim[0]) || szDelim[0] == '-' || szDelim[0] == '.' )
        {
            pszInput = OGRWktReadToken( pszInput, szDelim );
        }

/* -------------------------------------------------------------------- */
/*      Read next delimiter ... it should be a comma if there are       */
/*      more points.                                                    */
/* -------------------------------------------------------------------- */
        if( szDelim[0] != ')' && szDelim[0] != ',' )
        {
            CPLDebug( ""OGR"",
                      ""Corrupt input in OGRWktReadPoints().  ""
                      ""Got `%s' when expecting `,' or `)', near `%s' in %s."",
                      szDelim, pszInput, pszOrigInput );
            return nullptr;
        }
    } while( szDelim[0] == ',' );

    return pszInput;
}

/************************************************************************/
/*                          OGRWktReadPointsM()                         */
/*                                                                      */
/*      Read a point string.  The point list must be contained in       */
/*      brackets and each point pair separated by a comma.              */
/************************************************************************/

const char * OGRWktReadPointsM( const char * pszInput,
                                OGRRawPoint ** ppaoPoints,
                                double **ppadfZ, double **ppadfM,
                                int * flags,
                                int * pnMaxPoints,
                                int * pnPointsRead )

{
    const char *pszOrigInput = pszInput;
    const bool bNoFlags =
        !(*flags & OGRGeometry::OGR_G_3D) &&
        !(*flags & OGRGeometry::OGR_G_MEASURED);
    *pnPointsRead = 0;

    if( pszInput == nullptr )
        return nullptr;

/* -------------------------------------------------------------------- */
/*      Eat any leading white space.                                    */
/* -------------------------------------------------------------------- */
    while( *pszInput == ' ' || *pszInput == '\\t' )
        ++pszInput;

/* -------------------------------------------------------------------- */
/*      If this isn't an opening bracket then we have a problem.        */
/* -------------------------------------------------------------------- */
    if( *pszInput != '(' )
    {
        CPLDebug( ""OGR"",
                  ""Expected '(', but got %s in OGRWktReadPointsM()."",
                  pszInput );

        return pszInput;
    }

    ++pszInput;

/* ==================================================================== */
/*      This loop reads a single point.  It will continue till we       */
/*      run out of well formed points, or a closing bracket is          */
/*      encountered.                                                    */
/* ==================================================================== */
    char szDelim[OGR_WKT_TOKEN_MAX] = {};

    do {
/* -------------------------------------------------------------------- */
/*      Read the X and Y values, verify they are numeric.               */
/* -------------------------------------------------------------------- */
        char szTokenX[OGR_WKT_TOKEN_MAX] = {};
        char szTokenY[OGR_WKT_TOKEN_MAX] = {};

        pszInput = OGRWktReadToken( pszInput, szTokenX );
        pszInput = OGRWktReadToken( pszInput, szTokenY );

        if( (!isdigit(szTokenX[0]) && szTokenX[0] != '-' && szTokenX[0] != '.' )
            || (!isdigit(szTokenY[0]) && szTokenY[0] != '-' &&
                szTokenY[0] != '.') )
            return nullptr;

/* -------------------------------------------------------------------- */
/*      Do we need to grow the point list to hold this point?           */
/* -------------------------------------------------------------------- */
        if( *pnPointsRead == *pnMaxPoints )
        {
            *pnMaxPoints = *pnMaxPoints * 2 + 10;
            *ppaoPoints = static_cast<OGRRawPoint *>(
                CPLRealloc(*ppaoPoints, sizeof(OGRRawPoint) * *pnMaxPoints) );

            if( *ppadfZ != nullptr )
            {
                *ppadfZ = static_cast<double *>(
                    CPLRealloc(*ppadfZ, sizeof(double) * *pnMaxPoints) );
            }

            if( *ppadfM != nullptr )
            {
                *ppadfM = static_cast<double *>(
                    CPLRealloc(*ppadfM, sizeof(double) * *pnMaxPoints) );
            }
        }

/* -------------------------------------------------------------------- */
/*      Add point to list.                                              */
/* -------------------------------------------------------------------- */
        (*ppaoPoints)[*pnPointsRead].x = CPLAtof(szTokenX);
        (*ppaoPoints)[*pnPointsRead].y = CPLAtof(szTokenY);

/* -------------------------------------------------------------------- */
/*      Read the next token.                                            */
/* -------------------------------------------------------------------- */
        pszInput = OGRWktReadToken( pszInput, szDelim );

/* -------------------------------------------------------------------- */
/*      If there are unexpectedly more coordinates, they are Z.         */
/* -------------------------------------------------------------------- */

        if( !(*flags & OGRGeometry::OGR_G_3D) &&
            !(*flags & OGRGeometry::OGR_G_MEASURED) &&
            (isdigit(szDelim[0]) || szDelim[0] == '-' || szDelim[0] == '.' ))
        {
            *flags |= OGRGeometry::OGR_G_3D;
        }

/* -------------------------------------------------------------------- */
/*      Get Z if flag says so.                                          */
/*      Zero out possible remains from earlier strings.                 */
/* -------------------------------------------------------------------- */

        if( *flags & OGRGeometry::OGR_G_3D )
        {
            if( *ppadfZ == nullptr )
            {
                *ppadfZ = static_cast<double *>(
                    CPLCalloc(sizeof(double), *pnMaxPoints) );
            }
            if( isdigit(szDelim[0]) || szDelim[0] == '-' || szDelim[0] == '.' )
            {
                (*ppadfZ)[*pnPointsRead] = CPLAtof(szDelim);
                pszInput = OGRWktReadToken( pszInput, szDelim );
            }
            else
            {
                (*ppadfZ)[*pnPointsRead] = 0.0;
            }
        }
        else if( *ppadfZ != nullptr )
        {
            (*ppadfZ)[*pnPointsRead] = 0.0;
        }

/* -------------------------------------------------------------------- */
/*      If there are unexpectedly even more coordinates,                */
/*      they are discarded unless there were no flags originally.       */
/*      This is for backwards compatibility. Should this be an error?   */
/* -------------------------------------------------------------------- */

        if( !(*flags & OGRGeometry::OGR_G_MEASURED) &&
            (isdigit(szDelim[0]) || szDelim[0] == '-' || szDelim[0] == '.' ) )
        {
            if( bNoFlags )
            {
                *flags |= OGRGeometry::OGR_G_MEASURED;
            }
            else
            {
                pszInput = OGRWktReadToken( pszInput, szDelim );
            }
        }

/* -------------------------------------------------------------------- */
/*      Get M if flag says so.                                          */
/*      Zero out possible remains from earlier strings.                 */
/* -------------------------------------------------------------------- */

        if( *flags & OGRGeometry::OGR_G_MEASURED )
        {
            if( *ppadfM == nullptr )
            {
                *ppadfM = static_cast<double *>(
                    CPLCalloc(sizeof(double), *pnMaxPoints) );
            }
            if( isdigit(szDelim[0]) || szDelim[0] == '-' || szDelim[0] == '.' )
            {
                (*ppadfM)[*pnPointsRead] = CPLAtof(szDelim);
                pszInput = OGRWktReadToken( pszInput, szDelim );
            }
            else
            {
                (*ppadfM)[*pnPointsRead] = 0.0;
            }
        }
        else if( *ppadfM != nullptr )
        {
            (*ppadfM)[*pnPointsRead] = 0.0;
        }

/* -------------------------------------------------------------------- */
/*      If there are still more coordinates and we do not have Z        */
/*      then we have a case of flags == M and four coordinates.         */
/*      This is allowed in BNF.                                         */
/* -------------------------------------------------------------------- */

        if( !(*flags & OGRGeometry::OGR_G_3D) &&
            (isdigit(szDelim[0]) || szDelim[0] == '-' || szDelim[0] == '.') )
        {
            *flags |= OGRGeometry::OGR_G_3D;
            if( *ppadfZ == nullptr )
            {
                *ppadfZ = static_cast<double *>(
                    CPLCalloc(sizeof(double), *pnMaxPoints) );
            }
            (*ppadfZ)[*pnPointsRead] = (*ppadfM)[*pnPointsRead];
            (*ppadfM)[*pnPointsRead] = CPLAtof(szDelim);
            pszInput = OGRWktReadToken( pszInput, szDelim );
        }

/* -------------------------------------------------------------------- */
/*      Increase points index.                                          */
/* -------------------------------------------------------------------- */
        ++(*pnPointsRead);

/* -------------------------------------------------------------------- */
/*      The next delimiter should be a comma or an ending bracket.      */
/* -------------------------------------------------------------------- */
        if( szDelim[0] != ')' && szDelim[0] != ',' )
        {
            CPLDebug( ""OGR"",
                      ""Corrupt input in OGRWktReadPointsM()  ""
                      ""Got `%s' when expecting `,' or `)', near `%s' in %s."",
                      szDelim, pszInput, pszOrigInput );
            return nullptr;
        }
    } while( szDelim[0] == ',' );

    return pszInput;
}

/************************************************************************/
/*                             OGRMalloc()                              */
/*                                                                      */
/*      Cover for CPLMalloc()                                           */
/************************************************************************/

void *OGRMalloc( size_t size )

{
    return CPLMalloc( size );
}

/************************************************************************/
/*                             OGRCalloc()                              */
/*                                                                      */
/*      Cover for CPLCalloc()                                           */
/************************************************************************/

void *OGRCalloc( size_t count, size_t size )

{
    return CPLCalloc( count, size );
}

/************************************************************************/
/*                             OGRRealloc()                             */
/*                                                                      */
/*      Cover for CPLRealloc()                                          */
/************************************************************************/

void *OGRRealloc( void * pOld, size_t size )

{
    return CPLRealloc( pOld, size );
}

/************************************************************************/
/*                              OGRFree()                               */
/*                                                                      */
/*      Cover for CPLFree().                                            */
/************************************************************************/

void OGRFree( void * pMemory )

{
    CPLFree( pMemory );
}

/**
 * \\fn OGRGeneralCmdLineProcessor(int, char***, int)
 * General utility option processing.
 *
 * This function is intended to provide a variety of generic commandline
 * options for all OGR commandline utilities.  It takes care of the following
 * commandline options:
 *
 *  --version: report version of GDAL in use.
 *  --license: report GDAL license info.
 *  --format [format]: report details of one format driver.
 *  --formats: report all format drivers configured.
 *  --optfile filename: expand an option file into the argument list.
 *  --config key value: set system configuration option.
 *  --debug [on/off/value]: set debug level.
 *  --pause: Pause for user input (allows time to attach debugger)
 *  --locale [locale]: Install a locale using setlocale() (debugging)
 *  --help-general: report detailed help on general options.
 *
 * The argument array is replaced ""in place"" and should be freed with
 * CSLDestroy() when no longer needed.  The typical usage looks something
 * like the following.  Note that the formats should be registered so that
 * the --formats option will work properly.
 *
 *  int main( int argc, char ** argv )
 *  {
 *    OGRRegisterAll();
 *
 *    argc = OGRGeneralCmdLineProcessor( argc, &argv, 0 );
 *    if( argc < 1 )
 *        exit( -argc );
 *
 * @param nArgc number of values in the argument list.
 * @param ppapszArgv pointer to the argument list array (will be updated in
 * place).
 * @param nOptions unused.
 *
 * @return updated nArgc argument count.  Return of 0 requests terminate
 * without error, return of -1 requests exit with error code.
 */

int OGRGeneralCmdLineProcessor( int nArgc, char ***ppapszArgv,
                                CPL_UNUSED int nOptions )

{
    return GDALGeneralCmdLineProcessor( nArgc, ppapszArgv, GDAL_OF_VECTOR );
}

/************************************************************************/
/*                            OGRParseDate()                            */
/*                                                                      */
/*      Parse a variety of text date formats into an OGRField.          */
/************************************************************************/

/**
 * Parse date string.
 *
 * This function attempts to parse a date string in a variety of formats
 * into the OGRField.Date format suitable for use with OGR.  Generally
 * speaking this function is expecting values like:
 *
 *   YYYY-MM-DD HH:MM:SS[.sss]+nn
 *   or YYYY-MM-DDTHH:MM:SS[.sss]Z (ISO 8601 format)
 *   or YYYY-MM-DDZ
 *
 * The seconds may also have a decimal portion (which is ignored).  And
 * just dates (YYYY-MM-DD) or just times (HH:MM:SS[.sss]) are also supported.
 * The date may also be in YYYY/MM/DD format.  If the year is less than 100
 * and greater than 30 a ""1900"" century value will be set.  If it is less than
 * 30 and greater than -1 then a ""2000"" century value will be set.  In
 * the future this function may be generalized, and additional control
 * provided through nOptions, but an nOptions value of ""0"" should always do
 * a reasonable default form of processing.
 *
 * The value of psField will be indeterminate if the function fails (returns
 * FALSE).
 *
 * @param pszInput the input date string.
 * @param psField the OGRField that will be updated with the parsed result.
 * @param nOptions parsing options, for now always 0.
 *
 * @return TRUE if apparently successful or FALSE on failure.
 */

int OGRParseDate( const char *pszInput,
                  OGRField *psField,
                  CPL_UNUSED int nOptions )
{
    psField->Date.Year = 0;
    psField->Date.Month = 0;
    psField->Date.Day = 0;
    psField->Date.Hour = 0;
    psField->Date.Minute = 0;
    psField->Date.Second = 0;
    psField->Date.TZFlag = 0;
    psField->Date.Reserved = 0;

/* -------------------------------------------------------------------- */
/*      Do we have a date?                                              */
/* -------------------------------------------------------------------- */
    while( *pszInput == ' ' )
        ++pszInput;

    bool bGotSomething = false;
    if( strstr(pszInput,""-"") != nullptr || strstr(pszInput,""/"") != nullptr )
    {
        if( !(*pszInput == '-' || *pszInput == '+' ||
              (*pszInput >= '0' && *pszInput <= '9')) )
            return FALSE;
        int nYear = atoi(pszInput);
        if (nYear > std::numeric_limits<GInt16>::max() ||
            nYear < std::numeric_limits<GInt16>::min() )
        {
            CPLError(CE_Failure, CPLE_NotSupported,
                     ""Years < %d or > %d are not supported"",
                     std::numeric_limits<GInt16>::min(),
                     std::numeric_limits<GInt16>::max());
            return FALSE;
        }
        psField->Date.Year = static_cast<GInt16>(nYear);
        if( (pszInput[1] == '-' || pszInput[1] == '/' ) ||
            (pszInput[1] != '\\0' &&
             (pszInput[2] == '-' || pszInput[2] == '/' )) )
        {
            if( psField->Date.Year < 100 && psField->Date.Year >= 30 )
                psField->Date.Year += 1900;
            else if( psField->Date.Year < 30 && psField->Date.Year >= 0 )
                psField->Date.Year += 2000;
        }

        if( *pszInput == '-' )
            ++pszInput;
        while( *pszInput >= '0' && *pszInput <= '9' )
            ++pszInput;
        if( *pszInput != '-' && *pszInput != '/' )
            return FALSE;
        else
            ++pszInput;

        const int nMonth = atoi(pszInput);
        if( nMonth <= 0 || nMonth > 12 )
            return FALSE;
        psField->Date.Month = static_cast<GByte>(nMonth);

        while( *pszInput >= '0' && *pszInput <= '9' )
            ++pszInput;
        if( *pszInput != '-' && *pszInput != '/' )
            return FALSE;
        else
            ++pszInput;

        const int nDay = atoi(pszInput);
        if( nDay <= 0 || nDay > 31 )
            return FALSE;
        psField->Date.Day = static_cast<GByte>(nDay);

        while( *pszInput >= '0' && *pszInput <= '9' )
            ++pszInput;
        if( *pszInput == '\\0' )
            return TRUE;

        bGotSomething = true;

        // If ISO 8601 format.
        if( *pszInput == 'T' )
            ++pszInput;
        else if( *pszInput == 'Z' )
            return TRUE;
        else if( *pszInput != ' ' )
            return FALSE;
    }

/* -------------------------------------------------------------------- */
/*      Do we have a time?                                              */
/* -------------------------------------------------------------------- */
    while( *pszInput == ' ' )
        ++pszInput;

    if( strstr(pszInput, "":"") != nullptr )
    {
        if( !(*pszInput >= '0' && *pszInput <= '9') )
            return FALSE;
        const int nHour = atoi(pszInput);
        if( nHour < 0 || nHour > 23 )
            return FALSE;
        psField->Date.Hour = static_cast<GByte>(nHour);

        while( *pszInput >= '0' && *pszInput <= '9' )
            ++pszInput;
        if( *pszInput != ':' )
            return FALSE;
        else
            ++pszInput;

        if( !(*pszInput >= '0' && *pszInput <= '9') )
            return FALSE;
        const int nMinute = atoi(pszInput);
        if( nMinute < 0 || nMinute > 59 )
            return FALSE;
        psField->Date.Minute = static_cast<GByte>(nMinute);

        while( *pszInput >= '0' && *pszInput <= '9' )
            ++pszInput;
        if( *pszInput == ':' )
        {
            ++pszInput;

            if( !(*pszInput >= '0' && *pszInput <= '9') )
                return FALSE;
            const double dfSeconds = CPLAtof(pszInput);
            // We accept second=60 for leap seconds
            if (dfSeconds > 60.0 || dfSeconds < 0.0) return FALSE;
            psField->Date.Second = static_cast<float>(dfSeconds);

            while( (*pszInput >= '0' && *pszInput <= '9')
                || *pszInput == '.' )
            {
                ++pszInput;
            }

            // If ISO 8601 format.
            if( *pszInput == 'Z' )
            {
                psField->Date.TZFlag = 100;
            }
        }

        bGotSomething = true;
    }

    // No date or time!
    if( !bGotSomething )
        return FALSE;

/* -------------------------------------------------------------------- */
/*      Do we have a timezone?                                          */
/* -------------------------------------------------------------------- */
    while( *pszInput == ' ' )
        ++pszInput;

    if( *pszInput == '-' || *pszInput == '+' )
    {
        // +HH integral offset
        if( strlen(pszInput) <= 3 )
        {
            psField->Date.TZFlag = static_cast<GByte>(100 + atoi(pszInput) * 4);
        }
        else if( pszInput[3] == ':'  // +HH:MM offset
                 && atoi(pszInput + 4) % 15 == 0 )
        {
            psField->Date.TZFlag = static_cast<GByte>(100
                + atoi(pszInput + 1) * 4
                + (atoi(pszInput + 4) / 15));

            if( pszInput[0] == '-' )
                psField->Date.TZFlag = -1 * (psField->Date.TZFlag - 100) + 100;
        }
        else if( isdigit(pszInput[3]) && isdigit(pszInput[4])  // +HHMM offset
                 && atoi(pszInput + 3) % 15 == 0 )
        {
            psField->Date.TZFlag = static_cast<GByte>(100
                + static_cast<GByte>(CPLScanLong(pszInput + 1, 2)) * 4
                + (atoi(pszInput + 3) / 15));

            if( pszInput[0] == '-' )
                psField->Date.TZFlag = -1 * (psField->Date.TZFlag - 100) + 100;
        }
        else if( isdigit(pszInput[3]) && pszInput[4] == '\\0'  // +HMM offset
                 && atoi(pszInput + 2) % 15 == 0 )
        {
            psField->Date.TZFlag = static_cast<GByte>(100
                + static_cast<GByte>(CPLScanLong(pszInput + 1, 1)) * 4
                + (atoi(pszInput + 2) / 15));

            if( pszInput[0] == '-' )
                psField->Date.TZFlag = -1 * (psField->Date.TZFlag - 100) + 100;
        }
        // otherwise ignore any timezone info.
    }

    return TRUE;
}

/************************************************************************/
/*                           OGRParseXMLDateTime()                      */
/************************************************************************/

int OGRParseXMLDateTime( const char* pszXMLDateTime,
                         OGRField* psField)
{
    int year = 0;
    int month = 0;
    int day = 0;
    int hour = 0;
    int minute = 0;
    int TZHour = 0;
    int TZMinute = 0;
    float second = 0;
    char c = '\\0';
    int TZ = 0;
    bool bRet = false;

    // Date is expressed as a UTC date.
    if( sscanf(pszXMLDateTime, ""%04d-%02d-%02dT%02d:%02d:%f%c"",
               &year, &month, &day, &hour, &minute, &second, &c) == 7 &&
        c == 'Z' )
    {
        TZ = 100;
        bRet = true;
    }
    // Date is expressed as a UTC date, with a timezone.
    else if( sscanf(pszXMLDateTime, ""%04d-%02d-%02dT%02d:%02d:%f%c%02d:%02d"",
                    &year, &month, &day, &hour, &minute, &second, &c,
                    &TZHour, &TZMinute) == 9 &&
             (c == '+' || c == '-') )
    {
        TZ = 100 + ((c == '+') ? 1 : -1) * ((TZHour * 60 + TZMinute) / 15);
        bRet = true;
    }
    // Date is expressed into an unknown timezone.
    else if( sscanf(pszXMLDateTime, ""%04d-%02d-%02dT%02d:%02d:%f"",
                    &year, &month, &day, &hour, &minute, &second) == 6 )
    {
        TZ = 0;
        bRet = true;
    }
    // Date is expressed as a UTC date with only year:month:day.
    else if( sscanf(pszXMLDateTime, ""%04d-%02d-%02d"", &year, &month, &day) ==
             3 )
    {
        TZ = 0;
        bRet = true;
    }
    // Date is expressed as a UTC date with only year:month.
    else if( sscanf(pszXMLDateTime, ""%04d-%02d"", &year, &month) ==
             2 )
    {
        TZ = 0;
        bRet = true;
        day = 1;
    }

    if( !bRet )
      return FALSE;

    psField->Date.Year = static_cast<GInt16>(year);
    psField->Date.Month = static_cast<GByte>(month);
    psField->Date.Day = static_cast<GByte>(day);
    psField->Date.Hour = static_cast<GByte>(hour);
    psField->Date.Minute = static_cast<GByte>(minute);
    psField->Date.Second = second;
    psField->Date.TZFlag = static_cast<GByte>(TZ);
    psField->Date.Reserved = 0;

    return TRUE;
}

/************************************************************************/
/*                      OGRParseRFC822DateTime()                        */
/************************************************************************/

static const char* const aszMonthStr[] = {
    ""Jan"", ""Feb"", ""Mar"", ""Apr"", ""May"", ""Jun"",
    ""Jul"", ""Aug"", ""Sep"", ""Oct"", ""Nov"", ""Dec"" };

int OGRParseRFC822DateTime( const char* pszRFC822DateTime, OGRField* psField )
{
    int nYear, nMonth, nDay, nHour, nMinute, nSecond, nTZFlag;
    if( !CPLParseRFC822DateTime( pszRFC822DateTime,
                                    &nYear,
                                    &nMonth,
                                    &nDay,
                                    &nHour,
                                    &nMinute,
                                    &nSecond,
                                    &nTZFlag,
                                    nullptr ) )
    {
        return false;
    }

    psField->Date.Year = static_cast<GInt16>(nYear);
    psField->Date.Month = static_cast<GByte>(nMonth);
    psField->Date.Day = static_cast<GByte>(nDay);
    psField->Date.Hour = static_cast<GByte>(nHour);
    psField->Date.Minute = static_cast<GByte>(nMinute);
    psField->Date.Second = (nSecond < 0) ? 0.0f : static_cast<float>(nSecond);
    psField->Date.TZFlag = static_cast<GByte>(nTZFlag);
    psField->Date.Reserved = 0;

    return true;
}

/**
  * Returns the day of the week in Gregorian calendar
  *
  * @param day : day of the month, between 1 and 31
  * @param month : month of the year, between 1 (Jan) and 12 (Dec)
  * @param year : year

  * @return day of the week : 0 for Monday, ... 6 for Sunday
  */

int OGRGetDayOfWeek( int day, int month, int year )
{
    // Reference: Zeller's congruence.
    const int q = day;
    int m = month;
    if( month >=3 )
    {
        // m = month;
    }
    else
    {
        m = month + 12;
        year--;
    }
    const int K = year % 100;
    const int J = year / 100;
    const int h = ( q + (((m+1)*26)/10) + K + K/4 + J/4 + 5 * J) % 7;
    return ( h + 5 ) % 7;
}

/************************************************************************/
/*                         OGRGetRFC822DateTime()                       */
/************************************************************************/

char* OGRGetRFC822DateTime( const OGRField* psField )
{
    char* pszTZ = nullptr;
    const char* const aszDayOfWeek[] =
        { ""Mon"", ""Tue"", ""Wed"", ""Thu"", ""Fri"", ""Sat"", ""Sun"" };

    int dayofweek = OGRGetDayOfWeek(psField->Date.Day, psField->Date.Month,
                                    psField->Date.Year);

    int month = psField->Date.Month;
    if( month < 1 || month > 12 )
        month = 1;

    int TZFlag = psField->Date.TZFlag;
    if( TZFlag == 0 || TZFlag == 100 )
    {
        pszTZ = CPLStrdup(""GMT"");
    }
    else
    {
        int TZOffset = std::abs(TZFlag - 100) * 15;
        int TZHour = TZOffset / 60;
        int TZMinute = TZOffset - TZHour * 60;
        pszTZ = CPLStrdup(CPLSPrintf(""%c%02d%02d"", TZFlag > 100 ? '+' : '-',
                                        TZHour, TZMinute));
    }
    char* pszRet = CPLStrdup(CPLSPrintf(
        ""%s, %02d %s %04d %02d:%02d:%02d %s"",
        aszDayOfWeek[dayofweek], psField->Date.Day, aszMonthStr[month - 1],
        psField->Date.Year, psField->Date.Hour,
        psField->Date.Minute, static_cast<int>(psField->Date.Second), pszTZ));
    CPLFree(pszTZ);
    return pszRet;
}

/************************************************************************/
/*                            OGRGetXMLDateTime()                       */
/************************************************************************/

char* OGRGetXMLDateTime(const OGRField* psField)
{
    return OGRGetXMLDateTime(psField, false);
}

char* OGRGetXMLDateTime(const OGRField* psField, bool bAlwaysMillisecond)
{
    const GInt16 year = psField->Date.Year;
    const GByte month = psField->Date.Month;
    const GByte day = psField->Date.Day;
    const GByte hour = psField->Date.Hour;
    const GByte minute = psField->Date.Minute;
    const float second = psField->Date.Second;
    const GByte TZFlag = psField->Date.TZFlag;

    char szTimeZone[7];
    char* pszRet = nullptr;

    switch( TZFlag )
    {
        case 0:    // Unknown time zone
        case 1:    // Local time zone (not specified)
            szTimeZone[0] = 0;
            break;

        case 100:  // GMT
            szTimeZone[0] = 'Z';
            szTimeZone[1] = 0;
            break;

        default:   // Offset (in quarter-hour units) from GMT
            const int TZOffset = std::abs(TZFlag - 100) * 15;
            const int TZHour = TZOffset / 60;
            const int TZMinute = TZOffset % 60;

            snprintf(szTimeZone, 7, ""%c%02d:%02d"",
                     (TZFlag > 100) ? '+' : '-', TZHour, TZMinute);
    }

    if( OGR_GET_MS(second) || bAlwaysMillisecond )
        pszRet = CPLStrdup(CPLSPrintf(
                               ""%04d-%02u-%02uT%02u:%02u:%06.3f%s"",
                               year, month, day, hour, minute, second,
                               szTimeZone));
    else
        pszRet = CPLStrdup(CPLSPrintf(
                               ""%04d-%02u-%02uT%02u:%02u:%02u%s"",
                               year, month, day, hour, minute,
                               static_cast<GByte>(second), szTimeZone));

    return pszRet;
}

/************************************************************************/
/*                 OGRGetXML_UTF8_EscapedString()                       */
/************************************************************************/

char* OGRGetXML_UTF8_EscapedString(const char* pszString)
{
    char *pszEscaped = nullptr;
    if( !CPLIsUTF8(pszString, -1) &&
         CPLTestBool(CPLGetConfigOption(""OGR_FORCE_ASCII"", ""YES"")) )
    {
        static bool bFirstTime = true;
        if( bFirstTime )
        {
            bFirstTime = false;
            CPLError(CE_Warning, CPLE_AppDefined,
                     ""%s is not a valid UTF-8 string. Forcing it to ASCII.  ""
                     ""If you still want the original string and change the XML ""
                     ""file encoding afterwards, you can define ""
                     ""OGR_FORCE_ASCII=NO as configuration option.  ""
                     ""This warning won't be issued anymore"", pszString);
        }
        else
        {
            CPLDebug(""OGR"",
                     ""%s is not a valid UTF-8 string. Forcing it to ASCII"",
                     pszString);
        }
        char* pszTemp = CPLForceToASCII(pszString, -1, '?');
        pszEscaped = CPLEscapeString( pszTemp, -1, CPLES_XML );
        CPLFree(pszTemp);
    }
    else
        pszEscaped = CPLEscapeString( pszString, -1, CPLES_XML );
    return pszEscaped;
}

/************************************************************************/
/*                        OGRCompareDate()                              */
/************************************************************************/

int OGRCompareDate( const OGRField *psFirstTuple,
                    const OGRField *psSecondTuple )
{
    // TODO: We ignore TZFlag.

    if( psFirstTuple->Date.Year < psSecondTuple->Date.Year )
        return -1;
    else if( psFirstTuple->Date.Year > psSecondTuple->Date.Year )
        return 1;

    if( psFirstTuple->Date.Month < psSecondTuple->Date.Month )
        return -1;
    else if( psFirstTuple->Date.Month > psSecondTuple->Date.Month )
        return 1;

    if( psFirstTuple->Date.Day < psSecondTuple->Date.Day )
        return -1;
    else if( psFirstTuple->Date.Day > psSecondTuple->Date.Day )
        return 1;

    if( psFirstTuple->Date.Hour < psSecondTuple->Date.Hour )
        return -1;
    else if( psFirstTuple->Date.Hour > psSecondTuple->Date.Hour )
        return 1;

    if( psFirstTuple->Date.Minute < psSecondTuple->Date.Minute )
        return -1;
    else if( psFirstTuple->Date.Minute > psSecondTuple->Date.Minute )
        return 1;

    if( psFirstTuple->Date.Second < psSecondTuple->Date.Second )
        return -1;
    else if( psFirstTuple->Date.Second > psSecondTuple->Date.Second )
        return 1;

    return 0;
}

/************************************************************************/
/*                        OGRFastAtof()                                 */
/************************************************************************/

// On Windows, CPLAtof() is very slow if the number is followed by other long
// content.  Just extract the number into a short string before calling
// CPLAtof() on it.
static
double OGRCallAtofOnShortString(const char* pszStr)
{
    const char* p = pszStr;
    while( *p == ' ' || *p == '\\t' )
        ++p;

    char szTemp[128] = {};
    int nCounter = 0;
    while( *p == '+' ||
           *p == '-' ||
           (*p >= '0' && *p <= '9') ||
           *p == '.' ||
           (*p == 'e' || *p == 'E' || *p == 'd' || *p == 'D') )
    {
        szTemp[nCounter++] = *(p++);
        if( nCounter == 127 )
            return CPLAtof(pszStr);
    }
    szTemp[nCounter] = '\\0';
    return CPLAtof(szTemp);
}

/** Same contract as CPLAtof, except than it doesn't always call the
 *  system CPLAtof() that may be slow on some platforms. For simple but
 *  common strings, it'll use a faster implementation (up to 20x faster
 *  than CPLAtof() on MS runtime libraries) that has no guaranty to return
 *  exactly the same floating point number.
 */

double OGRFastAtof(const char* pszStr)
{
    double dfVal = 0;
    double dfSign = 1.0;
    const char* p = pszStr;

    constexpr double adfTenPower[] =
    {
        1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10,
        1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19, 1e20,
        1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29, 1e30, 1e31
    };

    while( *p == ' ' || *p == '\\t' )
        ++p;

    if( *p == '+' )
        ++p;
    else if( *p == '-' )
    {
        dfSign = -1.0;
        ++p;
    }

    while( true )
    {
        if( *p >= '0' && *p <= '9' )
        {
            dfVal = dfVal * 10.0 + (*p - '0');
            ++p;
        }
        else if( *p == '.' )
        {
            ++p;
            break;
        }
        else if( *p == 'e' || *p == 'E' || *p == 'd' || *p == 'D' )
            return OGRCallAtofOnShortString(pszStr);
        else
            return dfSign * dfVal;
    }

    unsigned int countFractionnal = 0;
    while( true )
    {
        if( *p >= '0' && *p <= '9' )
        {
            dfVal = dfVal * 10.0 + (*p - '0');
            ++countFractionnal;
            ++p;
        }
        else if( *p == 'e' || *p == 'E' || *p == 'd' || *p == 'D' )
            return OGRCallAtofOnShortString(pszStr);
        else
        {
            if( countFractionnal < CPL_ARRAYSIZE(adfTenPower) )
                return dfSign * (dfVal / adfTenPower[countFractionnal]);
            else
                return OGRCallAtofOnShortString(pszStr);
        }
    }
}

/**
 * Check that panPermutation is a permutation of [0, nSize-1].
 * @param panPermutation an array of nSize elements.
 * @param nSize size of the array.
 * @return OGRERR_NONE if panPermutation is a permutation of [0, nSize - 1].
 * @since OGR 1.9.0
 */
OGRErr OGRCheckPermutation( int* panPermutation, int nSize )
{
    OGRErr eErr = OGRERR_NONE;
    int* panCheck = static_cast<int *>(CPLCalloc(nSize, sizeof(int)));
    for( int i = 0; i < nSize; ++i )
    {
        if( panPermutation[i] < 0 || panPermutation[i] >= nSize )
        {
            CPLError(CE_Failure, CPLE_IllegalArg,
                     ""Bad value for element %d"", i);
            eErr = OGRERR_FAILURE;
            break;
        }
        if( panCheck[panPermutation[i]] != 0 )
        {
            CPLError(CE_Failure, CPLE_IllegalArg,
                     ""Array is not a permutation of [0,%d]"",
                     nSize - 1);
            eErr = OGRERR_FAILURE;
            break;
        }
        panCheck[panPermutation[i]] = 1;
    }
    CPLFree(panCheck);
    return eErr;
}

OGRErr OGRReadWKBGeometryType( const unsigned char * pabyData,
                               OGRwkbVariant eWkbVariant,
                               OGRwkbGeometryType *peGeometryType )
{
    if( !peGeometryType )
        return OGRERR_FAILURE;

/* -------------------------------------------------------------------- */
/*      Get the byte order byte.                                        */
/* -------------------------------------------------------------------- */
    int nByteOrder = DB2_V72_FIX_BYTE_ORDER(*pabyData);
    if( !( nByteOrder == wkbXDR || nByteOrder == wkbNDR ) )
        return OGRERR_CORRUPT_DATA;
    OGRwkbByteOrder eByteOrder = static_cast<OGRwkbByteOrder>(nByteOrder);

/* -------------------------------------------------------------------- */
/*      Get the geometry type.                                          */
/* -------------------------------------------------------------------- */
    bool bIs3D = false;
    bool bIsMeasured = false;
    int iRawType = 0;

    memcpy(&iRawType, pabyData + 1, 4);
    if( OGR_SWAP(eByteOrder))
    {
        CPL_SWAP32PTR(&iRawType);
    }

    // Test for M bit in PostGIS WKB, see ogrgeometry.cpp:4956.
    if( 0x40000000 & iRawType )
    {
        iRawType &= ~0x40000000;
        bIsMeasured = true;
    }
    // Old-style OGC z-bit is flipped? Tests also Z bit in PostGIS WKB.
    if( wkb25DBitInternalUse & iRawType )
    {
        // Clean off top 3 bytes.
        iRawType &= 0x000000FF;
        bIs3D = true;
    }

    // ISO SQL/MM Part3 draft -> Deprecated.
    // See http://jtc1sc32.org/doc/N1101-1150/32N1107-WD13249-3--spatial.pdf
    if( iRawType == 1000001 )
        iRawType = wkbCircularString;
    else if( iRawType == 1000002 )
        iRawType = wkbCompoundCurve;
    else if( iRawType == 1000003 )
        iRawType = wkbCurvePolygon;
    else if( iRawType == 1000004 )
        iRawType = wkbMultiCurve;
    else if( iRawType == 1000005 )
        iRawType = wkbMultiSurface;
    else if( iRawType == 2000001 )
        iRawType = wkbPointZM;
    else if( iRawType == 2000002 )
        iRawType = wkbLineStringZM;
    else if( iRawType == 2000003 )
        iRawType = wkbCircularStringZM;
    else if( iRawType == 2000004 )
        iRawType = wkbCompoundCurveZM;
    else if( iRawType == 2000005 )
        iRawType = wkbPolygonZM;
    else if( iRawType == 2000006 )
        iRawType = wkbCurvePolygonZM;
    else if( iRawType == 2000007 )
        iRawType = wkbMultiPointZM;
    else if( iRawType == 2000008 )
        iRawType = wkbMultiCurveZM;
    else if( iRawType == 2000009 )
        iRawType = wkbMultiLineStringZM;
    else if( iRawType == 2000010 )
        iRawType = wkbMultiSurfaceZM;
    else if( iRawType == 2000011 )
        iRawType = wkbMultiPolygonZM;
    else if( iRawType == 2000012 )
        iRawType = wkbGeometryCollectionZM;
    else if( iRawType == 3000001 )
        iRawType = wkbPoint25D;
    else if( iRawType == 3000002 )
        iRawType = wkbLineString25D;
    else if( iRawType == 3000003 )
        iRawType = wkbCircularStringZ;
    else if( iRawType == 3000004 )
        iRawType = wkbCompoundCurveZ;
    else if( iRawType == 3000005 )
        iRawType = wkbPolygon25D;
    else if( iRawType == 3000006 )
        iRawType = wkbCurvePolygonZ;
    else if( iRawType == 3000007 )
        iRawType = wkbMultiPoint25D;
    else if( iRawType == 3000008 )
        iRawType = wkbMultiCurveZ;
    else if( iRawType == 3000009 )
        iRawType = wkbMultiLineString25D;
    else if( iRawType == 3000010 )
        iRawType = wkbMultiSurfaceZ;
    else if( iRawType == 3000011 )
        iRawType = wkbMultiPolygon25D;
    else if( iRawType == 3000012 )
        iRawType = wkbGeometryCollection25D;
    else if( iRawType == 4000001 )
        iRawType = wkbPointM;
    else if( iRawType == 4000002 )
        iRawType = wkbLineStringM;
    else if( iRawType == 4000003 )
        iRawType = wkbCircularStringM;
    else if( iRawType == 4000004 )
        iRawType = wkbCompoundCurveM;
    else if( iRawType == 4000005 )
        iRawType = wkbPolygonM;
    else if( iRawType == 4000006 )
        iRawType = wkbCurvePolygonM;
    else if( iRawType == 4000007 )
        iRawType = wkbMultiPointM;
    else if( iRawType == 4000008 )
        iRawType = wkbMultiCurveM;
    else if( iRawType == 4000009 )
        iRawType = wkbMultiLineStringM;
    else if( iRawType == 4000010 )
        iRawType = wkbMultiSurfaceM;
    else if( iRawType == 4000011 )
        iRawType = wkbMultiPolygonM;
    else if( iRawType == 4000012 )
        iRawType = wkbGeometryCollectionM;

    // Sometimes the Z flag is in the 2nd byte?
    if( iRawType & (wkb25DBitInternalUse >> 16) )
    {
        // Clean off top 3 bytes.
        iRawType &= 0x000000FF;
        bIs3D = true;
    }

    if( eWkbVariant == wkbVariantPostGIS1 )
    {
        if( iRawType == POSTGIS15_CURVEPOLYGON )
            iRawType = wkbCurvePolygon;
        else if( iRawType == POSTGIS15_MULTICURVE )
            iRawType = wkbMultiCurve;
        else if( iRawType == POSTGIS15_MULTISURFACE )
            iRawType = wkbMultiSurface;
    }

    if( bIs3D )
    {
        iRawType += 1000;
    }
    if( bIsMeasured )
    {
        iRawType += 2000;
    }

    // ISO SQL/MM style types are between 1-17, 1001-1017, 2001-2017, and
    // 3001-3017.
    if( !((iRawType > 0 && iRawType <= 17) ||
           (iRawType > 1000 && iRawType <= 1017) ||
           (iRawType > 2000 && iRawType <= 2017) ||
           (iRawType > 3000 && iRawType <= 3017)) )
    {
        CPLError(CE_Failure, CPLE_NotSupported,
                 ""Unsupported WKB type %d"", iRawType);
        return OGRERR_UNSUPPORTED_GEOMETRY_TYPE;
    }

    // Convert to OGRwkbGeometryType value.
    if( iRawType >= 1001 && iRawType <= 1007 )
    {
        iRawType -= 1000;
        iRawType |= wkb25DBitInternalUse;
    }

    *peGeometryType = static_cast<OGRwkbGeometryType>(iRawType);

    return OGRERR_NONE;
}

/************************************************************************/
/*                        OGRFormatFloat()                              */
/************************************************************************/

int  OGRFormatFloat(char *pszBuffer, int nBufferLen,
                    float fVal, int nPrecision, char chConversionSpecifier)
{
    int nSize = 0;
    char szFormatting[32] = {};
    constexpr int MAX_SIGNIFICANT_DIGITS_FLOAT32 = 8;
    const int nInitialSignificantFigures =
        nPrecision >= 0 ? nPrecision : MAX_SIGNIFICANT_DIGITS_FLOAT32;

    CPLsnprintf(szFormatting, sizeof(szFormatting),
                ""%%.%d%c"",
                nInitialSignificantFigures,
                chConversionSpecifier);
    nSize = CPLsnprintf(pszBuffer, nBufferLen, szFormatting, fVal);
    const char* pszDot = strchr(pszBuffer, '.');

    // Try to avoid 0.34999999 or 0.15000001 rounding issues by
    // decreasing a bit precision.
    if( nInitialSignificantFigures >= 8 &&
        pszDot != nullptr &&
        (strstr(pszDot, ""99999"") != nullptr ||
         strstr(pszDot, ""00000"") != nullptr) )
    {
        const CPLString osOriBuffer(pszBuffer, nSize);

        bool bOK = false;
        for( int i = 1; i <= 3; i++ )
        {
            CPLsnprintf(szFormatting, sizeof(szFormatting),
                        ""%%.%d%c"",
                        nInitialSignificantFigures - i,
                        chConversionSpecifier);
            nSize = CPLsnprintf(pszBuffer, nBufferLen,
                                szFormatting, fVal);
            pszDot = strchr(pszBuffer, '.');
            if( pszDot != nullptr &&
                strstr(pszDot, ""99999"") == nullptr &&
                strstr(pszDot, ""00000"") == nullptr &&
                static_cast<float>(CPLAtof(pszBuffer)) == fVal )
            {
                bOK = true;
                break;
            }
        }
        if( !bOK )
        {
            memcpy(pszBuffer, osOriBuffer.c_str(), osOriBuffer.size()+1);
            nSize = static_cast<int>(osOriBuffer.size());
        }
    }

    if( nSize+2 < static_cast<int>(nBufferLen) &&
        strchr(pszBuffer, '.') == nullptr &&
        strchr(pszBuffer, 'e') == nullptr )
    {
        nSize += CPLsnprintf(pszBuffer + nSize, nBufferLen - nSize, "".0"");
    }

    return nSize;
}
",16343,True,2648.489722710102,median